brainloper-ui 1.0.0

package/esm2020/src/app/modules/interfaces/enum/enumActions.mjs

@@ -0,0 +1,7 @@
+export var enumActions;
+(function (enumActions) {
+    enumActions[enumActions["REPLACE"] = 0] = "REPLACE";
+    enumActions[enumActions["ADD"] = 1] = "ADD";
+    enumActions[enumActions["REMOVE"] = 2] = "REMOVE";
+})(enumActions || (enumActions = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW51bUFjdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL21vZHVsZXMvaW50ZXJmYWNlcy9lbnVtL2VudW1BY3Rpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLFdBSVg7QUFKRCxXQUFZLFdBQVc7SUFDbkIsbURBQU8sQ0FBQTtJQUNQLDJDQUFHLENBQUE7SUFDSCxpREFBTSxDQUFBO0FBQ1YsQ0FBQyxFQUpXLFdBQVcsS0FBWCxXQUFXLFFBSXRCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gZW51bUFjdGlvbnMge1xyXG4gICAgUkVQTEFDRSxcclxuICAgIEFERCxcclxuICAgIFJFTU9WRVxyXG59Il19

package/esm2020/src/app/modules/interfaces/enum/enumRules.mjs

@@ -0,0 +1,8 @@
+export var enumRules;
+(function (enumRules) {
+    enumRules[enumRules[">"] = 0] = ">";
+    enumRules[enumRules["<"] = 1] = "<";
+    enumRules[enumRules["=="] = 2] = "==";
+    enumRules[enumRules["!="] = 3] = "!=";
+})(enumRules || (enumRules = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW51bVJ1bGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9tb2R1bGVzL2ludGVyZmFjZXMvZW51bS9lbnVtUnVsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksU0FLWDtBQUxELFdBQVksU0FBUztJQUNqQixtQ0FBRyxDQUFBO0lBQ0gsbUNBQUcsQ0FBQTtJQUNILHFDQUFJLENBQUE7SUFDSixxQ0FBSSxDQUFBO0FBQ1IsQ0FBQyxFQUxXLFNBQVMsS0FBVCxTQUFTLFFBS3BCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gZW51bVJ1bGVzIHtcclxuICAgIFwiPlwiLFxyXG4gICAgXCI8XCIsXHJcbiAgICBcIj09XCIsXHJcbiAgICBcIiE9XCJcclxufSJdfQ==

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1mb3Jtcy1wYXJhbXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL21vZHVsZXMvaW50ZXJmYWNlcy9maWxlLWZvcm1zLXNlcnZpY2UvZmlsZS1mb3Jtcy1wYXJhbXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgZmlsZUZvcm1zUGFyYW1zIHtcclxuICAgaWQ6c3RyaW5nLFxyXG4gICB2YWx1ZTphbnlcclxufVxyXG4iXX0=

package/esm2020/src/app/modules/interfaces/file-forms-service/file-input-params.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1pbnB1dC1wYXJhbXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL21vZHVsZXMvaW50ZXJmYWNlcy9maWxlLWZvcm1zLXNlcnZpY2UvZmlsZS1pbnB1dC1wYXJhbXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgZmlsZUlucHV0UGFyYW1zIHtcclxuICAgIHR5cGVGaWxlOnN0cmluZyxcclxuICAgIGlucHV0OnN0cmluZyxcclxuICAgIGVkaXQ/OmJvb2xlYW4sXHJcbiAgICBsYWJlbD86c3RyaW5nLFxyXG4gICAgaW1hZ2VTcmM/OnN0cmluZyxcclxuICAgIHN0eWxlOntcclxuICAgICB3aWR0aDpzdHJpbmcsICAgXHJcbiAgICAgaGVpZ2h0PzpzdHJpbmcsXHJcbiAgICAgYm9yZGVyPzpzdHJpbmcsXHJcbiAgICAgc2hhcGU/OnN0cmluZ1xyXG4gICB9XHJcblxyXG59XHJcbiJdfQ==

package/esm2020/src/app/modules/interfaces/filters/header-filters.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVyLWZpbHRlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL21vZHVsZXMvaW50ZXJmYWNlcy9maWx0ZXJzL2hlYWRlci1maWx0ZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIEhlYWRlckZpbHRlcnMge1xyXG4gIHROOiBzdHJpbmcsXHJcbiAgdmlzaWJsZUZpZWxkOnN0cmluZyxcclxuICBwcmltYXJ5S2V5PzpzdHJpbmcsXHJcbiAgdHlwZTpzdHJpbmcsXHJcbiAgdmFsdWU6c3RyaW5nLFxyXG4gIGZpbGVGaWx0ZXI/OnN0cmluZyxcclxuICB1cmxEYXRhPzpzdHJpbmcsXHJcbiAgYm9keT86YW55LFxyXG4gIGFjdGl2ZT86Ym9vbGVhbixcclxuICBmaWxlTmFtZURiPzpzdHJpbmdcclxufVxyXG4iXX0=

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: "13.1.1", ngImport: i0, type: CryptoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CryptoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: CryptoService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", 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,143 @@
+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 generateToXlsx(title, header, name, body, url, params, filtersPost) {
+        this.message.openLoading("Cargando", "Generando archivo");
+        let data = [];
+        if (!body) {
+            if (url) {
+                var res;
+                if (filtersPost.length > 0) {
+                    res = await this.http.postDataBody(url, filtersPost, params);
+                }
+                else {
+                    res = await this.http.getDataBody(url, params);
+                }
+                if (res['count']) {
+                    data = res['data'];
+                }
+                else {
+                    data = res;
+                }
+            }
+        }
+        else {
+            data = body;
+        }
+        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,
+        };
+        //Add row with current date
+        let subTitleRow = worksheet.addRow(['Date :  ' + this.functionEter.dateDB(new Date())]);
+        // Blank Row
+        worksheet.addRow([]);
+        let addheader = false;
+        for (let p of header) {
+            if (p.id === null) {
+                worksheet.addRow([p.value]);
+                addheader = true;
+            }
+        }
+        if (addheader)
+            worksheet.addRow([]);
+        //Add Header Row
+        let headerRowValue = header.filter(x => x.id != null).map((p) => { return p.value; });
+        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);
+        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;
+        });
+        //data.forEach((d) => {
+        // let qty = row.getCell(5);
+        // let color = 'FF99FF99';
+        // if (+qty.value < 500) {
+        //   color = 'FF9999'
+        // }
+        // qty.fill = {
+        //   type: 'pattern',
+        //   pattern: 'solid',
+        //   fgColor: { argb: color }
+        // }
+        //});
+        workbook.xlsx.writeBuffer().then((data) => {
+            let blob = new Blob([data], {
+                type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            });
+            fs.saveAs(blob, name + '.xlsx');
+        });
+        this.message.closeLoading();
+    }
+}
+ExportDataService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", 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: "13.1.1", ngImport: i0, type: ExportDataService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", 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\n\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\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  public async generateToXlsx<T>(title:string, header:Array<params>, name:string, body?: Array<T>, url?: string, params?: Array<params>, filtersPost?:Array<HeaderFilters>) {\r\n    this.message.openLoading(\"Cargando\", \"Generando archivo\")\r\n    let data = []\r\n    if(!body){\r\n      if(url) {\r\n        var res: any\r\n        if(filtersPost.length > 0){\r\n          res = await this.http.postDataBody(url, filtersPost, params)\r\n        }else{\r\n          res = await this.http.getDataBody(url, params)\r\n        }\r\n        if(res['count']){\r\n          data = res['data']\r\n        }else{\r\n          data = res\r\n        }\r\n      }\r\n\r\n    }else{\r\n      data = body\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    //Add row with current date\r\n    let subTitleRow = worksheet.addRow(['Date :  ' + this.functionEter.dateDB(new Date())]);\r\n\r\n    // Blank Row\r\n    worksheet.addRow([]);\r\n    let addheader = false\r\n    for(let p of header){\r\n      if(p.id === null){\r\n        worksheet.addRow([p.value])\r\n        addheader = true\r\n      }\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})\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    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    //data.forEach((d) => {\r\n      // let qty = row.getCell(5);\r\n      // let color = 'FF99FF99';\r\n      // if (+qty.value < 500) {\r\n      //   color = 'FF9999'\r\n      // }\r\n      // qty.fill = {\r\n      //   type: 'pattern',\r\n      //   pattern: 'solid',\r\n      //   fgColor: { argb: color }\r\n      // }\r\n    //});\r\n\r\n    workbook.xlsx.writeBuffer().then((data) => {\r\n      let blob = new Blob([data], {\r\n        type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\r\n      });\r\n      fs.saveAs(blob, name + '.xlsx');\r\n    });\r\n    this.message.closeLoading()\r\n  }\r\n}\r\n\r\nenum enumRules {\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: "13.1.1", ngImport: i0, type: FileFormsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FileFormsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FileFormsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", 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,48 @@
+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}`;
+    }
+    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: "13.1.1", ngImport: i0, type: FunctionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FunctionsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FunctionsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", 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: "13.1.1", ngImport: i0, type: GeneratePdfService, deps: [{ token: i1.MatDialog }], target: i0.ɵɵFactoryTarget.Injectable });
+GeneratePdfService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: GeneratePdfService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", 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: "13.1.1", ngImport: i0, type: HttpService, deps: [{ token: i1.HttpClient }, { token: i2.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+HttpService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: HttpService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", 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"]}