brainloper-ui 15.0.1 → 17.0.0

package/esm2022/src/app/modules/services/http.service.mjs

@@ -0,0 +1,142 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { HttpResponseType } from '../interfaces/enum/httpResponseType';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./message.service";
+export class HttpService {
+    http;
+    message;
+    constructor(http, message) {
+        this.http = http;
+        this.message = message;
+    }
+    createParams(params) {
+        let data = new HttpParams();
+        if (params) {
+            params.forEach(element => {
+                data = data.append(`${element.id}`, `${element.value}`);
+            });
+        }
+        return data;
+    }
+    createOptionsWithResponseType(params, withCredentials = false, responseType = HttpResponseType.JSON) {
+        const options = {
+            params: this.createParams(params),
+            withCredentials
+        };
+        if (responseType !== HttpResponseType.JSON) {
+            options.responseType = responseType;
+        }
+        return options;
+    }
+    getData(url, params, withCredentials = false) {
+        return this.http.get(url, { params: this.createParams(params), withCredentials });
+    }
+    postData(url, body, params, withCredentials = false) {
+        return this.http.post(url, body, { params: this.createParams(params), withCredentials });
+    }
+    putData(url, body, params, withCredentials = false) {
+        return this.http.put(url, body, { params: this.createParams(params), withCredentials });
+    }
+    deleteData(url, params, withCredentials = false) {
+        return this.http.delete(url, { params: this.createParams(params), withCredentials });
+    }
+    getDataPromise(url, params, withCredentials = false) {
+        return new Promise((resolve, reject) => {
+            this.getData(url, params, withCredentials).subscribe(res => resolve(res), err => reject(err));
+        });
+    }
+    postDataPromise(url, body, params, withCredentials = false) {
+        return new Promise((resolve, reject) => {
+            this.postData(url, body, params, withCredentials).subscribe(res => resolve(res), err => reject(err));
+        });
+    }
+    putDataPromise(url, body, params, withCredentials = false) {
+        return new Promise((resolve, reject) => {
+            this.putData(url, body, params, withCredentials).subscribe(res => resolve(res), err => reject(err));
+        });
+    }
+    deleteDataPromise(url, params, withCredentials = false) {
+        return new Promise((resolve, reject) => {
+            this.deleteData(url, params, withCredentials).subscribe(res => resolve(res), err => reject(err));
+        });
+    }
+    getDataBody(url, params, withCredentials = false) {
+        return new Promise((resolve, reject) => {
+            this.http.get(url, { params: this.createParams(params), withCredentials }).subscribe(res => {
+                if (res['code'] === 0 && res['body']) {
+                    resolve(res['body']);
+                }
+                else {
+                    resolve(null);
+                    this.message.Error("Error", res['message']);
+                }
+            }, err => reject(err));
+        });
+    }
+    postDataBody(url, body, params, withCredentials = false) {
+        return new Promise((resolve, reject) => {
+            this.http.post(url, body, { params: this.createParams(params), withCredentials }).subscribe(res => {
+                if (res['code'] === 0 && res['body']) {
+                    resolve(res['body']);
+                }
+                else {
+                    resolve(null);
+                    this.message.Error("Error", res['message']);
+                }
+            }, err => reject(err));
+        });
+    }
+    putDataBody(url, body, params, withCredentials = false) {
+        return new Promise((resolve, reject) => {
+            this.http.put(url, body, { params: this.createParams(params), withCredentials }).subscribe(res => {
+                if (res['code'] === 0 && res['body']) {
+                    resolve(res['body']);
+                }
+                else {
+                    resolve(null);
+                    this.message.Error("Error", res['message']);
+                }
+            }, err => reject(err));
+        });
+    }
+    getDataWithResponseType(url, params, withCredentials = false, responseType = HttpResponseType.JSON) {
+        return this.http.get(url, this.createOptionsWithResponseType(params, withCredentials, responseType));
+    }
+    postDataWithResponseType(url, body, params, withCredentials = false, responseType = HttpResponseType.JSON) {
+        return this.http.post(url, body, this.createOptionsWithResponseType(params, withCredentials, responseType));
+    }
+    putDataWithResponseType(url, body, params, withCredentials = false, responseType = HttpResponseType.JSON) {
+        return this.http.put(url, body, this.createOptionsWithResponseType(params, withCredentials, responseType));
+    }
+    deleteDataWithResponseType(url, params, withCredentials = false, responseType = HttpResponseType.JSON) {
+        return this.http.delete(url, this.createOptionsWithResponseType(params, withCredentials, responseType));
+    }
+    getDataPromiseWithResponseType(url, params, withCredentials = false, responseType = HttpResponseType.JSON) {
+        return new Promise((resolve, reject) => {
+            this.getDataWithResponseType(url, params, withCredentials, responseType).subscribe(res => resolve(res), err => reject(err));
+        });
+    }
+    postDataPromiseWithResponseType(url, body, params, withCredentials = false, responseType = HttpResponseType.JSON) {
+        return new Promise((resolve, reject) => {
+            this.postDataWithResponseType(url, body, params, withCredentials, responseType).subscribe(res => resolve(res), err => reject(err));
+        });
+    }
+    putDataPromiseWithResponseType(url, body, params, withCredentials = false, responseType = HttpResponseType.JSON) {
+        return new Promise((resolve, reject) => {
+            this.putDataWithResponseType(url, body, params, withCredentials, responseType).subscribe(res => resolve(res), err => reject(err));
+        });
+    }
+    deleteDataPromiseWithResponseType(url, params, withCredentials = false, responseType = HttpResponseType.JSON) {
+        return new Promise((resolve, reject) => {
+            this.deleteDataWithResponseType(url, params, withCredentials, responseType).subscribe(res => resolve(res), err => reject(err));
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpService, deps: [{ token: i1.HttpClient }, { token: i2.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.MessageService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.service.js","sourceRoot":"","sources":["../../../../../../src/app/modules/services/http.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAc,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;;;;AAGvE,MAAM,OAAO,WAAW;IAGZ;IACA;IAFV,YACU,IAAgB,EAChB,OAAuB;QADvB,SAAI,GAAJ,IAAI,CAAY;QAChB,YAAO,GAAP,OAAO,CAAgB;IAC7B,CAAC;IAEG,YAAY,CAAC,MAAY;QAC/B,IAAI,IAAI,GAAG,IAAI,UAAU,EAAE,CAAC;QAC5B,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;gBACvB,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;YAC1D,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,6BAA6B,CAAC,MAAO,EAAE,kBAA2B,KAAK,EAAE,eAAiC,gBAAgB,CAAC,IAAI;QACrI,MAAM,OAAO,GAAQ;YACnB,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;YACjC,eAAe;SAChB,CAAC;QAEF,IAAI,YAAY,KAAK,gBAAgB,CAAC,IAAI,EAAE,CAAC;YAC3C,OAAO,CAAC,YAAY,GAAG,YAAY,CAAC;QACtC,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,OAAO,CAAC,GAAW,EAAE,MAAO,EAAE,kBAA2B,KAAK;QAC5D,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC;IACpF,CAAC;IAED,QAAQ,CAAC,GAAW,EAAE,IAAS,EAAE,MAAO,EAAE,kBAA2B,KAAK;QACxE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC;IAC3F,CAAC;IAED,OAAO,CAAC,GAAW,EAAE,IAAS,EAAE,MAAO,EAAE,kBAA2B,KAAK;QACvE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC;IAC1F,CAAC;IAED,UAAU,CAAC,GAAW,EAAE,MAAO,EAAE,kBAA2B,KAAK;QAC/D,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC;IACvF,CAAC;IAED,cAAc,CAAC,GAAW,EAAE,MAAO,EAAE,kBAA2B,KAAK;QACnE,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC,SAAS,CAClD,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,EACnB,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CACnB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,eAAe,CAAC,GAAW,EAAE,IAAS,EAAE,MAAO,EAAE,kBAA2B,KAAK;QAC/E,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC,SAAS,CACzD,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,EACnB,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CACnB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,cAAc,CAAC,GAAW,EAAE,IAAS,EAAE,MAAO,EAAE,kBAA2B,KAAK;QAC9E,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC,SAAS,CACxD,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,EACnB,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CACnB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,iBAAiB,CAAC,GAAW,EAAE,MAAO,EAAE,kBAA2B,KAAK;QACtE,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC,SAAS,CACrD,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,EACnB,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CACnB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,WAAW,CAAI,GAAW,EAAE,MAAO,EAAE,kBAA2B,KAAK;QACnE,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC,SAAS,CAClF,GAAG,CAAC,EAAE;gBACJ,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;oBACrC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAM,CAAC,CAAC;gBAC5B,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,IAAI,CAAC,CAAC;oBACd,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;gBAC9C,CAAC;YACH,CAAC,EACD,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CACnB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,YAAY,CAAI,GAAW,EAAE,IAAS,EAAE,MAAO,EAAE,kBAA2B,KAAK;QAC/E,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC,SAAS,CACzF,GAAG,CAAC,EAAE;gBACJ,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;oBACrC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAM,CAAC,CAAC;gBAC5B,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,IAAI,CAAC,CAAC;oBACd,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;gBAC9C,CAAC;YACH,CAAC,EACD,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CACnB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,WAAW,CAAI,GAAW,EAAE,IAAS,EAAE,MAAO,EAAE,kBAA2B,KAAK;QAC9E,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC,SAAS,CACxF,GAAG,CAAC,EAAE;gBACJ,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;oBACrC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAM,CAAC,CAAC;gBAC5B,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,IAAI,CAAC,CAAC;oBACd,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;gBAC9C,CAAC;YACH,CAAC,EACD,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CACnB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,uBAAuB,CAAC,GAAW,EAAE,MAAO,EAAE,kBAA2B,KAAK,EAAE,eAAiC,gBAAgB,CAAC,IAAI;QACpI,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,6BAA6B,CAAC,MAAM,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC,CAAC;IACvG,CAAC;IAED,wBAAwB,CAAC,GAAW,EAAE,IAAS,EAAE,MAAO,EAAE,kBAA2B,KAAK,EAAE,eAAiC,gBAAgB,CAAC,IAAI;QAChJ,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,6BAA6B,CAAC,MAAM,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC,CAAC;IAC9G,CAAC;IAED,uBAAuB,CAAC,GAAW,EAAE,IAAS,EAAE,MAAO,EAAE,kBAA2B,KAAK,EAAE,eAAiC,gBAAgB,CAAC,IAAI;QAC/I,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,6BAA6B,CAAC,MAAM,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC,CAAC;IAC7G,CAAC;IAED,0BAA0B,CAAC,GAAW,EAAE,MAAO,EAAE,kBAA2B,KAAK,EAAE,eAAiC,gBAAgB,CAAC,IAAI;QACvI,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,6BAA6B,CAAC,MAAM,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC,CAAC;IAC1G,CAAC;IAED,8BAA8B,CAAU,GAAW,EAAE,MAAO,EAAE,kBAA2B,KAAK,EAAE,eAAiC,gBAAgB,CAAC,IAAI;QACpJ,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC,SAAS,CAChF,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,GAAQ,CAAC,EACxB,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CACnB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,+BAA+B,CAAU,GAAW,EAAE,IAAS,EAAE,MAAO,EAAE,kBAA2B,KAAK,EAAE,eAAiC,gBAAgB,CAAC,IAAI;QAChK,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,wBAAwB,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC,SAAS,CACvF,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,GAAQ,CAAC,EACxB,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CACnB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,8BAA8B,CAAU,GAAW,EAAE,IAAS,EAAE,MAAO,EAAE,kBAA2B,KAAK,EAAE,eAAiC,gBAAgB,CAAC,IAAI;QAC/J,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,uBAAuB,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC,SAAS,CACtF,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,GAAQ,CAAC,EACxB,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CACnB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,iCAAiC,CAAU,GAAW,EAAE,MAAO,EAAE,kBAA2B,KAAK,EAAE,eAAiC,gBAAgB,CAAC,IAAI;QACvJ,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,0BAA0B,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC,SAAS,CACnF,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,GAAQ,CAAC,EACxB,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CACnB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;wGApLU,WAAW;4GAAX,WAAW;;4FAAX,WAAW;kBADvB,UAAU","sourcesContent":["import { MessageService } from './message.service';\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpParams } from '@angular/common/http';\nimport { HttpResponseType } from '../interfaces/enum/httpResponseType';\n\n@Injectable()\nexport class HttpService {\n\n  constructor(\n    private http: HttpClient,\n    private message: MessageService\n  ) { }\n\n  private createParams(params?: any): HttpParams {\n    let data = new HttpParams();\n    if (params) {\n      params.forEach(element => {\n        data = data.append(`${element.id}`, `${element.value}`);\n      });\n    }\n    return data;\n  }\n\n  private createOptionsWithResponseType(params?, withCredentials: boolean = false, responseType: HttpResponseType = HttpResponseType.JSON) {\n    const options: any = { \n      params: this.createParams(params), \n      withCredentials \n    };\n    \n    if (responseType !== HttpResponseType.JSON) {\n      options.responseType = responseType;\n    }\n    \n    return options;\n  }\n\n  getData(url: string, params?, withCredentials: boolean = false) {\n    return this.http.get(url, { params: this.createParams(params), withCredentials });\n  }\n\n  postData(url: string, body: any, params?, withCredentials: boolean = false) {\n    return this.http.post(url, body, { params: this.createParams(params), withCredentials });\n  }\n\n  putData(url: string, body: any, params?, withCredentials: boolean = false) {\n    return this.http.put(url, body, { params: this.createParams(params), withCredentials });\n  }\n\n  deleteData(url: string, params?, withCredentials: boolean = false) {\n    return this.http.delete(url, { params: this.createParams(params), withCredentials });\n  }\n\n  getDataPromise(url: string, params?, withCredentials: boolean = false) {\n    return new Promise((resolve, reject) => {\n      this.getData(url, params, withCredentials).subscribe(\n        res => resolve(res),\n        err => reject(err)\n      );\n    });\n  }\n\n  postDataPromise(url: string, body: any, params?, withCredentials: boolean = false) {\n    return new Promise((resolve, reject) => {\n      this.postData(url, body, params, withCredentials).subscribe(\n        res => resolve(res),\n        err => reject(err)\n      );\n    });\n  }\n\n  putDataPromise(url: string, body: any, params?, withCredentials: boolean = false) {\n    return new Promise((resolve, reject) => {\n      this.putData(url, body, params, withCredentials).subscribe(\n        res => resolve(res),\n        err => reject(err)\n      );\n    });\n  }\n\n  deleteDataPromise(url: string, params?, withCredentials: boolean = false) {\n    return new Promise((resolve, reject) => {\n      this.deleteData(url, params, withCredentials).subscribe(\n        res => resolve(res),\n        err => reject(err)\n      );\n    });\n  }\n\n  getDataBody<T>(url: string, params?, withCredentials: boolean = false): Promise<T> {\n    return new Promise((resolve, reject) => {\n      this.http.get(url, { params: this.createParams(params), withCredentials }).subscribe(\n        res => {\n          if (res['code'] === 0 && res['body']) {\n            resolve(res['body'] as T);\n          } else {\n            resolve(null);\n            this.message.Error(\"Error\", res['message']);\n          }\n        },\n        err => reject(err)\n      );\n    });\n  }\n\n  postDataBody<T>(url: string, body: any, params?, withCredentials: boolean = false): Promise<T> {\n    return new Promise((resolve, reject) => {\n      this.http.post(url, body, { params: this.createParams(params), withCredentials }).subscribe(\n        res => {\n          if (res['code'] === 0 && res['body']) {\n            resolve(res['body'] as T);\n          } else {\n            resolve(null);\n            this.message.Error(\"Error\", res['message']);\n          }\n        },\n        err => reject(err)\n      );\n    });\n  }\n\n  putDataBody<T>(url: string, body: any, params?, withCredentials: boolean = false): Promise<T> {\n    return new Promise((resolve, reject) => {\n      this.http.put(url, body, { params: this.createParams(params), withCredentials }).subscribe(\n        res => {\n          if (res['code'] === 0 && res['body']) {\n            resolve(res['body'] as T);\n          } else {\n            resolve(null);\n            this.message.Error(\"Error\", res['message']);\n          }\n        },\n        err => reject(err)\n      );\n    });\n  }\n\n  getDataWithResponseType(url: string, params?, withCredentials: boolean = false, responseType: HttpResponseType = HttpResponseType.JSON) {\n    return this.http.get(url, this.createOptionsWithResponseType(params, withCredentials, responseType));\n  }\n\n  postDataWithResponseType(url: string, body: any, params?, withCredentials: boolean = false, responseType: HttpResponseType = HttpResponseType.JSON) {\n    return this.http.post(url, body, this.createOptionsWithResponseType(params, withCredentials, responseType));\n  }\n\n  putDataWithResponseType(url: string, body: any, params?, withCredentials: boolean = false, responseType: HttpResponseType = HttpResponseType.JSON) {\n    return this.http.put(url, body, this.createOptionsWithResponseType(params, withCredentials, responseType));\n  }\n\n  deleteDataWithResponseType(url: string, params?, withCredentials: boolean = false, responseType: HttpResponseType = HttpResponseType.JSON) {\n    return this.http.delete(url, this.createOptionsWithResponseType(params, withCredentials, responseType));\n  }\n\n  getDataPromiseWithResponseType<T = any>(url: string, params?, withCredentials: boolean = false, responseType: HttpResponseType = HttpResponseType.JSON): Promise<T> {\n    return new Promise((resolve, reject) => {\n      this.getDataWithResponseType(url, params, withCredentials, responseType).subscribe(\n        res => resolve(res as T),\n        err => reject(err)\n      );\n    });\n  }\n\n  postDataPromiseWithResponseType<T = any>(url: string, body: any, params?, withCredentials: boolean = false, responseType: HttpResponseType = HttpResponseType.JSON): Promise<T> {\n    return new Promise((resolve, reject) => {\n      this.postDataWithResponseType(url, body, params, withCredentials, responseType).subscribe(\n        res => resolve(res as T),\n        err => reject(err)\n      );\n    });\n  }\n\n  putDataPromiseWithResponseType<T = any>(url: string, body: any, params?, withCredentials: boolean = false, responseType: HttpResponseType = HttpResponseType.JSON): Promise<T> {\n    return new Promise((resolve, reject) => {\n      this.putDataWithResponseType(url, body, params, withCredentials, responseType).subscribe(\n        res => resolve(res as T),\n        err => reject(err)\n      );\n    });\n  }\n\n  deleteDataPromiseWithResponseType<T = any>(url: string, params?, withCredentials: boolean = false, responseType: HttpResponseType = HttpResponseType.JSON): Promise<T> {\n    return new Promise((resolve, reject) => {\n      this.deleteDataWithResponseType(url, params, withCredentials, responseType).subscribe(\n        res => resolve(res as T),\n        err => reject(err)\n      );\n    });\n  }\n}"]}

package/esm2022/src/app/modules/services/loading/loading.component.mjs

@@ -0,0 +1,30 @@
+import { Component, Inject, ViewEncapsulation } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+export class LoadingComponent {
+    dialogRef;
+    data;
+    options = {
+        path: '/assets/loading.json'
+    };
+    constructor(dialogRef, data) {
+        this.dialogRef = dialogRef;
+        this.data = data;
+    }
+    ngOnInit() {
+    }
+    animationCreated(animationItem) {
+        console.log(animationItem);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LoadingComponent, deps: [{ token: i1.MatDialogRef }, { token: MAT_DIALOG_DATA }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: LoadingComponent, selector: "app-loading", ngImport: i0, template: "<mat-dialog-content style=\"display: flex; justify-content: center; align-items: center; flex-direction: column;\">\n  <div style=\"font-size: 20px;\">\n    <strong>{{data.title}}</strong>\n  </div>\n  <div>\n    <!-- <ng-lottie width='170px' [options]=\"options\" (animationCreated)=\"animationCreated($event)\"></ng-lottie> -->\n    <img width=\"170px\" src=\"assets/loading.gif\" alt=\"\">\n  </div>\n  <div style=\"text-align: center;\">\n    {{data.message}}\n  </div>\n</mat-dialog-content>", styles: [".mat-dialog-container{overflow:hidden!important;background-color:#fff!important}\n"], dependencies: [{ kind: "directive", type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LoadingComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-loading', encapsulation: ViewEncapsulation.None, template: "<mat-dialog-content style=\"display: flex; justify-content: center; align-items: center; flex-direction: column;\">\n  <div style=\"font-size: 20px;\">\n    <strong>{{data.title}}</strong>\n  </div>\n  <div>\n    <!-- <ng-lottie width='170px' [options]=\"options\" (animationCreated)=\"animationCreated($event)\"></ng-lottie> -->\n    <img width=\"170px\" src=\"assets/loading.gif\" alt=\"\">\n  </div>\n  <div style=\"text-align: center;\">\n    {{data.message}}\n  </div>\n</mat-dialog-content>", styles: [".mat-dialog-container{overflow:hidden!important;background-color:#fff!important}\n"] }]
+        }], ctorParameters: () => [{ type: i1.MatDialogRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/modules/services/local-storage.service.mjs

@@ -0,0 +1,115 @@
+import { compress, decompress } from 'lz-string';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LocalStorageService {
+    prefix = 'bl-f';
+    store = window.localStorage;
+    constructor() {
+        this.prefix += '.';
+    }
+    /**
+     * set key in local storage
+     * @param key  key
+     * @param value  value
+     */
+    set(key, value) {
+        key = this.prefix + key;
+        this.store.setItem(key, compress(JSON.stringify(value))); // compress data
+        return true;
+    }
+    /**
+     * get key in local storage
+     * @param key  key
+     * @returns  value as object
+     */
+    get(key) {
+        key = this.prefix + key;
+        const datacompressed = this.store.getItem(key);
+        if (!datacompressed) {
+            return null;
+        }
+        const item = decompress(datacompressed); // decompress
+        return JSON.parse(item);
+    }
+    /**
+     * remove a key
+     * @param key key to remove
+     * @returns boolean
+     */
+    remove(key) {
+        key = this.prefix + key;
+        this.store.removeItem(key);
+        return true;
+    }
+    /**
+   * clear all
+   * @returns boolean
+   */
+    clear() {
+        this.store.clear();
+        return true;
+    }
+    /**
+     * get all keys present in local storage
+     * @returns  array of keys
+     */
+    getAllKeys() {
+        let keys = [];
+        for (let index = 0; index < this.store.length; index++) {
+            const key = this.store.key(index);
+            if (key.indexOf(this.prefix) === 0) {
+                keys.push(key.substr(this.prefix.length));
+            }
+        }
+        return keys;
+    }
+    /**
+     * set key with expire time
+     * @param key key
+     * @param value  value
+     * @returns true if set correctly
+     */
+    setWhitExpiry(key, value) {
+        const now = new Date();
+        const ttl = 3600 * 1000;
+        const item = {
+            value: value,
+            expiry: now.getTime() + ttl,
+        };
+        key = this.prefix + key;
+        this.store.setItem(key, compress(JSON.stringify(item))); // compress data
+        return true;
+    }
+    /**
+     * return key with expire time
+     * @param key key
+     * @returns return object with data or null if key expired
+     */
+    getWithExpiry(key) {
+        key = this.prefix + key;
+        const datacompressed = this.store.getItem(key);
+        if (!datacompressed) {
+            return null;
+        }
+        const itemStr = decompress(datacompressed); // decompress
+        const item = JSON.parse(itemStr);
+        const now = new Date();
+        if (!item) {
+            return null;
+        }
+        if (now.getTime() > item.expiry) {
+            this.store.removeItem(key);
+            return null;
+        }
+        return item.value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/modules/services/message.service.mjs

@@ -0,0 +1,202 @@
+import { Injectable } from '@angular/core';
+import Swal from 'sweetalert2';
+import { LoadingComponent } from './loading/loading.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+export class MessageService {
+    dialog;
+    loadingNow = false;
+    warningQueue = [];
+    showingWarning = false;
+    loading;
+    constructor(dialog) {
+        this.dialog = dialog;
+    }
+    openLoading(title, message) {
+        if (!this.loadingNow) {
+            this.loadingNow = true;
+            this.loading = this.dialog.open(LoadingComponent, {
+                data: {
+                    title,
+                    message
+                },
+                width: '250px',
+                // height:'280px',
+                disableClose: true,
+            });
+        }
+    }
+    closeLoading() {
+        if (this.loadingNow) {
+            this.loading.close();
+            this.loadingNow = false;
+        }
+    }
+    Error(title, message, showCancelButton = false, confirmButtonText = 'Aceptar', cancelButtonText = 'Cancelar') {
+        return new Promise((resolve, reject) => {
+            Swal.fire({
+                title: title,
+                text: message,
+                icon: 'error',
+                showCancelButton: showCancelButton,
+                confirmButtonText: confirmButtonText,
+                cancelButtonText: cancelButtonText,
+                customClass: {
+                    confirmButton: 'confirm-button-class',
+                    cancelButton: 'cancel-button-class',
+                }
+            }).then((result) => {
+                if (result.value) {
+                    resolve(true);
+                }
+                else if (result.dismiss === Swal.DismissReason.cancel) {
+                    resolve(false);
+                }
+            });
+        });
+    }
+    Success(title, message, showCancelButton = false, confirmButtonText = 'Aceptar', cancelButtonText = 'Cancelar') {
+        return new Promise((resolve, reject) => {
+            Swal.fire({
+                title: title,
+                text: message,
+                icon: 'success',
+                showCancelButton: showCancelButton,
+                confirmButtonText: confirmButtonText,
+                cancelButtonText: cancelButtonText,
+                customClass: {
+                    confirmButton: 'confirm-button-class',
+                    cancelButton: 'cancel-button-class',
+                }
+            }).then((result) => {
+                if (result.value) {
+                    resolve(true);
+                }
+                else if (result.dismiss === Swal.DismissReason.cancel) {
+                    resolve(false);
+                }
+            });
+        });
+    }
+    Warning(title, message, showCancelButton = false, confirmButtonText = 'Aceptar', cancelButtonText = 'Cancelar', allowOutsideClick = false) {
+        return new Promise((resolve, reject) => {
+            const warningData = {
+                title: title,
+                message: message,
+                showCancelButton: showCancelButton,
+                confirmButtonText: confirmButtonText,
+                cancelButtonText: cancelButtonText,
+                resolve: resolve,
+                allowOutsideClick
+            };
+            this.warningQueue.push(warningData);
+            if (!this.showingWarning) {
+                this.showNextWarning();
+            }
+        });
+    }
+    showNextWarning() {
+        if (this.warningQueue.length > 0) {
+            this.showingWarning = true;
+            const warningData = this.warningQueue.shift();
+            Swal.fire({
+                title: warningData.title,
+                text: warningData.message,
+                icon: 'warning',
+                showCancelButton: warningData.showCancelButton,
+                confirmButtonText: warningData.confirmButtonText,
+                cancelButtonText: warningData.cancelButtonText,
+                customClass: {
+                    confirmButton: 'confirm-button-class',
+                    cancelButton: 'cancel-button-class',
+                },
+                allowOutsideClick: warningData.allowOutsideClick,
+            }).then((result) => {
+                this.showingWarning = false;
+                if (result.value) {
+                    warningData.resolve(true);
+                }
+                else if (result.dismiss === Swal.DismissReason.cancel) {
+                    warningData.resolve(false);
+                }
+                this.showNextWarning();
+            });
+        }
+    }
+    Info(title, message, showCancelButton = false, confirmButtonText = 'Aceptar', cancelButtonText = 'Cancelar') {
+        return new Promise((resolve, reject) => {
+            Swal.fire({
+                title: title,
+                text: message,
+                icon: 'info',
+                showCancelButton: showCancelButton,
+                confirmButtonText: confirmButtonText,
+                cancelButtonText: cancelButtonText,
+                customClass: {
+                    confirmButton: 'confirm-button-class',
+                    cancelButton: 'cancel-button-class',
+                }
+            }).then((result) => {
+                if (result.value) {
+                    resolve(true);
+                }
+                else if (result.dismiss === Swal.DismissReason.cancel) {
+                    resolve(false);
+                }
+            });
+        });
+    }
+    SuccessToast(message, duration = 4000) {
+        Swal.fire({
+            position: 'top-end',
+            icon: 'success',
+            title: message,
+            showConfirmButton: false,
+            toast: true,
+            timer: duration,
+            width: 'auto'
+        });
+    }
+    ErrorToast(message, duration = 4000) {
+        Swal.fire({
+            position: 'top-end',
+            icon: 'error',
+            title: message,
+            showConfirmButton: false,
+            toast: true,
+            timer: duration,
+            width: 'auto'
+        });
+    }
+    WarningToast(message, duration = 4000) {
+        Swal.fire({
+            position: 'top-end',
+            icon: 'warning',
+            title: message,
+            showConfirmButton: false,
+            toast: true,
+            timer: duration,
+            width: 'auto'
+        });
+    }
+    InfoToast(message, duration = 4000) {
+        Swal.fire({
+            position: 'top-end',
+            icon: 'info',
+            title: message,
+            showConfirmButton: false,
+            toast: true,
+            timer: duration,
+            width: 'auto'
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MessageService, deps: [{ token: i1.MatDialog }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MessageService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MessageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.MatDialog }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message.service.js","sourceRoot":"","sources":["../../../../../../src/app/modules/services/message.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport Swal from 'sweetalert2'\nimport { MatDialog } from '@angular/material/dialog';\nimport { LoadingComponent } from './loading/loading.component';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class MessageService {\n\n  private loadingNow: boolean = false\n  private warningQueue: any[] = [];\n  private showingWarning: boolean = false;\n  private loading\n  constructor(\n    private dialog:MatDialog\n  ) { }\n\n  openLoading(title,message){\n    if(!this.loadingNow){\n      this.loadingNow = true\n      this.loading = this.dialog.open(LoadingComponent, {\n        data:{\n          title,\n          message\n        },\n        width:'250px',\n        // height:'280px',\n        disableClose:true,\n\n      })\n    }\n\n  }\n\n  closeLoading(){\n    if(this.loadingNow){\n      this.loading.close()\n      this.loadingNow = false\n    }\n  }\n\n  Error(title:string, message:string, showCancelButton:boolean=false,confirmButtonText:string='Aceptar', cancelButtonText:string='Cancelar'){\n    return new Promise((resolve,reject)=>{\n      Swal.fire({\n        title: title,\n        text: message,\n        icon: 'error',\n        showCancelButton: showCancelButton,\n        confirmButtonText: confirmButtonText,\n        cancelButtonText: cancelButtonText,\n        customClass: {\n          confirmButton: 'confirm-button-class',\n          cancelButton: 'cancel-button-class',\n        }\n      }).then((result) => {\n        if (result.value) {\n          resolve(true)\n        } else if (result.dismiss === Swal.DismissReason.cancel) {\n          resolve(false)\n        }\n      })\n    })\n  }\n\n  Success(title:string, message:string, showCancelButton:boolean=false,confirmButtonText:string='Aceptar', cancelButtonText:string='Cancelar'){\n\n    return new Promise((resolve,reject)=>{\n      Swal.fire({\n        title: title,\n        text: message,\n        icon: 'success',\n        showCancelButton: showCancelButton,\n        confirmButtonText: confirmButtonText,\n        cancelButtonText: cancelButtonText,\n        customClass: {\n          confirmButton: 'confirm-button-class',\n          cancelButton: 'cancel-button-class',\n        }\n      }).then((result) => {\n        if (result.value) {\n          resolve(true)\n        } else if (result.dismiss === Swal.DismissReason.cancel) {\n          resolve(false)\n        }\n      })\n    })\n  }\n\n  Warning(\n    title: string,\n    message: string,\n    showCancelButton: boolean = false,\n    confirmButtonText: string = 'Aceptar',\n    cancelButtonText: string = 'Cancelar',\n    allowOutsideClick = false\n  ) {\n    return new Promise((resolve, reject) => {\n      const warningData = {\n        title: title,\n        message: message,\n        showCancelButton: showCancelButton,\n        confirmButtonText: confirmButtonText,\n        cancelButtonText: cancelButtonText,\n        resolve: resolve,\n        allowOutsideClick\n      };\n\n      this.warningQueue.push(warningData);\n\n      if (!this.showingWarning) {\n        this.showNextWarning();\n      }\n    });\n  }\n\n  private showNextWarning() {\n    if (this.warningQueue.length > 0) {\n      this.showingWarning = true;\n      const warningData = this.warningQueue.shift();\n\n      Swal.fire({\n        title: warningData.title,\n        text: warningData.message,\n        icon: 'warning',\n        showCancelButton: warningData.showCancelButton,\n        confirmButtonText: warningData.confirmButtonText,\n        cancelButtonText: warningData.cancelButtonText,\n        customClass: {\n          confirmButton: 'confirm-button-class',\n          cancelButton: 'cancel-button-class',\n        },\n        allowOutsideClick: warningData.allowOutsideClick,\n      }).then((result) => {\n        this.showingWarning = false;\n\n        if (result.value) {\n          warningData.resolve(true);\n        } else if (result.dismiss === Swal.DismissReason.cancel) {\n          warningData.resolve(false);\n        }\n        this.showNextWarning();\n      });\n    }\n  }\n\n  Info(title:string, message:string, showCancelButton:boolean=false,confirmButtonText:string='Aceptar', cancelButtonText:string='Cancelar'){\n    return new Promise((resolve,reject)=>{\n      Swal.fire({\n        title: title,\n        text: message,\n        icon: 'info',\n        showCancelButton: showCancelButton,\n        confirmButtonText: confirmButtonText,\n        cancelButtonText: cancelButtonText,\n        customClass: {\n          confirmButton: 'confirm-button-class',\n          cancelButton: 'cancel-button-class',\n        }\n      }).then((result) => {\n        if (result.value) {\n          resolve(true)\n        } else if (result.dismiss === Swal.DismissReason.cancel) {\n          resolve(false)\n        }\n      })\n    })\n  }\n\n\n  SuccessToast(message:string, duration:number = 4000){\n    Swal.fire({\n      position: 'top-end',\n      icon: 'success',\n      title: message,\n      showConfirmButton: false,\n      toast:true,\n      timer: duration,\n      width:'auto'\n    })\n  }\n\n  ErrorToast(message:string, duration:number = 4000){\n    Swal.fire({\n      position: 'top-end',\n      icon: 'error',\n      title: message,\n      showConfirmButton: false,\n      toast:true,\n      timer: duration,\n      width:'auto'\n    })\n  }\n\n  WarningToast(message:string, duration:number = 4000){\n    Swal.fire({\n      position: 'top-end',\n      icon: 'warning',\n      title: message,\n      showConfirmButton: false,\n      toast:true,\n      timer: duration,\n      width:'auto'\n    })\n  }\n\n  InfoToast(message:string, duration:number = 4000){\n    Swal.fire({\n      position: 'top-end',\n      icon: 'info',\n      title: message,\n      showConfirmButton: false,\n      toast:true,\n      timer: duration,\n      width:'auto'\n    })\n  }\n\n}\n"]}