brainloper-ui 14.0.16 → 14.0.18

package/esm2020/src/app/modules/interfaces/menu-break-crumb/menu-break-crumb.mjs

@@ -0,0 +1,8 @@
+export class MenuBreadCrumb {
+    constructor() {
+        this.name = "";
+        this.router = null;
+        this.current = false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1icmVhay1jcnVtYi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvbW9kdWxlcy9pbnRlcmZhY2VzL21lbnUtYnJlYWstY3J1bWIvbWVudS1icmVhay1jcnVtYi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFNQSxNQUFNLE9BQU8sY0FBYztJQUEzQjtRQUNFLFNBQUksR0FBRyxFQUFFLENBQUE7UUFDVCxXQUFNLEdBQUksSUFBSSxDQUFBO1FBQ2QsWUFBTyxHQUFJLEtBQUssQ0FBQTtJQUNsQixDQUFDO0NBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIElNZW51QnJlYWRDcnVtYiB7XHJcbiAgbmFtZTpzdHJpbmcsXHJcbiAgcm91dGVyPzpzdHJpbmcsXHJcbiAgY3VycmVudD86Ym9vbGVhblxyXG59XHJcblxyXG5leHBvcnQgY2xhc3MgTWVudUJyZWFkQ3J1bWIgaW1wbGVtZW50cyBJTWVudUJyZWFkQ3J1bWIgIHtcclxuICBuYW1lID0gXCJcIlxyXG4gIHJvdXRlcj8gPSBudWxsXHJcbiAgY3VycmVudD8gPSBmYWxzZVxyXG59XHJcbiJdfQ==

package/esm2020/src/app/modules/interfaces/report/template-pdf-ot.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcGxhdGUtcGRmLW90LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9tb2R1bGVzL2ludGVyZmFjZXMvcmVwb3J0L3RlbXBsYXRlLXBkZi1vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBUZW1wbGF0ZVBkZk90IHtcclxuICBuYW1lPzpzdHJpbmcsXHJcbiAgbml0PzpzdHJpbmcsXHJcbiAgYWRkcmVzcz86c3RyaW5nLFxyXG4gIHRlbGVwaG9uZT86c3RyaW5nLFxyXG4gIG1haWw/OnN0cmluZyxcclxuICBpbWFnZT86c3RyaW5nLFxyXG4gIGNvZGU/OnN0cmluZyxcclxuICBkYXRlPzpzdHJpbmcsXHJcbiAgcmVzcG9uc2libGU/OnN0cmluZyxcclxuICB0aGlyZD86c3RyaW5nLFxyXG4gIG9kb21ldGVyPzpzdHJpbmcsXHJcbiAgYXBwcm92ZWRfYnk/OnN0cmluZyxcclxuICBkZXNjcmlwdGlvbj86c3RyaW5nLFxyXG4gIGNvbnNlY3V0aXZlPzpzdHJpbmcsXHJcbiAgbmFtZVByb3ZpZGVyPzpzdHJpbmcsXHJcbiAgYWRkcmVzc1Byb3ZpZGVyPzpzdHJpbmcsXHJcbiAgYXJlYT86IHN0cmluZ1xyXG59XHJcbiJdfQ==

package/esm2020/src/app/modules/interfaces/report/template-pfd-fo.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcGxhdGUtcGZkLWZvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9tb2R1bGVzL2ludGVyZmFjZXMvcmVwb3J0L3RlbXBsYXRlLXBmZC1mby50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBUZW1wbGF0ZVBkZkZvIHtcclxuICAgIG5hbWU/OnN0cmluZyxcclxuICAgIG5pdD86c3RyaW5nLFxyXG4gICAgYWRkcmVzcz86c3RyaW5nLFxyXG4gICAgdGVsZXBob25lPzpzdHJpbmcsXHJcbiAgICBtYWlsPzpzdHJpbmcsXHJcbiAgICBpbWFnZT86c3RyaW5nLFxyXG4gICAgY29kZT86c3RyaW5nLFxyXG4gICAgZGF0ZT86c3RyaW5nLFxyXG4gICAgcmVzcG9uc2libGU/OnN0cmluZyxcclxuICAgIGlkX3BsYWNlPzpzdHJpbmcsXHJcbiAgICBhcHByb3ZlZF9ieT86c3RyaW5nLFxyXG4gICAgZGVzY3JpcHRpb24/OnN0cmluZyxcclxuICAgIGRldGFsbGU/OnN0cmluZyxcclxuICAgIGNvbnNlY3V0aXZlPzpzdHJpbmcsXHJcbiAgICBuYW1lUGxhY2U/OnN0cmluZyxcclxuICAgIGFkZHJlc3NQbGFjZT86c3RyaW5nLFxyXG4gICAgYXJlYT86IHN0cmluZ1xyXG4gICAgb2RvbWV0ZXI/OiBzdHJpbmcsXHJcbiAgfVxyXG4iXX0=

package/esm2020/src/app/modules/services/crypto.service.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import * as CryptoJS from 'crypto-js';
+import * as i0 from "@angular/core";
+//declare var require: any
+//var CryptoJS = require("crypto-js");
+export class CryptoService {
+    constructor() {
+        this.key = "ssaldkmaosweiuf231owdalsd0";
+    }
+    asignarKey(key) {
+        this.key = key;
+    }
+    encode(data) {
+        const strData = JSON.stringify(data);
+        let c = CryptoJS.AES.encrypt(strData, this.key);
+        return c;
+    }
+    decode(data) {
+        try {
+            var bytes = CryptoJS.AES.decrypt(data, this.key);
+            var str = bytes.toString(CryptoJS.enc.Utf8);
+            return JSON.parse(str);
+        }
+        catch (e) {
+            console.log('Error try to decode string');
+        }
+    }
+}
+CryptoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CryptoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CryptoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CryptoService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CryptoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/app/modules/services/export-data.service.mjs

@@ -0,0 +1,166 @@
+import { Injectable } from '@angular/core';
+import * as fs from 'file-saver';
+import { Workbook } from 'exceljs';
+import * as i0 from "@angular/core";
+import * as i1 from "./http.service";
+import * as i2 from "./functions.service";
+import * as i3 from "./message.service";
+export class ExportDataService {
+    constructor(http, functionEter, message) {
+        this.http = http;
+        this.functionEter = functionEter;
+        this.message = message;
+    }
+    async generateExcelWithSheets(title, header, name, bodies, url, params, filtersPost, titleFields, sheetNameFields, BodyFields) {
+        this.message.openLoading("Cargando", "Generando archivo");
+        bodies = await this.getDataBody(url, params, bodies, filtersPost);
+        const workbook = new Workbook();
+        for (let index = 0; index < bodies.length; index++) {
+            const body = bodies[index];
+            if (titleFields) {
+                title = titleFields.map(param => body[param]).join("-");
+            }
+            var nameSheet = "sheet";
+            if (sheetNameFields) {
+                nameSheet = sheetNameFields.map(param => body[param]).join("-");
+            }
+            const worksheet = await this.generateToXlsx(title, header, `(${(index + 1) + ') ' + nameSheet}`, body, null, null, null, BodyFields, false);
+            workbook.addWorksheet(worksheet.name, { views: [{ state: 'frozen', ySplit: 1 }] });
+            const newWorksheet = workbook.getWorksheet(worksheet.name);
+            newWorksheet.model = worksheet.model;
+        }
+        const buffer = await workbook.xlsx.writeBuffer();
+        this.saveAsExcelFile(buffer, name);
+        this.message.closeLoading();
+    }
+    async generateToXlsx(title, header, name, body, url, params, filtersPost, BodyFields, generateFile = true) {
+        if (!generateFile)
+            this.message.openLoading("Cargando", "Generando el archivo");
+        body = await this.getDataBody(url, params, body, filtersPost);
+        let workbook = new Workbook();
+        let worksheet = workbook.addWorksheet(name);
+        // Add new row
+        let titleRow = worksheet.addRow([title]);
+        // Set font, size and style in title row.
+        titleRow.font = {
+            name: 'Comic Sans MS',
+            family: 4,
+            size: 16,
+            underline: 'double',
+            bold: true,
+        };
+        // Blank Row
+        // worksheet.addRow([]);
+        // let addheader = false
+        // for (let p of header.filter(x => x.id === null)) {
+        //   worksheet.addRow([body[p.value]??p.value])
+        //   addheader = true
+        // }
+        worksheet.addRow([]);
+        let addheader = false;
+        for (let p of header.filter(x => x.id === null)) {
+            let value = p.value;
+            const matches = value.match(/{(.*?)}/g);
+            if (matches) {
+                matches.forEach(match => {
+                    const key = match.slice(1, -1);
+                    value = value.replace(match, body[key] ?? match);
+                });
+            }
+            worksheet.addRow([value]);
+            addheader = true;
+        }
+        if (addheader)
+            worksheet.addRow([]);
+        //Add Header Row
+        let headerRowValue = header.filter(x => x.id != null).map((p) => { return p.value ?? p.id; });
+        let _headerRowValue = worksheet.addRow(headerRowValue);
+        // Cell Style : Fill and Border
+        _headerRowValue.eachCell((cell, number) => {
+            cell.fill = {
+                type: 'pattern',
+                pattern: 'lightUp',
+                fgColor: { argb: '6775f500' },
+                bgColor: { argb: '6775f500' },
+            };
+            cell.border = {
+                top: { style: 'thin' },
+                left: { style: 'thin' },
+                bottom: { style: 'thin' },
+                right: { style: 'thin' },
+            };
+        });
+        var headerRow = header.filter(x => x.id != null);
+        let data = BodyFields != null ? body[BodyFields] ?? [] : body;
+        for (let d of data) {
+            var row = [];
+            for (let h of headerRow) {
+                var dh = d[`${h.id}`];
+                if (h.rules) {
+                    for (const rule of h.rules) {
+                        if (rule.rule == enumRules['==']) {
+                            if (dh == rule.valueRule.toString())
+                                dh = rule.valueAction;
+                        }
+                    }
+                }
+                row.push(dh?.toString());
+            }
+            worksheet.addRow(row);
+        }
+        worksheet.columns.forEach(function (column, i) {
+            var maxLength = 0;
+            column["eachCell"]({ includeEmpty: true }, function (cell) {
+                var columnLength = cell.value ? cell.value.toString().length : 10;
+                if (columnLength > maxLength) {
+                    maxLength = columnLength;
+                }
+            });
+            column.width = maxLength < 10 ? 10 : maxLength;
+        });
+        if (!generateFile) {
+            return worksheet;
+        }
+        workbook.xlsx.writeBuffer().then((data) => {
+            this.saveAsExcelFile(data, name);
+        });
+        if (!generateFile)
+            this.message.closeLoading();
+    }
+    saveAsExcelFile(buffer, fileName) {
+        const data = new Blob([buffer], {
+            type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8'
+        });
+        fs.saveAs(data, `${fileName}_export_${new Date().getTime()}.xlsx`);
+    }
+    async getDataBody(url, params, body, filtersPost) {
+        if (body)
+            return body;
+        if (url) {
+            var res;
+            res = await this.http.postDataBody(url, filtersPost, params);
+            if (res['count']) {
+                return res['data'];
+            }
+            else {
+                return res;
+            }
+        }
+    }
+}
+ExportDataService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ExportDataService, deps: [{ token: i1.HttpService }, { token: i2.FunctionsService }, { token: i3.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+ExportDataService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ExportDataService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ExportDataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpService }, { type: i2.FunctionsService }, { type: i3.MessageService }]; } });
+var enumRules;
+(function (enumRules) {
+    enumRules[enumRules[">"] = 0] = ">";
+    enumRules[enumRules["<"] = 1] = "<";
+    enumRules[enumRules["=="] = 2] = "==";
+    enumRules[enumRules["!="] = 3] = "!=";
+})(enumRules || (enumRules = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"export-data.service.js","sourceRoot":"","sources":["../../../../../../src/app/modules/services/export-data.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { MessageService } from './message.service';\r\nimport { Injectable } from '@angular/core';\r\nimport { HttpService } from './http.service';\r\nimport * as fs from 'file-saver';\r\nimport { Workbook } from 'exceljs';\r\nimport { params } from '../interfaces/data-table/params';\r\nimport { FunctionsService } from './functions.service';\r\nimport { HeaderFilters } from '../interfaces/filters/header-filters';\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ExportDataService {\r\n\r\n  constructor(\r\n    private http: HttpService,\r\n    private functionEter: FunctionsService,\r\n    private message: MessageService) { }\r\n\r\n  async generateExcelWithSheets<T>(\r\n    title: string,\r\n    header: Array<params>,\r\n    name: string,\r\n    bodies?: Array<any>,\r\n    url?: string,\r\n    params?: params[],\r\n    filtersPost?: Array<HeaderFilters<any>>,\r\n    titleFields?: string[],\r\n    sheetNameFields?: string[],\r\n    BodyFields?:string): Promise<void> {\r\n\r\n    this.message.openLoading(\"Cargando\", \"Generando archivo\")\r\n\r\n    bodies = await this.getDataBody<Array<T>>(url, params, bodies, filtersPost)\r\n    const workbook = new Workbook();\r\n\r\n    for (let index = 0; index < bodies.length; index++) {\r\n      const body = bodies[index];\r\n\r\n      if (titleFields) {\r\n        title = titleFields.map(param => body[param]).join(\"-\");\r\n      }\r\n\r\n      var nameSheet = \"sheet\";\r\n\r\n      if (sheetNameFields) {\r\n        nameSheet = sheetNameFields.map(param => body[param]).join(\"-\");\r\n      }\r\n\r\n      const worksheet = await this.generateToXlsx(title, header, `(${(index+1)+') '+nameSheet}`, body, null, null, null, BodyFields, false);\r\n      workbook.addWorksheet(worksheet.name, { views: [{ state: 'frozen', ySplit: 1 }] });\r\n      const newWorksheet = workbook.getWorksheet(worksheet.name);\r\n      newWorksheet.model = worksheet.model;\r\n    }\r\n\r\n    const buffer = await workbook.xlsx.writeBuffer();\r\n    this.saveAsExcelFile(buffer, name);\r\n\r\n    this.message.closeLoading()\r\n  }\r\n\r\n  public async generateToXlsx<T>(\r\n    title: string,\r\n    header: Array<params>,\r\n    name: string,\r\n    body?: T,\r\n    url?: string,\r\n    params?: Array<params>,\r\n    filtersPost?: Array<HeaderFilters<any>>,\r\n    BodyFields?:string,\r\n    generateFile: boolean = true): Promise<any> {\r\n\r\n    if (!generateFile) this.message.openLoading(\"Cargando\", \"Generando el archivo\")\r\n\r\n    body = await this.getDataBody<T>(url, params, body, filtersPost)\r\n\r\n    let workbook = new Workbook();\r\n    let worksheet = workbook.addWorksheet(name);\r\n\r\n    // Add new row\r\n    let titleRow = worksheet.addRow([title]);\r\n\r\n    // Set font, size and style in title row.\r\n    titleRow.font = {\r\n      name: 'Comic Sans MS',\r\n      family: 4,\r\n      size: 16,\r\n      underline: 'double',\r\n      bold: true,\r\n    };\r\n\r\n    // Blank Row\r\n    // worksheet.addRow([]);\r\n    // let addheader = false\r\n    // for (let p of header.filter(x => x.id === null)) {\r\n    //   worksheet.addRow([body[p.value]??p.value])\r\n    //   addheader = true\r\n    // }\r\n\r\n    worksheet.addRow([]);\r\n    let addheader = false;\r\n    for (let p of header.filter(x => x.id === null)) {\r\n      let value = p.value;\r\n      const matches = value.match(/{(.*?)}/g);\r\n      if (matches) {\r\n        matches.forEach(match => {\r\n          const key = match.slice(1, -1);\r\n          value = value.replace(match, body[key] ?? match);\r\n        });\r\n      }\r\n      worksheet.addRow([value]);\r\n      addheader = true;\r\n    }\r\n\r\n    if (addheader) worksheet.addRow([]);\r\n\r\n    //Add Header Row\r\n    let headerRowValue = header.filter(x => x.id != null).map((p) => { return p.value??p.id })\r\n    let _headerRowValue = worksheet.addRow(headerRowValue);\r\n\r\n    // Cell Style : Fill and Border\r\n    _headerRowValue.eachCell((cell, number) => {\r\n      cell.fill = {\r\n        type: 'pattern',\r\n        pattern: 'lightUp',\r\n        fgColor: { argb: '6775f500' },\r\n        bgColor: { argb: '6775f500' },\r\n      };\r\n      cell.border = {\r\n        top: { style: 'thin' },\r\n        left: { style: 'thin' },\r\n        bottom: { style: 'thin' },\r\n        right: { style: 'thin' },\r\n      };\r\n    });\r\n\r\n    var headerRow = header.filter(x => x.id != null)\r\n\r\n    let data = BodyFields != null ? body[BodyFields] ?? [] : body\r\n    for (let d of data) {\r\n      var row = []\r\n      for (let h of headerRow) {\r\n        var dh = d[`${h.id}`]\r\n        if (h.rules) {\r\n          for (const rule of h.rules) {\r\n            if (rule.rule == enumRules['==']) {\r\n              if (dh == rule.valueRule.toString())\r\n                dh = rule.valueAction\r\n            }\r\n          }\r\n        }\r\n        row.push(dh?.toString())\r\n      }\r\n      worksheet.addRow(row);\r\n    }\r\n\r\n    worksheet.columns.forEach(function (column, i) {\r\n      var maxLength = 0;\r\n      column[\"eachCell\"]({ includeEmpty: true }, function (cell) {\r\n        var columnLength = cell.value ? cell.value.toString().length : 10;\r\n        if (columnLength > maxLength) {\r\n          maxLength = columnLength;\r\n        }\r\n      });\r\n      column.width = maxLength < 10 ? 10 : maxLength;\r\n    });\r\n\r\n    if (!generateFile) {\r\n      return worksheet;\r\n    }\r\n\r\n    workbook.xlsx.writeBuffer().then((data) => {\r\n      this.saveAsExcelFile(data, name);\r\n    });\r\n\r\n    if (!generateFile) this.message.closeLoading()\r\n  }\r\n\r\n  private saveAsExcelFile(buffer: any, fileName: string): void {\r\n    const data: Blob = new Blob([buffer], {\r\n      type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8'\r\n    });\r\n    fs.saveAs(data, `${fileName}_export_${new Date().getTime()}.xlsx`);\r\n  }\r\n\r\n  private async getDataBody<T>(url: string, params: Array<params>, body: T, filtersPost?: Array<HeaderFilters<any>>): Promise<T> {\r\n    if (body) return body;\r\n\r\n    if (url) {\r\n      var res: any\r\n      res = await this.http.postDataBody(url, filtersPost, params)\r\n      if (res['count']) {\r\n        return res['data']\r\n      } else {\r\n        return res\r\n      }\r\n    }\r\n\r\n  }\r\n}\r\n\r\nenum enumRules {\r\n  \">\",\r\n  \"<\",\r\n  \"==\",\r\n  \"!=\"\r\n}\r\n"]}

package/esm2020/src/app/modules/services/file-forms.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FileFormsService {
+    constructor() { }
+    createMultipartForm(file, params) {
+        const formD = new FormData();
+        formD.append('file', file, 'form-data'); //Asigna el campo File
+        if (params) {
+            params.forEach((element) => {
+                formD.append(element.id, element.value);
+            });
+        }
+        return (formD);
+    }
+}
+FileFormsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: FileFormsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FileFormsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: FileFormsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: FileFormsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1mb3Jtcy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9tb2R1bGVzL3NlcnZpY2VzL2ZpbGUtZm9ybXMuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQyxNQUFNLE9BQU8sZ0JBQWdCO0lBRTNCLGdCQUFnQixDQUFDO0lBRWpCLG1CQUFtQixDQUFDLElBQVMsRUFBRSxNQUFPO1FBRXBDLE1BQU0sS0FBSyxHQUFHLElBQUksUUFBUSxFQUFFLENBQUM7UUFDN0IsS0FBSyxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUMsSUFBSSxFQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUEsc0JBQXNCO1FBQzVELElBQUcsTUFBTSxFQUFDO1lBQ1IsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDLE9BQVcsRUFBRSxFQUFFO2dCQUM3QixLQUFLLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxFQUFFLEVBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFBO1lBQ3hDLENBQUMsQ0FBQyxDQUFDO1NBQ0o7UUFDRCxPQUFNLENBQUMsS0FBSyxDQUFDLENBQUE7SUFFZixDQUFDOzs2R0FmVSxnQkFBZ0I7aUhBQWhCLGdCQUFnQixjQUZmLE1BQU07MkZBRVAsZ0JBQWdCO2tCQUg1QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCdcclxufSlcclxuZXhwb3J0IGNsYXNzIEZpbGVGb3Jtc1NlcnZpY2Uge1xyXG5cclxuICBjb25zdHJ1Y3RvcigpIHsgfVxyXG5cclxuICBjcmVhdGVNdWx0aXBhcnRGb3JtKGZpbGU6RmlsZSwgcGFyYW1zPyl7XHJcblxyXG4gICAgY29uc3QgZm9ybUQgPSBuZXcgRm9ybURhdGEoKTtcclxuICAgIGZvcm1ELmFwcGVuZCgnZmlsZScsZmlsZSwnZm9ybS1kYXRhJyk7Ly9Bc2lnbmEgZWwgY2FtcG8gRmlsZVxyXG4gICAgaWYocGFyYW1zKXtcclxuICAgICAgcGFyYW1zLmZvckVhY2goKGVsZW1lbnQ6YW55KSA9PiB7XHJcbiAgICAgICAgZm9ybUQuYXBwZW5kKGVsZW1lbnQuaWQsZWxlbWVudC52YWx1ZSlcclxuICAgICAgfSk7XHJcbiAgICB9XHJcbiAgICByZXR1cm4oZm9ybUQpXHJcblxyXG4gIH1cclxuXHJcbn1cclxuIl19

package/esm2020/src/app/modules/services/functions.service.mjs

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FunctionsService {
+    constructor() { }
+    dateForm(date) {
+        let data = new Date(date);
+        let change = `${data.getFullYear()}/${data.getMonth() + 1}/${data.getDate()}`;
+        return (change);
+    }
+    dateIso(date) {
+        let data = date.toString();
+        let cut = data.replace(/(.*)\T.*/, '$1');
+        let add = `${cut}T05:00:00.000Z`;
+        let fecha = add.replace(/(.*)\T.*/, '$1');
+        return (fecha);
+    }
+    dateDB(date) {
+        let day = this.validateTwoDigitFormat(date.getDate().toString());
+        let month = this.validateTwoDigitFormat((date.getMonth() + 1).toString());
+        return `${date.getFullYear()}-${month}-${day}`;
+    }
+    dateWithTime(date) {
+        if (!date)
+            return "";
+        var value = date.split("T");
+        return value[0] + " " + value[1].split(".")[0];
+    }
+    areObjectsEqual(obj1, obj2) {
+        return JSON.stringify(obj1) === JSON.stringify(obj2);
+    }
+    removeDuplicateObjects(originalArray) {
+        const uniqueArray = [];
+        originalArray.forEach((obj) => {
+            if (!uniqueArray.some((uniqueObj) => this.areObjectsEqual(obj, uniqueObj))) {
+                uniqueArray.push(obj);
+            }
+        });
+        return uniqueArray;
+    }
+    validateTwoDigitFormat(number) {
+        if (number.length == 1)
+            number = "0" + number;
+        return number;
+    }
+}
+FunctionsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: FunctionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FunctionsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: FunctionsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: FunctionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/app/modules/services/generate-pdf.service.mjs

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import { GeneratePdfComponent } from '../brainloper-ui/components/report/generate-pdf/generate-pdf.component';
+import { TemplateFuelComponent } from '../brainloper-ui/components/report/template-fuel/template-fuel.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+export class GeneratePdfService {
+    constructor(dialog) {
+        this.dialog = dialog;
+    }
+    getPdfOt(data, autoGenerateData) {
+        let autoGenerate = false;
+        if (autoGenerateData) {
+            autoGenerate = autoGenerateData;
+        }
+        return new Promise((resolve, rejects) => {
+            let screen = "850px";
+            // if ( window.screen.width<1000) {
+            //   screen = "100vw"
+            // }
+            this.dialog.open(GeneratePdfComponent, {
+                data: {
+                    data,
+                    autoGenerate: autoGenerate
+                },
+                width: screen
+            }).afterClosed().subscribe((res) => {
+                return resolve(true);
+            });
+        });
+    }
+    getPdfFo(data, autoGenerateData) {
+        let autoGenerate = false;
+        if (autoGenerateData) {
+            autoGenerate = autoGenerateData;
+        }
+        return new Promise((resolve, rejects) => {
+            let screen = "850px";
+            this.dialog.open(TemplateFuelComponent, {
+                data: {
+                    data,
+                    autoGenerate: autoGenerate
+                },
+                width: screen
+            }).afterClosed().subscribe((res) => {
+                return resolve(true);
+            });
+        });
+    }
+}
+GeneratePdfService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: GeneratePdfService, deps: [{ token: i1.MatDialog }], target: i0.ɵɵFactoryTarget.Injectable });
+GeneratePdfService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: GeneratePdfService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: GeneratePdfService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,154 @@
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./message.service";
+export class HttpService {
+    constructor(http, message) {
+        this.http = http;
+        this.message = message;
+    }
+    getData(url, params) {
+        let data = new HttpParams();
+        if (params) {
+            params.forEach(element => {
+                data = data.append(`${element.id}`, `${element.value}`);
+            });
+        }
+        return this.http.get(url, { params: data });
+    }
+    postData(url, body, params) {
+        let data = new HttpParams();
+        if (params) {
+            params.forEach(element => {
+                data = data.append(`${element.id}`, `${element.value}`);
+            });
+        }
+        return this.http.post(url, body, { params: data });
+    }
+    putData(url, body, params) {
+        let data = new HttpParams();
+        if (params) {
+            params.forEach(element => {
+                data = data.append(`${element.id}`, `${element.value}`);
+            });
+        }
+        return this.http.put(url, body, { params: data });
+    }
+    deleteData(url, params) {
+        let data = new HttpParams();
+        if (params) {
+            params.forEach(element => {
+                data = data.append(`${element.id}`, `${element.value}`);
+            });
+        }
+        return this.http.delete(url, { params: data });
+    }
+    getDataPromise(url, params) {
+        let data = new HttpParams();
+        if (params) {
+            params.forEach(element => {
+                data = data.append(`${element.id}`, `${element.value}`);
+            });
+        }
+        return new Promise((resolve, reject) => {
+            this.http.get(url, { params: data }).subscribe(res => resolve(res), err => reject(err));
+        });
+    }
+    postDataPromise(url, body, params) {
+        let data = new HttpParams();
+        if (params) {
+            params.forEach(element => {
+                data = data.append(`${element.id}`, `${element.value}`);
+            });
+        }
+        return new Promise((resolve, reject) => {
+            this.http.post(url, body, { params: data }).subscribe(res => resolve(res), err => reject(err));
+        });
+    }
+    putDataPromise(url, body, params) {
+        let data = new HttpParams();
+        if (params) {
+            params.forEach(element => {
+                data = data.append(`${element.id}`, `${element.value}`);
+            });
+        }
+        return new Promise((resolve, reject) => {
+            this.http.put(url, body, { params: data }).subscribe(res => resolve(res), err => reject(err));
+        });
+    }
+    deleteDataPromise(url, params) {
+        let data = new HttpParams();
+        if (params) {
+            params.forEach(element => {
+                data = data.append(`${element.id}`, `${element.value}`);
+            });
+        }
+        return new Promise((resolve, reject) => {
+            this.http.delete(url, { params: data }).subscribe(res => resolve(res), err => reject(err));
+        });
+    }
+    getDataBody(url, params) {
+        let data = new HttpParams();
+        if (params) {
+            params.forEach(element => {
+                data = data.append(`${element.id}`, `${element.value}`);
+            });
+        }
+        return new Promise((resolve, reject) => {
+            this.http.get(url, { params: data }).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) {
+        let data = new HttpParams();
+        if (params) {
+            params.forEach(element => {
+                data = data.append(`${element.id}`, `${element.value}`);
+            });
+        }
+        return new Promise((resolve, reject) => {
+            this.http.post(url, body, { params: data }).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) {
+        let data = new HttpParams();
+        if (params) {
+            params.forEach(element => {
+                data = data.append(`${element.id}`, `${element.value}`);
+            });
+        }
+        return new Promise((resolve, reject) => {
+            this.http.put(url, body, { params: data }).subscribe(res => {
+                if (res['code'] === 0 && res['body']) {
+                    resolve(res['body']);
+                }
+                else {
+                    resolve(null);
+                    this.message.Error("Error", res['message']);
+                }
+            }, err => reject(err));
+        });
+    }
+}
+HttpService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: HttpService, deps: [{ token: i1.HttpClient }, { token: i2.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+HttpService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: HttpService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: HttpService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ 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":"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","sourcesContent":["import { MessageService } from './message.service';\r\nimport { Injectable } from '@angular/core';\r\nimport { HttpClient, HttpParams } from '@angular/common/http';\r\n\r\n@Injectable()\r\nexport class HttpService {\r\n\r\n  constructor(\r\n    private http : HttpClient,\r\n    private message: MessageService\r\n  ) { }\r\n\r\n  getData(url:string, params?){\r\n\r\n    let data = new HttpParams()\r\n    if(params){\r\n    params.forEach(element => {\r\n    data = data.append(`${element.id}`, `${element.value}`);\r\n    });\r\n    }\r\n    return this.http.get(url, {params:data})\r\n  }\r\n\r\n  postData(url:string, body:any, params?){\r\n\r\n    let data = new HttpParams()\r\n    if(params){\r\n    params.forEach(element => {\r\n    data = data.append(`${element.id}`, `${element.value}`);\r\n    });\r\n    }\r\n    return this.http.post(url, body, {params:data})\r\n  }\r\n\r\n  putData(url:string, body:any, params?){\r\n\r\n    let data = new HttpParams()\r\n    if(params){\r\n    params.forEach(element => {\r\n    data = data.append(`${element.id}`, `${element.value}`);\r\n    });\r\n    }\r\n    return this.http.put(url, body, {params:data})\r\n  }\r\n\r\n  deleteData(url:string, params?){\r\n    let data = new HttpParams()\r\n    if(params){\r\n    params.forEach(element => {\r\n    data = data.append(`${element.id}`, `${element.value}`);\r\n    });\r\n    }\r\n    return this.http.delete(url, {params:data})\r\n  }\r\n\r\n  getDataPromise(url:string, params?){\r\n    let data = new HttpParams()\r\n    if(params){\r\n    params.forEach(element => {\r\n    data = data.append(`${element.id}`, `${element.value}`);\r\n    });\r\n    }\r\n    return new Promise((resolve,reject)=>{\r\n      this.http.get(url, {params:data}).subscribe(\r\n        res=>resolve(res),\r\n        err=>reject(err)\r\n      )\r\n    })\r\n  }\r\n\r\n  postDataPromise(url:string, body:any, params?){\r\n    let data = new HttpParams()\r\n    if(params){\r\n    params.forEach(element => {\r\n    data = data.append(`${element.id}`, `${element.value}`);\r\n    });\r\n    }\r\n    return new Promise((resolve,reject)=>{\r\n      this.http.post(url, body, {params:data}).subscribe(\r\n        res=>resolve(res),\r\n        err=>reject(err)\r\n      )\r\n    })\r\n  }\r\n\r\n  putDataPromise(url:string, body:any, params?){\r\n    let data = new HttpParams()\r\n    if(params){\r\n    params.forEach(element => {\r\n    data = data.append(`${element.id}`, `${element.value}`);\r\n    });\r\n    }\r\n    return new Promise((resolve,reject)=>{\r\n      this.http.put(url, body, {params:data}).subscribe(\r\n        res=>resolve(res),\r\n        err=>reject(err)\r\n      )\r\n    })\r\n  }\r\n\r\n  deleteDataPromise(url:string, params?){\r\n    let data = new HttpParams()\r\n    if(params){\r\n    params.forEach(element => {\r\n    data = data.append(`${element.id}`, `${element.value}`);\r\n    });\r\n    }\r\n    return new Promise((resolve,reject)=>{\r\n      this.http.delete(url, {params:data}).subscribe(\r\n        res=>resolve(res),\r\n        err=>reject(err)\r\n      )\r\n    })\r\n  }\r\n\r\n  getDataBody<T>(url:string, params?): Promise<T>{\r\n    let data = new HttpParams()\r\n    if(params){\r\n    params.forEach(element => {\r\n    data = data.append(`${element.id}`, `${element.value}`);\r\n    });\r\n    }\r\n    return new Promise((resolve,reject)=>{\r\n      this.http.get(url, {params:data}).subscribe(\r\n        res=> {\r\n          if(res['code'] === 0 && res['body']){\r\n            resolve(res['body'] as T)\r\n          }else{\r\n            resolve(null)\r\n            this.message.Error(\"Error\", res['message'])\r\n          }\r\n          }\r\n        ,\r\n        err=>reject(err)\r\n      )\r\n    })\r\n  }\r\n\r\n  postDataBody<T>(url:string, body:any, params?): Promise<T>{\r\n    let data = new HttpParams()\r\n    if(params){\r\n    params.forEach(element => {\r\n    data = data.append(`${element.id}`, `${element.value}`);\r\n    });\r\n    }\r\n    return new Promise((resolve,reject)=>{\r\n      this.http.post(url, body, {params:data}).subscribe(\r\n        res=> {\r\n          if(res['code'] === 0 && res['body']){\r\n            resolve(res['body'] as T)\r\n          }else{\r\n            resolve(null)\r\n            this.message.Error(\"Error\", res['message'])\r\n          }\r\n          }\r\n        ,\r\n        err=>reject(err)\r\n      )\r\n    })\r\n  }\r\n\r\n  putDataBody<T>(url:string, body:any, params?): Promise<T>{\r\n    let data = new HttpParams()\r\n    if(params){\r\n    params.forEach(element => {\r\n    data = data.append(`${element.id}`, `${element.value}`);\r\n    });\r\n    }\r\n    return new Promise((resolve,reject)=>{\r\n      this.http.put(url, body, {params:data}).subscribe(\r\n        res=> {\r\n          if(res['code'] === 0 && res['body']){\r\n            resolve(res['body'] as T)\r\n          }else{\r\n            resolve(null)\r\n            this.message.Error(\"Error\", res['message'])\r\n          }\r\n          }\r\n        ,\r\n        err=>reject(err)\r\n      )\r\n    })\r\n  }\r\n\r\n}\r\n"]}