ng2-rest/browser/resource.service.js

import { Subject } from 'rxjs/Subject';
import 'rxjs/add/operator/map';
import 'rxjs/add/operator/takeUntil';
import 'rxjs/add/operator/take';
import 'rxjs/add/operator/toPromise';
import { Log, Level } from 'ng2-logger/browser';
const log = Log.create('resouce-service', Level.__NOTHING);
import { Rest } from './rest.class';
import { RestRequest } from './rest-request';
import { RestHeaders } from './rest-headers';
import { Cookie } from './cookie';
import { interpolateParamsToUrl, isValid, containsModels, getModels } from './params';
//#endregion
export class Resource {
    //#endregion
    //#region constructor
    constructor() {
        setTimeout(() => {
            const zone = this.getZone();
            if (!RestRequest.zone)
                RestRequest.zone = zone;
        });
    }
    static get listenErrors() {
        return this._listenErrors.asObservable();
    }
    //#region private mthods and fields
    getZone() {
        const isNode = (typeof window === 'undefined');
        if (isNode)
            return;
        const ng = window['ng'];
        const getAllAngularRootElements = window['getAllAngularRootElements'];
        if (!ng || !getAllAngularRootElements)
            return;
        const probe = ng.probe;
        const coreTokens = ng.coreTokens;
        if (!coreTokens.NgZone)
            return;
        const zoneClass = coreTokens.NgZone;
        if (!probe || typeof probe !== 'function' || !getAllAngularRootElements)
            return;
        const angularElements = getAllAngularRootElements();
        if (!Array.isArray(angularElements) || angularElements.length === 0)
            return;
        const rootElement = ng.probe(angularElements[0]);
        if (!rootElement)
            return;
        const injector = rootElement.injector;
        if (!injector || !injector.get || typeof injector.get !== 'function')
            return;
        const zone = injector.get(zoneClass);
        return zone;
    }
    static initAngularNgZone(zone) {
        RestRequest.zone = zone;
    }
    checkNestedModels(model, allModels) {
        // if (model.indexOf('/') !== -1) { //TODO make this better, becouse now I unecesary checking shit
        for (let p in allModels) {
            if (allModels.hasOwnProperty(p)) {
                let m = allModels[p];
                if (isValid(p)) {
                    let urlModels = getModels(p);
                    if (containsModels(model, urlModels)) {
                        model = p;
                        break;
                    }
                }
            }
        }
        // }
        return model;
    }
    static getModel(endpoint, model) {
        model = Resource.prepareModel(model);
        const e = Resource.endpoints[endpoint];
        if (!e)
            return undefined;
        const r = Resource.endpoints[endpoint].models[model];
        return Resource.endpoints[endpoint].models[model];
    }
    //#endregion
    //#region create
    static create(e, model, entityMapping, circular) {
        const badRestRegEX = new RegExp('((\/:)[a-z]+)+', 'g');
        const matchArr = model.match(badRestRegEX) || [];
        const badModelsNextToEachOther = matchArr.join();
        const atleas2DoubleDots = ((badModelsNextToEachOther.match(new RegExp(':', 'g')) || []).length >= 2);
        if (atleas2DoubleDots && model.search(badModelsNextToEachOther) !== -1) {
            throw new Error(`

Bad rest model: ${model}

Do not create rest models like this:    /book/author/:bookid/:authorid
Instead use nested approach:            /book/:bookid/author/:authorid
            `);
        }
        ;
        Resource.map(e, e);
        Resource.instance.add(e, model ? model : '', entityMapping, circular);
        // if (model.charAt(model.length - 1) !== '/') model = `${model}/`;
        return {
            model: (params) => Resource.instance.api(e, interpolateParamsToUrl(params, model)),
            replay: (method) => {
                Resource.getModel(e, model).replay(method);
            },
            get headers() {
                return Resource.getModel(e, model).headers;
            }
        };
    }
    //#endregion
    //#region reset
    static reset() {
        Resource.endpoints = {};
    }
    //#region map
    static map(endpoint, url) {
        log.i('url', url);
        let regex = /(http|https):\/\/(\w+:{0,1}\w*)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%!\-\/]))?/;
        let e = endpoint;
        if (!regex.test(url)) {
            throw `Url address is not correct: ${url}`;
        }
        if (url.charAt(url.length - 1) === '/')
            url = url.slice(0, url.length - 1);
        log.i('url after', url);
        if (Resource.endpoints[e] !== undefined) {
            if (Resource.enableWarnings)
                console.warn('Cannot use map function at the same API endpoint again ('
                    + Resource.endpoints[e].url + ')');
            return false;
        }
        Resource.endpoints[e] = {
            url: url,
            models: {},
            entity: null
        };
        log.i('enpoints', Resource.endpoints);
        return true;
    }
    //#endregion
    static prepareModel(model) {
        if (model.charAt(model.length - 1) === '/')
            model = model.slice(0, model.length - 1);
        if (model.charAt(0) === '/')
            model = model.slice(1, model.length);
        return model;
    }
    //#region add
    /**
     * And enipoint to application
     *
     * @param {E} endpoint
     * @param {string} model
     * @returns {boolean}
     */
    add(endpoint, model, entity, circular) {
        log.i(`I am maping ${model} on ${endpoint}`);
        model = Resource.prepareModel(model);
        let e;
        e = (endpoint).toString();
        if (Resource.endpoints[e] === undefined) {
            console.error('Endpoint is not mapped ! Cannot add model ' + model);
            return;
        }
        if (Resource.endpoints[e].models[model] !== undefined) {
            if (Resource.enableWarnings)
                console.warn(`Model '${model}' is already defined in endpoint: `
                    + Resource.endpoints[e].url);
            return;
        }
        Resource.endpoints[e].models[model] =
            new Rest(Resource.endpoints[e].url
                + '/' + model, Resource.request, {
                endpoint: e,
                path: model,
                entity,
                circular
            });
        return;
    }
    //#endregion
    //#region api
    /**
     * Access api throught endpoint
     *
     * @param {E} endpoint
     * @param {string} model
     * @returns {Rest<T, TA>}
     */
    api(endpoint, model) {
        if (model.charAt(0) === '/')
            model = model.slice(1, model.length);
        let e = (endpoint).toString();
        if (Resource.endpoints[e] === undefined) {
            throw `Endpoint: ${endpoint} is not mapped ! Cannot add model: ${model}`;
        }
        let allModels = Resource.endpoints[e].models;
        let orgModel = model;
        model = this.checkNestedModels(model, allModels);
        if (Resource.endpoints[e].models[model] === undefined) {
            log.d('Resource.endpoints', Resource.endpoints);
            throw `Model '${model}' is undefined in endpoint: ${Resource.endpoints[e].url} `;
        }
        let res = Resource.endpoints[(endpoint).toString()].models[model];
        if (orgModel !== model) {
            let baseUrl = Resource.endpoints[(endpoint).toString()].url;
            log.d('base', Resource.endpoints[(endpoint).toString()]);
            log.d('baseUrl', baseUrl);
            log.d('orgModel', orgModel);
            res.__rest_endpoint = `${baseUrl}/${orgModel}`;
        }
        else
            res.__rest_endpoint = undefined;
        return res;
    }
}
Resource.DEFAULT_HEADERS = RestHeaders.from({
    'Content-Type': 'application/json',
    'Accept': 'application/json'
});
Resource._listenErrors = new Subject();
Resource.enableWarnings = true;
Resource.instance = new Resource();
Resource.endpoints = {};
Resource.request = new RestRequest();
//#endregion
Resource.Cookies = Cookie.Instance;
// const res = Resource.create('')
// res.model()
//   .mock({
//     code: 500,
//     data: {},
//     isArray: true
//   })
//   .array.
//# sourceMappingURL=resource.service.js.map