node-webplay/bin/core/httprequest.js

A nodejs streaming server implementation

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _request = require("request");

var _request2 = _interopRequireDefault(_request);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function blobToBuffer(blob, cb) {
    if (typeof Blob === "undefined" || !(blob instanceof Blob)) {
        throw new Error("first argument must be a Blob");
    }
    if (typeof cb !== "function") {
        throw new Error("second argument must be a function");
    }

    var reader = new FileReader();

    function onLoadEnd(e) {
        reader.removeEventListener("loadend", onLoadEnd, false);
        if (e.error) cb(e.error);else cb(null, new Buffer(reader.result));
    }

    reader.addEventListener("loadend", onLoadEnd, false);
    reader.readAsArrayBuffer(blob);
}

function _req(opts, resolve, reject) {
    (0, _request2.default)(opts, function (error, res, b) {
        if (null != error) {
            //console.log("httprequest error", error.message);
            reject(error);
        } else {
            //console.log("httprequest response" , res.statusCode);

            var statusCode = res.statusCode;

            if (res.statusCode >= 200 && res.statusCode < 300) {
                resolve({ response: res, body: b });
            } else {
                var _error = new Error("Request Failed.\n" + ("Status Code: " + statusCode));

                _error["body"] = b;
                _error["statusCode"] = statusCode;
                _error["headers"] = res.heders;

                reject(_error);
            }
        }
    });
}

function req(opts) {
    return new Promise(function (resolve, reject) {

        var def = true;
        try {
            undefined === Blob;
        } catch (err) {
            def = false;
        }

        if (!def || !(opts.body instanceof Blob)) {
            _req(opts, resolve, reject);
        } else {
            blobToBuffer(opts.body, function (err, buffer) {
                if (null != err) reject(err);else {
                    opts.body = buffer;
                    _req(opts, resolve, reject);
                }
            });
        }
    });
}

var httprequest = function () {
    function httprequest() {
        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;

        _classCallCheck(this, httprequest);

        this._opt = {};

        if (null != process) {
            if (null != process.env) if (null != process.env.http_proxy) this._opt.proxy = process.env.http_proxy;
        }

        if (null != options) {
            Object.assign(this._opt, options);
        }
    }

    _createClass(httprequest, [{
        key: "get",
        value: function get(url) {

            this._opt.method = "GET";
            this._opt.uri = url;

            return req(this._opt);
        }
    }, {
        key: "put",
        value: function put(url, body) {

            this._opt.method = "PUT";
            this._opt.uri = url;

            this._opt.body = body;

            return req(this._opt);
        }
    }]);

    return httprequest;
}();

exports.default = httprequest;
//# sourceMappingURL=httprequest.js.map