ngx-mat-lib
Version:
A bunch of utilities and components to use in your Angular 7+ apps!
222 lines (221 loc) • 24.9 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
import { Injectable } from "@angular/core";
import { HttpClient, HttpParams } from "@angular/common/http";
import { XmatConstantsService } from "./xmat-constants.service";
import { XmatResponseTypes, XmatRestVerbs } from "../models/index";
import { Observable, forkJoin } from "rxjs";
import { map } from "rxjs/operators";
import { forEach } from "lodash";
/**
* XMAT REST BY TONY SAMPERI
* extend this file by adding a public "serviceUrls" variable
* and optionally servicesConfigs
*
* CRUD-HTTP MAPPING
* POST Create Crea una nuova risorsa
* GET Read Ottiene una risorsa esistente
* PUT Update Aggiorna una risorsa o ne modifica lo stato
* DELETE Delete Elimina una risorsa
*/
export class XmatRestService {
/**
* @param {?} _http
* @param {?} _xmatConstants
*/
constructor(_http, _xmatConstants) {
this._http = _http;
this._xmatConstants = _xmatConstants;
// Sample data
this.servicesUrls = {};
this.servicesConfigs = {};
this._restBaseUrl = this._xmatConstants.restBaseUrl;
this._ds = this._xmatConstants.ds;
}
/**
* @param {?} file
* @param {?=} verb
* @param {?=} body
* @param {?=} onError
* @return {?}
*/
downloadBlobFromUrl(file, verb = XmatRestVerbs.GET, body, onError) {
/** @type {?} */
let call;
if (verb === XmatRestVerbs.GET) {
call = this.getBlobFromUrl(file, verb);
}
if (verb === XmatRestVerbs.PATCH) {
call = this.getBlobFromUrl(file, verb, body);
}
call.subscribe((results) => {
// IE DOESN'T SUPPORT TRIGGERING SO WE START DOWNLOADING WITH THIS PORKAROUND
if (window.navigator.msSaveOrOpenBlob) {
window.navigator.msSaveOrOpenBlob(results, file.fileName);
}
else {
/** @type {?} */
const unsafeUrl = URL.createObjectURL(results);
/** @type {?} */
const linkEl = document.createElement("a");
linkEl.setAttribute("href", unsafeUrl);
linkEl.setAttribute("download", file.fileName);
document.body.appendChild(linkEl);
linkEl.click();
document.body.removeChild(linkEl);
}
}, (err) => {
typeof onError === typeof isNaN && onError(err);
});
}
/**
* @param {?} file
* @param {?=} verb
* @param {?=} body
* @return {?}
*/
getBlobFromUrl(file, verb = XmatRestVerbs.GET, body) {
if (!file || !file.url) {
console.error("XmatRest: invalid XmatFile provided!", file);
return void 0;
}
// Use a default fileName if not set
if (!file.fileName || !file.fileName.length) {
/** @type {?} */
const ext = file.url.substr(file.url.lastIndexOf("."));
file.fileName = `xmat-document${ext}`;
}
if (verb === XmatRestVerbs.GET) {
return this._http.get(file.url, {
responseType: XmatResponseTypes.blob
});
}
if (verb === XmatRestVerbs.PATCH) {
return this._http.patch(file.url, body, {
responseType: XmatResponseTypes.blob
});
}
throw new Error(`XmatRest: invalid verb provided for 'getBlobFromUrl'. Expected GET|PATCH, got ${verb}`);
}
/**
* @param {?} configs
* @return {?}
*/
$all(configs) {
/** @type {?} */
const queue = [];
forEach(configs, (c) => {
queue.push(this.$http(c));
});
return forkJoin(queue);
}
/**
* @template T, U
* @param {?} configs
* @return {?}
*/
$allMap(configs) {
/** @type {?} */
const queue = [];
/** @type {?} */
const queueKeys = [];
forEach(configs, (c, key) => {
queue.push(this.$http(c));
queueKeys.push(key);
});
return forkJoin(queue)
.pipe(map((raw) => {
/** @type {?} */
const mapped = {};
forEach(raw, (value, index) => {
mapped[queueKeys[index]] = value;
});
return mapped;
}));
}
/**
* @template T
* @param {?=} config
* @return {?}
*/
$http(config = this._generateHttpConfig()) {
if (!config.method) {
config.method = XmatRestVerbs.GET;
}
if (!config.url) {
console.error("Error: [$http:badconfig]", config);
return new Observable();
}
switch (config.method) {
case XmatRestVerbs.GET:
/** @type {?} */
let params = config.params || new HttpParams();
/**
* Transform data in query params
*/
if (!!config.data) {
// Accepting 0, null, void 0 as empty params
if (this._xmatConstants.isStrictlyObject(config.data)) {
forEach(Object.keys(config.data), (key) => {
params = params.append(key, config.data[key]);
});
}
else {
console.warn("Error: [XmatRest:badparams]");
}
}
return this._http.get(config.url, { params: params });
case XmatRestVerbs.PATCH:
return this._http.patch(config.url, config.data, { params: config.params });
case XmatRestVerbs.POST:
return this._http.post(config.url, config.data, { params: config.params });
case XmatRestVerbs.DELETE:
return this._http.delete(config.url, { params: config.params });
case XmatRestVerbs.PUT:
return this._http.put(config.url, config.data, { params: config.params });
default:
console.error("Error: [XmatRest:badmethod]", arguments);
return new Observable();
}
}
/**
* @param {?=} method
* @param {?=} url
* @param {?=} queryable
* @return {?}
*/
_generateHttpConfig(method = XmatRestVerbs.GET, url = "", queryable = false) {
url = this._xmatConstants.removeTrailingSlash(url);
return /** @type {?} */ ({
method: method,
url: url,
data: void 0,
queryable: queryable
});
}
}
XmatRestService.decorators = [
{ type: Injectable }
];
/** @nocollapse */
XmatRestService.ctorParameters = () => [
{ type: HttpClient },
{ type: XmatConstantsService }
];
if (false) {
/** @type {?} */
XmatRestService.prototype.servicesUrls;
/** @type {?} */
XmatRestService.prototype.servicesConfigs;
/** @type {?} */
XmatRestService.prototype._restBaseUrl;
/** @type {?} */
XmatRestService.prototype._ds;
/** @type {?} */
XmatRestService.prototype._http;
/** @type {?} */
XmatRestService.prototype._xmatConstants;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xmat-rest.service.js","sourceRoot":"ng://ngx-mat-lib/","sources":["lib/services/xmat-rest.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\nimport { HttpClient, HttpParams } from \"@angular/common/http\";\n//\nimport { XmatConstantsService } from \"./xmat-constants.service\";\nimport {\n    XmatFile,\n    XmatHttpConfig,\n    XmatResponseTypes,\n    XmatRestVerbs\n} from \"../models/index\";\nimport { XmatGenericObject } from \"../models/index\";\n//\nimport { Observable, forkJoin, throwError } from \"rxjs\";\nimport { map } from \"rxjs/operators\";\nimport { forEach } from \"lodash\";\n\n/**\n * XMAT REST BY TONY SAMPERI\n * extend this file by adding a public \"serviceUrls\" variable\n * and optionally servicesConfigs\n *\n * CRUD-HTTP MAPPING\n * POST        Create        Crea una nuova risorsa\n * GET        Read        Ottiene una risorsa esistente\n * PUT        Update    Aggiorna una risorsa o ne modifica lo stato\n * DELETE    Delete    Elimina una risorsa\n */\n\n@Injectable()\nexport class XmatRestService {\n\n    // Sample data\n    readonly servicesUrls = {\n        /**\n         *  myServiceA: \"my-service-a\"\n         *  myServiceA: \"my-service-b\"\n         */\n    };\n\n    readonly servicesConfigs = {\n        /**\n         * myServiceA: {\n         *     get: (): XmatHttpConfig => {\n         *         return this._generateHttpConfig(XmatRestVerbs.GET, this.servicesUrls.myServiceA, true);\n         *     },\n         *     post: (): XmatHttpConfig => {\n         *         return this._generateHttpConfig(XmatRestVerbs.POST, this.servicesUrls.myServiceA);\n         *     }\n         * },\n         * myServiceB: (): XmatHttpConfig => {\n         *     return this._generateHttpConfig(XmatRestVerbs.GET, this.servicesUrls.myServiceA, true);\n         * }\n         */\n    };\n\n    protected _restBaseUrl = this._xmatConstants.restBaseUrl;\n    protected _ds = this._xmatConstants.ds;\n\n    constructor(protected _http: HttpClient,\n        protected _xmatConstants: XmatConstantsService) {\n\n    }\n\n    downloadBlobFromUrl(file: XmatFile, verb?: XmatRestVerbs.GET, onError?: (err: any) => void): void;\n    downloadBlobFromUrl(file: XmatFile, verb: XmatRestVerbs.PATCH, body: any, onError?: (err: any) => void): void;\n    downloadBlobFromUrl(\n        file: XmatFile,\n        verb: XmatRestVerbs.GET | XmatRestVerbs.PATCH = XmatRestVerbs.GET,\n        body?: any | void,\n        onError?: (err: any) => void\n    ): void {\n        let call;\n        if (verb === XmatRestVerbs.GET) {\n            call = this.getBlobFromUrl(file, verb);\n        }\n        if (verb === XmatRestVerbs.PATCH) {\n            call = this.getBlobFromUrl(file, verb, body);\n        }\n\n        call.subscribe((results: Blob) => {\n            // IE DOESN'T SUPPORT TRIGGERING SO WE START DOWNLOADING WITH THIS PORKAROUND\n            if (window.navigator.msSaveOrOpenBlob) {\n                window.navigator.msSaveOrOpenBlob(results, file.fileName);\n            }\n            else {\n                const unsafeUrl = URL.createObjectURL(results);\n                const linkEl: HTMLElement = document.createElement(\"a\");\n                linkEl.setAttribute(\"href\", unsafeUrl);\n                linkEl.setAttribute(\"download\", file.fileName);\n\n                document.body.appendChild(linkEl);\n                linkEl.click();\n                document.body.removeChild(linkEl);\n            }\n        }, (err: any) => {\n            typeof onError === typeof isNaN && onError(err);\n        });\n    }\n\n    getBlobFromUrl(file: XmatFile, verb?: XmatRestVerbs.GET): Observable<Blob>;\n    getBlobFromUrl(file: XmatFile, verb: XmatRestVerbs.PATCH, body: any): Observable<Blob>;\n    getBlobFromUrl(file: XmatFile, verb: XmatRestVerbs.GET | XmatRestVerbs.PATCH = XmatRestVerbs.GET, body?: any): Observable<Blob> {\n        if (!file || !file.url) {\n            console.error(\"XmatRest: invalid XmatFile provided!\", file);\n            return void 0;\n        }\n        // Use a default fileName if not set\n        if (!file.fileName || !file.fileName.length) {\n            const ext = file.url.substr(file.url.lastIndexOf(\".\"));\n            file.fileName = `xmat-document${ext}`;\n        }\n\n        if (verb === XmatRestVerbs.GET) {\n            return this._http.get(file.url, {\n                responseType: XmatResponseTypes.blob\n            });\n        }\n        if (verb === XmatRestVerbs.PATCH) {\n            return this._http.patch(file.url, body, {\n                responseType: XmatResponseTypes.blob\n            });\n        }\n\n        throw new Error(`XmatRest: invalid verb provided for 'getBlobFromUrl'. Expected GET|PATCH, got ${verb}`);\n    }\n\n    $all(configs: XmatHttpConfig[]): Observable<any[]> {\n        const queue: Observable<any>[] = [];\n        forEach(configs, (c: XmatHttpConfig) => {\n            queue.push(this.$http(c));\n        });\n\n        return forkJoin(queue);\n    }\n\n    $allMap<T extends XmatGenericObject<XmatHttpConfig>, U = any>(configs: T): Observable<XmatGenericObject<U>> {\n        const queue: Observable<any>[] = [];\n        const queueKeys: Array<number | string> = [];\n        forEach(configs, (c: XmatHttpConfig, key: string | number) => {\n            queue.push(this.$http(c));\n            queueKeys.push(key);\n        });\n        return forkJoin(queue)\n            .pipe(map((raw: any[]) => {\n                const mapped = {};\n                forEach(raw, (value, index) => {\n                    mapped[queueKeys[index]] = value;\n                });\n\n                return mapped;\n            }));\n    }\n\n    $http<T>(config: XmatHttpConfig = this._generateHttpConfig()): Observable<T> {\n        if (!config.method) {\n            config.method = XmatRestVerbs.GET;\n        }\n        if (!config.url) {\n            console.error(\"Error: [$http:badconfig]\", config);\n            return new Observable();\n        }\n        switch (config.method) {\n            case XmatRestVerbs.GET:\n                let params = config.params || new HttpParams();\n                /**\n                 * Transform data in query params\n                 */\n                if (!!config.data) {\n                    // Accepting 0, null, void 0 as empty params\n                    if (this._xmatConstants.isStrictlyObject(config.data)) {\n                        forEach(Object.keys(config.data), (key: string) => {\n                            params = params.append(key, config.data[key]);\n                        });\n                    }\n                    else {\n                        console.warn(\"Error: [XmatRest:badparams]\");\n                    }\n                }\n                return this._http.get<T>(config.url, { params: params });\n            case XmatRestVerbs.PATCH:\n                return this._http.patch<T>(config.url, config.data, { params: config.params });\n            case XmatRestVerbs.POST:\n                return this._http.post<T>(config.url, config.data, { params: config.params });\n            case XmatRestVerbs.DELETE:\n                return this._http.delete<T>(config.url, { params: config.params });\n            case XmatRestVerbs.PUT:\n                return this._http.put<T>(config.url, config.data, { params: config.params });\n            default:\n                console.error(\"Error: [XmatRest:badmethod]\", arguments);\n                return new Observable();\n        }\n    }\n\n    protected _generateHttpConfig(method: XmatRestVerbs = XmatRestVerbs.GET, url: string = \"\", queryable: boolean = false): XmatHttpConfig {\n        url = this._xmatConstants.removeTrailingSlash(url);\n        return {\n            method: method,\n            url: url,\n            data: void 0,\n            queryable: queryable\n        } as XmatHttpConfig;\n    }\n}\n\n\n"]}