dts-backoffice-util 4.0.0 → 6.0.1

package/esm2020/lib/services/session-info.service.mjs

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class UserLoginService {
+    constructor(http) {
+        this.http = http;
+        this.apiUrl = '/totvs-menu/rest/getSessionInfo';
+        this.userLogin = undefined;
+    }
+    getUserLogin() {
+        if (localStorage.getItem('username')) {
+            return of(localStorage.getItem('username'));
+        }
+        if (this.userLogin) {
+            return of(this.userLogin);
+        }
+        else {
+            return this.http.get(`${this.apiUrl}`)
+                .pipe(map((response) => {
+                this.userLogin = response.userName;
+                return response.userName;
+            }));
+        }
+    }
+}
+/** @nocollapse */ UserLoginService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: UserLoginService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ UserLoginService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: UserLoginService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: UserLoginService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbi1pbmZvLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kdHMtYmFja29mZmljZS11dGlsL3NyYy9saWIvc2VydmljZXMvc2Vzc2lvbi1pbmZvLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUczQyxPQUFPLEVBQWMsRUFBRSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ3RDLE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQzs7O0FBS3JDLE1BQU0sT0FBTyxnQkFBZ0I7SUFLekIsWUFBbUIsSUFBZ0I7UUFBaEIsU0FBSSxHQUFKLElBQUksQ0FBWTtRQUgxQixXQUFNLEdBQUcsaUNBQWlDLENBQUM7UUFDcEQsY0FBUyxHQUFHLFNBQVMsQ0FBQztJQUVpQixDQUFDO0lBRXhDLFlBQVk7UUFDUixJQUFJLFlBQVksQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLEVBQUU7WUFDbEMsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDO1NBQy9DO1FBRUQsSUFBSSxJQUFJLENBQUMsU0FBUyxFQUFFO1lBQ2hCLE9BQU8sRUFBRSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztTQUM3QjthQUFNO1lBQ0gsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBZSxHQUFHLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztpQkFDL0MsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFO2dCQUNuQixJQUFJLENBQUMsU0FBUyxHQUFHLFFBQVEsQ0FBQyxRQUFRLENBQUM7Z0JBQ25DLE9BQU8sUUFBUSxDQUFDLFFBQVEsQ0FBQztZQUM3QixDQUFDLENBQUMsQ0FBQyxDQUFDO1NBQ1g7SUFDTCxDQUFDOztpSUFyQlEsZ0JBQWdCO3FJQUFoQixnQkFBZ0IsY0FGYixNQUFNOzRGQUVULGdCQUFnQjtrQkFINUIsVUFBVTttQkFBQztvQkFDUixVQUFVLEVBQUUsTUFBTTtpQkFDckIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEh0dHBDbGllbnQgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XHJcbmltcG9ydCB7IElTZXNzaW9uSW5mbyB9IGZyb20gJy4uL21vZGVsL3Nlc3Npb24taW5mby5tb2RlbCc7XHJcbmltcG9ydCB7IE9ic2VydmFibGUsIG9mIH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IG1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuICAgIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgVXNlckxvZ2luU2VydmljZSB7XHJcblxyXG4gICAgcmVhZG9ubHkgYXBpVXJsID0gJy90b3R2cy1tZW51L3Jlc3QvZ2V0U2Vzc2lvbkluZm8nO1xyXG4gICAgdXNlckxvZ2luID0gdW5kZWZpbmVkO1xyXG5cclxuICAgIGNvbnN0cnVjdG9yKHB1YmxpYyBodHRwOiBIdHRwQ2xpZW50KSB7IH1cclxuXHJcbiAgICBnZXRVc2VyTG9naW4oKTogT2JzZXJ2YWJsZTxzdHJpbmc+IHtcclxuICAgICAgICBpZiAobG9jYWxTdG9yYWdlLmdldEl0ZW0oJ3VzZXJuYW1lJykpIHtcclxuICAgICAgICAgICAgcmV0dXJuIG9mKGxvY2FsU3RvcmFnZS5nZXRJdGVtKCd1c2VybmFtZScpKTtcclxuICAgICAgICB9XHJcblxyXG4gICAgICAgIGlmICh0aGlzLnVzZXJMb2dpbikge1xyXG4gICAgICAgICAgICByZXR1cm4gb2YodGhpcy51c2VyTG9naW4pO1xyXG4gICAgICAgIH0gZWxzZSB7XHJcbiAgICAgICAgICAgIHJldHVybiB0aGlzLmh0dHAuZ2V0PElTZXNzaW9uSW5mbz4oYCR7dGhpcy5hcGlVcmx9YClcclxuICAgICAgICAgICAgICAgIC5waXBlKG1hcCgocmVzcG9uc2UpID0+IHtcclxuICAgICAgICAgICAgICAgICAgICB0aGlzLnVzZXJMb2dpbiA9IHJlc3BvbnNlLnVzZXJOYW1lO1xyXG4gICAgICAgICAgICAgICAgICAgIHJldHVybiByZXNwb25zZS51c2VyTmFtZTtcclxuICAgICAgICAgICAgICAgIH0pKTtcclxuICAgICAgICB9XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2020/lib/services/translate.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TranslateService {
+    static getSuportLanguage() {
+        return ['pt-BR', 'pt', 'en-US', 'en', 'es'];
+    }
+    static getDefaultCurrencyCode() {
+        return '$';
+    }
+    static getCurrentLanguage() {
+        const locale = localStorage.getItem('user.language') || navigator.language;
+        if (locale && this.getSuportLanguage().includes(locale)) {
+            return locale;
+        }
+        return 'en-US';
+    }
+}
+/** @nocollapse */ TranslateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TranslateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ TranslateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TranslateService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TranslateService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRlLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kdHMtYmFja29mZmljZS11dGlsL3NyYy9saWIvc2VydmljZXMvdHJhbnNsYXRlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFHM0MsTUFBTSxPQUFPLGdCQUFnQjtJQUV6QixNQUFNLENBQUMsaUJBQWlCO1FBQ3BCLE9BQU8sQ0FBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDaEQsQ0FBQztJQUVELE1BQU0sQ0FBQyxzQkFBc0I7UUFDekIsT0FBTyxHQUFHLENBQUM7SUFDZixDQUFDO0lBRUQsTUFBTSxDQUFDLGtCQUFrQjtRQUNyQixNQUFNLE1BQU0sR0FBRyxZQUFZLENBQUMsT0FBTyxDQUFDLGVBQWUsQ0FBQyxJQUFJLFNBQVMsQ0FBQyxRQUFRLENBQUM7UUFFM0UsSUFBSSxNQUFNLElBQUksSUFBSSxDQUFDLGlCQUFpQixFQUFFLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxFQUFFO1lBQUUsT0FBTyxNQUFNLENBQUM7U0FBRTtRQUUzRSxPQUFPLE9BQU8sQ0FBQztJQUNuQixDQUFDOztpSUFoQlEsZ0JBQWdCO3FJQUFoQixnQkFBZ0I7NEZBQWhCLGdCQUFnQjtrQkFENUIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbkBJbmplY3RhYmxlKClcclxuZXhwb3J0IGNsYXNzIFRyYW5zbGF0ZVNlcnZpY2Uge1xyXG5cclxuICAgIHN0YXRpYyBnZXRTdXBvcnRMYW5ndWFnZSgpIHtcclxuICAgICAgICByZXR1cm4gWydwdC1CUicsICdwdCcsICdlbi1VUycsICdlbicsICdlcyddO1xyXG4gICAgfVxyXG5cclxuICAgIHN0YXRpYyBnZXREZWZhdWx0Q3VycmVuY3lDb2RlKCkge1xyXG4gICAgICAgIHJldHVybiAnJCc7XHJcbiAgICB9XHJcblxyXG4gICAgc3RhdGljIGdldEN1cnJlbnRMYW5ndWFnZSgpIHtcclxuICAgICAgICBjb25zdCBsb2NhbGUgPSBsb2NhbFN0b3JhZ2UuZ2V0SXRlbSgndXNlci5sYW5ndWFnZScpIHx8IG5hdmlnYXRvci5sYW5ndWFnZTtcclxuXHJcbiAgICAgICAgaWYgKGxvY2FsZSAmJiB0aGlzLmdldFN1cG9ydExhbmd1YWdlKCkuaW5jbHVkZXMobG9jYWxlKSkgeyByZXR1cm4gbG9jYWxlOyB9XHJcblxyXG4gICAgICAgIHJldHVybiAnZW4tVVMnO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2020/lib/utils/file.util.mjs

@@ -0,0 +1,129 @@
+export class FileUtil {
+    constructor() { }
+    static downloadFile(data, fileName, contentType, base64) {
+        base64 = (base64 === false) ? false : true;
+        const dataBlob = base64 ? this.b64toBlob(data, contentType) : data;
+        this.download(dataBlob, fileName);
+    }
+    static downloadData(data, dwldDataParam = null) {
+        if (!data) {
+            return;
+        }
+        if (!dwldDataParam) {
+            dwldDataParam = new DownloadDataParams();
+        }
+        if (!dwldDataParam.fileName) {
+            dwldDataParam.fileName = 'data.csv';
+        }
+        if (!dwldDataParam.literals) {
+            dwldDataParam.literals = {};
+        }
+        if (!dwldDataParam.columnDelimiter) {
+            dwldDataParam.columnDelimiter = ';';
+        }
+        if (!dwldDataParam.columnList) {
+            dwldDataParam.columnList = [];
+        }
+        if (!dwldDataParam.columnExclude) {
+            dwldDataParam.columnExclude = [];
+        }
+        const datab64 = btoa(this.jsonToString(data, dwldDataParam));
+        this.downloadFile(datab64, dwldDataParam.fileName, 'text/csv');
+    }
+    static download(file, fileName) {
+        const binaryData = [file];
+        const downloadLink = document.createElement('a');
+        const urlDownload = window.URL.createObjectURL(new Blob(binaryData, { type: file.type }));
+        /**Verifica se é ie ou edge, pois o mesmo tem tratamento próprio para arquivos blob */
+        const nav = window.navigator;
+        if (nav && nav.msSaveOrOpenBlob) {
+            nav.msSaveOrOpenBlob(file, fileName);
+        }
+        else {
+            downloadLink.href = urlDownload;
+            downloadLink.setAttribute('download', fileName);
+            document.body.appendChild(downloadLink);
+            downloadLink.click();
+            window.URL.revokeObjectURL(urlDownload);
+            downloadLink.remove();
+        }
+    }
+    static b64toBlob(b64Data, contentType, sliceSize) {
+        contentType = contentType || '';
+        sliceSize = sliceSize || 512;
+        const byteCharacters = atob(b64Data);
+        const byteArrays = [];
+        for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {
+            const slice = byteCharacters.slice(offset, offset + sliceSize);
+            const byteNumbers = new Array(slice.length);
+            for (let i = 0; i < slice.length; i++) {
+                byteNumbers[i] = slice.charCodeAt(i);
+            }
+            const byteArray = new Uint8Array(byteNumbers);
+            byteArrays.push(byteArray);
+        }
+        const blob = new Blob(byteArrays, { type: contentType });
+        return blob;
+    }
+    static jsonToString(jsonData, dwldDataParam) {
+        if (!jsonData || jsonData.length === 0) {
+            return '';
+        }
+        const lineDelimiter = '\n';
+        let columnOrig = null;
+        let columnHeader = null;
+        const keys = [];
+        let includeKey;
+        if (dwldDataParam.columnList &&
+            dwldDataParam.columnList.length > 0) {
+            columnOrig = dwldDataParam.columnList;
+        }
+        else {
+            columnOrig = Object.keys(jsonData[0]);
+        }
+        columnOrig.forEach(key => {
+            includeKey = true;
+            if (dwldDataParam.columnExclude &&
+                dwldDataParam.columnExclude.length > 0 &&
+                dwldDataParam.columnExclude.indexOf(key) !== -1) {
+                includeKey = false;
+            }
+            if (includeKey) {
+                keys.push(key);
+                columnHeader = (!columnHeader) ? '' : columnHeader + dwldDataParam.columnDelimiter;
+                columnHeader += (dwldDataParam.literals[key]) ? dwldDataParam.literals[key] : key;
+            }
+        });
+        const lineStr = jsonData.reduce((accLineStr, currentItem) => {
+            let first = true;
+            let columnValue = null;
+            keys.forEach(key => {
+                if (!first) {
+                    accLineStr += dwldDataParam.columnDelimiter;
+                }
+                columnValue = currentItem[key];
+                if (columnValue === null || columnValue === undefined) {
+                    columnValue = '';
+                }
+                switch (typeof (columnValue)) {
+                    case 'number':
+                        columnValue = columnValue.toLocaleString();
+                        break;
+                    case 'boolean':
+                        columnValue = (dwldDataParam.literals[`${columnValue}`]) ?
+                            dwldDataParam.literals[`${columnValue}`] : columnValue;
+                        break;
+                    case 'object':
+                        columnValue = JSON.stringify(columnValue);
+                }
+                accLineStr += columnValue;
+                first = false;
+            });
+            return accLineStr + lineDelimiter;
+        }, columnHeader + lineDelimiter);
+        return lineStr;
+    }
+}
+export class DownloadDataParams {
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file.util.js","sourceRoot":"","sources":["../../../../../projects/dts-backoffice-util/src/lib/utils/file.util.ts"],"names":[],"mappings":"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","sourcesContent":["export class FileUtil {\r\n\r\n    constructor(\r\n    ) { }\r\n\r\n    static downloadFile(data: any, fileName: string, contentType?: string, base64?: boolean): void {\r\n        base64 = (base64 === false) ? false : true;\r\n        const dataBlob = base64 ? this.b64toBlob(data, contentType) : data;\r\n        this.download(dataBlob, fileName);\r\n    }\r\n\r\n    static downloadData(data: Array<any>, dwldDataParam: IDownloadDataParams = null): void {\r\n        if (!data) { return; }\r\n\r\n        if (!dwldDataParam) { dwldDataParam = new DownloadDataParams(); }\r\n        if (!dwldDataParam.fileName) { dwldDataParam.fileName = 'data.csv'; }\r\n        if (!dwldDataParam.literals) { dwldDataParam.literals = {}; }\r\n        if (!dwldDataParam.columnDelimiter) { dwldDataParam.columnDelimiter = ';'; }\r\n        if (!dwldDataParam.columnList) { dwldDataParam.columnList = []; }\r\n        if (!dwldDataParam.columnExclude) { dwldDataParam.columnExclude = []; }\r\n\r\n        const datab64 = btoa(this.jsonToString(data, dwldDataParam));\r\n        this.downloadFile(datab64, dwldDataParam.fileName, 'text/csv');\r\n    }\r\n\r\n    private static download(file: Blob, fileName: string): void {\r\n        const binaryData = [file];\r\n        const downloadLink = document.createElement('a');\r\n        const urlDownload = window.URL.createObjectURL(new Blob(binaryData, { type: file.type }));\r\n\r\n        /**Verifica se é ie ou edge, pois o mesmo tem tratamento próprio para arquivos blob */\r\n        const nav = (window.navigator as any);\r\n        if (nav && nav.msSaveOrOpenBlob) {\r\n            nav.msSaveOrOpenBlob(file, fileName);\r\n        } else {\r\n            downloadLink.href = urlDownload;\r\n            downloadLink.setAttribute('download', fileName);\r\n            document.body.appendChild(downloadLink);\r\n            downloadLink.click();\r\n            window.URL.revokeObjectURL(urlDownload);\r\n            downloadLink.remove();\r\n        }\r\n    }\r\n\r\n    private static b64toBlob(b64Data: any, contentType?: string, sliceSize?: number): Blob {\r\n        contentType = contentType || '';\r\n        sliceSize = sliceSize || 512;\r\n\r\n        const byteCharacters = atob(b64Data);\r\n        const byteArrays = [];\r\n\r\n        for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {\r\n            const slice = byteCharacters.slice(offset, offset + sliceSize);\r\n\r\n            const byteNumbers = new Array(slice.length);\r\n            for (let i = 0; i < slice.length; i++) {\r\n                byteNumbers[i] = slice.charCodeAt(i);\r\n            }\r\n\r\n            const byteArray = new Uint8Array(byteNumbers);\r\n            byteArrays.push(byteArray);\r\n        }\r\n\r\n        const blob = new Blob(byteArrays, { type: contentType });\r\n        return blob;\r\n    }\r\n\r\n    private static jsonToString(jsonData: Array<any>, dwldDataParam: IDownloadDataParams): string {\r\n        if (!jsonData || jsonData.length === 0) { return ''; }\r\n\r\n        const lineDelimiter = '\\n';\r\n\r\n        let columnOrig = null;\r\n        let columnHeader = null;\r\n        const keys = [];\r\n        let includeKey: boolean;\r\n\r\n        if (dwldDataParam.columnList &&\r\n            dwldDataParam.columnList.length > 0) {\r\n            columnOrig = dwldDataParam.columnList;\r\n        } else {\r\n            columnOrig = Object.keys(jsonData[0]);\r\n        }\r\n\r\n        columnOrig.forEach(key => {\r\n            includeKey = true;\r\n\r\n            if (dwldDataParam.columnExclude &&\r\n                dwldDataParam.columnExclude.length > 0 &&\r\n                dwldDataParam.columnExclude.indexOf(key) !== -1) {\r\n                includeKey = false;\r\n            }\r\n\r\n            if (includeKey) {\r\n                keys.push(key);\r\n                columnHeader = (!columnHeader) ? '' : columnHeader + dwldDataParam.columnDelimiter;\r\n                columnHeader += (dwldDataParam.literals[key]) ? dwldDataParam.literals[key] : key;\r\n            }\r\n        });\r\n\r\n        const lineStr = jsonData.reduce((accLineStr, currentItem) => {\r\n            let first = true;\r\n            let columnValue = null;\r\n\r\n            keys.forEach(key => {\r\n                if (!first) { accLineStr += dwldDataParam.columnDelimiter; }\r\n\r\n                columnValue = currentItem[key];\r\n                if (columnValue === null || columnValue === undefined) { columnValue = ''; }\r\n                switch (typeof (columnValue)) {\r\n                    case 'number':\r\n                        columnValue = columnValue.toLocaleString();\r\n                        break;\r\n                    case 'boolean':\r\n                        columnValue = (dwldDataParam.literals[`${columnValue}`]) ?\r\n                            dwldDataParam.literals[`${columnValue}`] : columnValue;\r\n                        break;\r\n                    case 'object':\r\n                        columnValue = JSON.stringify(columnValue);\r\n                }\r\n                accLineStr += columnValue;\r\n\r\n                first = false;\r\n            });\r\n\r\n            return accLineStr + lineDelimiter;\r\n\r\n        }, columnHeader + lineDelimiter);\r\n\r\n        return lineStr;\r\n    }\r\n}\r\n\r\nexport interface IDownloadDataParams {\r\n    fileName: string;\r\n    literals: any;\r\n    columnDelimiter: string;\r\n    columnList: Array<string>;\r\n    columnExclude: Array<string>;\r\n}\r\n\r\nexport class DownloadDataParams implements IDownloadDataParams {\r\n    fileName: string;\r\n    literals: any;\r\n    columnDelimiter: string;\r\n    columnList: Array<string>;\r\n    columnExclude: Array<string>;\r\n}\r\n"]}