@ngx-resource/handler-ngx-http-legacy/src/ResourceHandlerHttp.js

Resource handler Angular old http

var __extends = (this && this.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
import { Injectable } from '@angular/core';
import { Http, Request, RequestMethod, ResponseContentType } from '@angular/http';
import { ResourceRequestMethod, ResourceResponseBodyType } from '@ngx-resource/core';
import { ResourceHandlerAbstract } from './ResourceHandlerAbstract';
var ResourceHandlerHttp = /** @class */ (function (_super) {
    __extends(ResourceHandlerHttp, _super);
    function ResourceHandlerHttp(http) {
        var _this = _super.call(this) || this;
        _this.http = http;
        return _this;
    }
    ResourceHandlerHttp.prototype.request = function (request) {
        return this.http.request(request);
    };
    ResourceHandlerHttp.prototype.prepareRequest = function (req) {
        var options = {
            url: req.url,
            body: req.body,
            withCredentials: req.withCredentials
        };
        switch (req.method) {
            case ResourceRequestMethod.Get:
                options.method = RequestMethod.Get;
                break;
            case ResourceRequestMethod.Post:
                options.method = RequestMethod.Post;
                break;
            case ResourceRequestMethod.Put:
                options.method = RequestMethod.Put;
                break;
            case ResourceRequestMethod.Delete:
                options.method = RequestMethod.Delete;
                break;
            case ResourceRequestMethod.Head:
                options.method = RequestMethod.Head;
                break;
            case ResourceRequestMethod.Options:
                options.method = RequestMethod.Options;
                break;
            case ResourceRequestMethod.Patch:
                options.method = RequestMethod.Patch;
        }
        switch (req.responseBodyType) {
            case ResourceResponseBodyType.Json:
                options.responseType = ResponseContentType.Json;
                break;
            case ResourceResponseBodyType.ArrayBuffer:
                options.responseType = ResponseContentType.ArrayBuffer;
                break;
            case ResourceResponseBodyType.Blob:
                options.responseType = ResponseContentType.Blob;
                break;
            default:
                options.responseType = ResponseContentType.Text;
        }
        if (req.headers) {
            options.headers = req.headers;
        }
        if (req.query) {
            options.params = req.query;
        }
        return new Request(options);
    };
    ResourceHandlerHttp.prototype.handleResponse = function (req, response) {
        var body;
        switch (req.responseBodyType) {
            case ResourceResponseBodyType.Json:
                body = response.json();
                break;
            case ResourceResponseBodyType.ArrayBuffer:
                body = response.arrayBuffer();
                break;
            case ResourceResponseBodyType.Blob:
                body = response.blob();
                break;
            default:
                body = response.text();
        }
        return {
            status: response.status,
            body: body,
            headers: response.headers.toJSON()
        };
    };
    ResourceHandlerHttp.decorators = [
        { type: Injectable },
    ];
    /** @nocollapse */
    ResourceHandlerHttp.ctorParameters = function () { return [
        { type: Http, },
    ]; };
    return ResourceHandlerHttp;
}(ResourceHandlerAbstract));
export { ResourceHandlerHttp };