@netgrif/components-core
Version:
Netgrif Application engine frontend core Angular library
167 lines • 23.2 kB
JavaScript
import { HttpEventType, HttpParams } from '@angular/common/http';
import { Injectable } from '@angular/core';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common/http";
export var ProgressType;
(function (ProgressType) {
ProgressType["UPLOAD"] = "upload";
ProgressType["DOWNLOAD"] = "download";
})(ProgressType || (ProgressType = {}));
export class AbstractResourceProvider {
httpClient;
constructor(httpClient) {
this.httpClient = httpClient;
}
static addLastSlash(link) {
if (link.length > 0) {
return link.charAt(link.length - 1) === '/' ? link : link + '/';
}
else {
throw Error('No define api url');
}
}
static removeFirstSlash(link) {
return link.charAt(0) === '/' ? link.length > 1 ? link.substring(1, link.length) : '' : link;
}
static sanitizeUrl(endpoint, url) {
if (endpoint?.includes('http://') || (endpoint?.includes('https://'))) {
if (url) {
if (endpoint?.includes(url)) {
return endpoint;
}
else {
return url?.includes('https://') ? 'https://' +
endpoint?.replace(/(^\w+:|^)\/\//, '') : 'http://' +
endpoint?.replace(/(^\w+:|^)\/\//, '');
}
}
else {
return endpoint;
}
}
else {
if (url) {
return AbstractResourceProvider.addLastSlash(url) + AbstractResourceProvider.removeFirstSlash(endpoint);
}
else {
throw Error('No define endpoint');
}
}
}
/**
* Combines two instances of {@link Params} type into one.
* If a parameter is declared in both instances uses the value of the `highPriorityParams` in the result.
* @param highPriorityParams parameters with the higher priority
* @param lowPriorityParams parameters with the lower priority
* @returns combination of botch parameters. Uses the value of the higher priority parameters if the keys are in conflict.
*/
static combineParams(highPriorityParams, lowPriorityParams) {
const importantParams = highPriorityParams instanceof HttpParams ?
ResourceProvider.convertHttpParamsToObjectParams(highPriorityParams) :
highPriorityParams;
const params = lowPriorityParams instanceof HttpParams ?
ResourceProvider.convertHttpParamsToObjectParams(lowPriorityParams) :
{ ...lowPriorityParams };
Object.assign(params, importantParams);
return new HttpParams({ fromObject: params });
}
/**
* Converts {@link HttpParams} instance into a simple object.
* @param params instance to convert
* @returns simple object with keys and values from the input argument
*/
static convertHttpParamsToObjectParams(params) {
const result = {};
params.keys().forEach(key => {
const values = params.getAll(key);
if (values.length === 1) {
result[key] = values[0];
}
else {
result[key] = values;
}
});
return result;
}
static getProgress(event) {
return {
type: event.type === HttpEventType.UploadProgress ? ProgressType.UPLOAD : ProgressType.DOWNLOAD,
loaded: event.loaded,
total: event.total,
progress: event.loaded && event.total ? Math.round(event.loaded * 100 / event.total) : undefined
};
}
static processMessageResource(response) {
const resource = response.type === HttpEventType.Response ?
response.body : response;
if (!!resource && resource.error) {
throw new Error(resource.error);
}
return resource;
}
get$(endpoint, url, params, headers, responseType) {
return this.httpClient.get(AbstractResourceProvider.sanitizeUrl(endpoint, url), {
headers,
params,
responseType: 'json',
observe: 'body'
});
}
getBlob$(endpoint, url, params, headers) {
return this.httpClient.get(AbstractResourceProvider.sanitizeUrl(endpoint, url), {
params,
headers,
observe: 'events',
responseType: 'blob',
reportProgress: true
});
}
post$(endpoint, url, body, params, headers, responseType) {
return this.httpClient.post(AbstractResourceProvider.sanitizeUrl(endpoint, url), body, {
headers,
params,
responseType: 'json',
observe: 'body'
});
}
postWithEvent$(endpoint, url, body, params, headers, responseType) {
return this.httpClient.post(AbstractResourceProvider.sanitizeUrl(endpoint, url), body, {
params,
headers,
responseType: 'json',
observe: 'events',
reportProgress: true
});
}
put$(endpoint, url, body, params, headers, responseType) {
return this.httpClient.put(AbstractResourceProvider.sanitizeUrl(endpoint, url), body, {
headers,
params,
responseType: 'json',
observe: 'body'
});
}
delete$(endpoint, url, params, headers, responseType, body) {
return this.httpClient.delete(AbstractResourceProvider.sanitizeUrl(endpoint, url), {
headers,
params,
responseType: 'json',
observe: 'body',
body
});
}
}
export class ResourceProvider extends AbstractResourceProvider {
constructor(httpClient) {
super(httpClient);
}
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ResourceProvider, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ResourceProvider, providedIn: 'root' });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ResourceProvider, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: i1.HttpClient }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-provider.service.js","sourceRoot":"","sources":["../../../../../projects/netgrif-components-core/src/lib/resources/resource-provider.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {HttpClient, HttpEvent, HttpEventType, HttpHeaders, HttpParams, HttpProgressEvent, HttpResponse} from '@angular/common/http';\nimport {Observable} from 'rxjs';\nimport {Injectable} from '@angular/core';\nimport {MessageResource} from './interface/message-resource';\n\n\nexport type Headers =\n    HttpHeaders | {\n    [header: string]: string | Array<string>;\n};\n\nexport type Params = HttpParams | ObjectParams;\n\nexport type ResponseType = 'json' | 'hal';\n\nexport interface ObjectParams {\n    [param: string]: string | Array<string>;\n}\n\nexport enum ProgressType {\n    UPLOAD = 'upload',\n    DOWNLOAD = 'download'\n}\n\nexport interface ProviderProgress {\n    type: ProgressType;\n    loaded: number;\n    total?: number;\n    progress?: number;\n}\n\n\nexport abstract class AbstractResourceProvider {\n\n    protected constructor(protected httpClient: HttpClient) {\n    }\n\n    private static addLastSlash(link: string): string {\n        if (link.length > 0) {\n            return link.charAt(link.length - 1) === '/' ? link : link + '/';\n        } else {\n            throw Error('No define api url');\n        }\n    }\n\n    private static removeFirstSlash(link: string): string {\n        return link.charAt(0) === '/' ? link.length > 1 ? link.substring(1, link.length) : '' : link;\n    }\n\n\n    public static sanitizeUrl(endpoint?: string, url?: string): string {\n        if (endpoint?.includes('http://') || (endpoint?.includes('https://'))) {\n            if (url) {\n                if (endpoint?.includes(url)) {\n                    return endpoint;\n                } else {\n                    return url?.includes('https://') ? 'https://' +\n                        endpoint?.replace(/(^\\w+:|^)\\/\\//, '') : 'http://' +\n                        endpoint?.replace(/(^\\w+:|^)\\/\\//, '');\n                }\n            } else {\n                return endpoint;\n            }\n        } else {\n            if (url) {\n                return AbstractResourceProvider.addLastSlash(url) + AbstractResourceProvider.removeFirstSlash(endpoint);\n            } else {\n                throw Error('No define endpoint');\n            }\n        }\n    }\n\n    /**\n     * Combines two instances of {@link Params} type into one.\n     * If a parameter is declared in both instances uses the value of the `highPriorityParams` in the result.\n     * @param highPriorityParams parameters with the higher priority\n     * @param lowPriorityParams parameters with the lower priority\n     * @returns combination of botch parameters. Uses the value of the higher priority parameters if the keys are in conflict.\n     */\n    public static combineParams(highPriorityParams: Params, lowPriorityParams: Params): HttpParams {\n        const importantParams = highPriorityParams instanceof HttpParams ?\n            ResourceProvider.convertHttpParamsToObjectParams(highPriorityParams) :\n            highPriorityParams;\n        const params = lowPriorityParams instanceof HttpParams ?\n            ResourceProvider.convertHttpParamsToObjectParams(lowPriorityParams) :\n            {...lowPriorityParams};\n        Object.assign(params, importantParams);\n        return new HttpParams({fromObject: params});\n    }\n\n    /**\n     * Converts {@link HttpParams} instance into a simple object.\n     * @param params instance to convert\n     * @returns simple object with keys and values from the input argument\n     */\n    public static convertHttpParamsToObjectParams(params: HttpParams): ObjectParams {\n        const result = {};\n        params.keys().forEach(key => {\n            const values = params.getAll(key);\n            if (values.length === 1) {\n                result[key] = values[0];\n            } else {\n                result[key] = values;\n            }\n        });\n        return result;\n    }\n\n    public static getProgress(event: HttpProgressEvent): ProviderProgress {\n        return {\n            type: event.type === HttpEventType.UploadProgress ? ProgressType.UPLOAD : ProgressType.DOWNLOAD,\n            loaded: event.loaded,\n            total: event.total,\n            progress: event.loaded && event.total ? Math.round(event.loaded * 100 / event.total) : undefined\n        };\n    }\n\n    public static processMessageResource(response: MessageResource | HttpResponse<MessageResource>): MessageResource {\n        const resource: MessageResource = (response as HttpResponse<MessageResource>).type === HttpEventType.Response ?\n            (response as HttpResponse<MessageResource>).body : response as MessageResource;\n        if (!!resource && resource.error) {\n            throw new Error(resource.error);\n        }\n        return resource;\n    }\n\n    public get$<T>(endpoint?: string, url ?: string, params ?: Params, headers ?: Headers,\n                   responseType ?: ResponseType): Observable<T> {\n        return this.httpClient.get<T>(AbstractResourceProvider.sanitizeUrl(endpoint, url),\n            {\n                headers,\n                params,\n                responseType: 'json',\n                observe: 'body'\n            });\n    }\n\n    public getBlob$(endpoint?: string, url ?: string, params ?: Params, headers?: Headers): Observable<HttpEvent<Blob>> {\n        return this.httpClient.get(AbstractResourceProvider.sanitizeUrl(endpoint, url),\n            {\n                params,\n                headers,\n                observe: 'events',\n                responseType: 'blob',\n                reportProgress: true\n            });\n    }\n\n    public post$<T>(endpoint?: string, url ?: string, body ?: object, params ?: Params, headers ?: Headers,\n                    responseType ?: ResponseType): Observable<T> {\n        return this.httpClient.post<T>(AbstractResourceProvider.sanitizeUrl(endpoint, url),\n            body,\n            {\n                headers,\n                params,\n                responseType: 'json',\n                observe: 'body'\n            });\n    }\n\n    public postWithEvent$<T>(endpoint?: string, url ?: string, body ?: object, params ?: Params, headers?: Headers,\n                             responseType ?: ResponseType): Observable<HttpEvent<T>> {\n        return this.httpClient.post<T>(AbstractResourceProvider.sanitizeUrl(endpoint, url),\n            body,\n            {\n                params,\n                headers,\n                responseType: 'json',\n                observe: 'events',\n                reportProgress: true\n            });\n    }\n\n    public put$<T>(endpoint?: string, url ?: string, body ?: object, params ?: Params, headers ?: Headers,\n                   responseType ?: ResponseType): Observable<T> {\n        return this.httpClient.put<T>(AbstractResourceProvider.sanitizeUrl(endpoint, url),\n            body,\n            {\n                headers,\n                params,\n                responseType: 'json',\n                observe: 'body'\n            });\n    }\n\n    public delete$<T>(endpoint?: string, url?: string, params ?: Params, headers ?: Headers,\n                      responseType ?: ResponseType, body?: object,): Observable<T> {\n        return this.httpClient.delete<T>(AbstractResourceProvider.sanitizeUrl(endpoint, url), {\n            headers,\n            params,\n            responseType: 'json',\n            observe: 'body',\n            body\n        });\n    }\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class ResourceProvider extends AbstractResourceProvider {\n    constructor(httpClient: HttpClient) {\n        super(httpClient);\n    }\n\n}\n"]}