dts-backoffice-util 3.0.0 → 6.0.0

package/esm2020/lib/utils/field-validation.util.mjs

@@ -0,0 +1,179 @@
+/*
+Versão: 1.002
+Data Criação: 19/02/2019
+*/
+import { DisclaimerUtil } from './disclaimer.util';
+export class FieldValidationUtil {
+    constructor(poNotification, poI18nPipe, literals) {
+        this.literals = {};
+        this.poNotification = poNotification;
+        this.poI18nPipe = poI18nPipe;
+        this.literals = literals;
+        this.disclaimerUtil = new DisclaimerUtil(this.poNotification, this.poI18nPipe, this.literals);
+    }
+    vldFieldCharacter(field, value) {
+        if (!value || value.trim() === '') {
+            this.poNotification.error({
+                message: this.poI18nPipe.transform(this.literals['fieldVldRequered'], [this.literals[field]])
+            });
+            return false;
+        }
+        return true;
+    }
+    // Valida uma faixa de caracteres se o inicial é menor que final
+    vldRangeCharacter(initialField, finalField, initialValue, finalValue) {
+        if (!initialValue || !finalValue) {
+            return true;
+        }
+        if (initialValue.trim().toUpperCase() > finalValue.trim().toUpperCase()) {
+            this.poNotification.error({
+                message: this.poI18nPipe.transform(this.literals['fieldVldRange'], [this.literals[initialField], this.literals[finalField]])
+            });
+            return false;
+        }
+        return true;
+    }
+    vldFieldNumber(field, value, vldValue = false, zeroAccept = false) {
+        if (vldValue && !this.vldValueOfNumber(field, value)) {
+            return false;
+        }
+        if ((!value) || value <= 0) {
+            if (value === 0 && zeroAccept === true) {
+                return true;
+            }
+            this.poNotification.error({
+                message: this.poI18nPipe.transform(this.literals['fieldVldRequered'], [this.literals[field]])
+            });
+            return false;
+        }
+        return true;
+    }
+    vldValueOfNumber(field, value) {
+        if (value && value < 0) {
+            this.poNotification.error({ message: this.poI18nPipe.transform(this.literals['fieldVldNumber'], [value.toString(), this.literals[field]]) });
+            return false;
+        }
+        return true;
+    }
+    vldFieldPercent(field, value, vldValue = false) {
+        if (vldValue && !this.vldValueOfPercent(field, value)) {
+            return false;
+        }
+        if (!this.vldFieldNumber(field, value)) {
+            return false;
+        }
+        return true;
+    }
+    vldValueOfPercent(field, value) {
+        if (value && value < 0) {
+            this.poNotification.error({ message: this.poI18nPipe.transform(this.literals['fieldVldNumber'], [value.toString(), this.literals[field]]) });
+            return false;
+        }
+        if (value && value > 100) {
+            this.poNotification.error({ message: this.poI18nPipe.transform(this.literals['fieldVldNumber'], [value.toString(), this.literals[field]]) });
+            return false;
+        }
+        return true;
+    }
+    // Valida uma faixa de números se o inicial é menor que final
+    vldRangeNumber(initialField, finalField, initialValue, finalValue) {
+        if (!initialValue) {
+            initialValue = 0;
+        }
+        if (!finalValue) {
+            finalValue = 0;
+        }
+        if (initialValue > finalValue) {
+            this.poNotification.error({
+                message: this.poI18nPipe.transform(this.literals['fieldVldRange'], [this.literals[initialField], this.literals[finalField]])
+            });
+            return false;
+        }
+        return true;
+    }
+    vldFieldDate(field, value) {
+        const valDate = this.disclaimerUtil.ajustDate(value);
+        if (!this.disclaimerUtil.isValidDate(valDate)) {
+            this.poNotification.error({
+                message: this.poI18nPipe.transform(this.literals['fieldVldDate'], [this.literals[field]])
+            });
+            return false;
+        }
+        return true;
+    }
+    // Valida uma faixa de datas se o inicial é menor que final
+    vldRangeDate(initialField, finalField, initialValue, finalValue) {
+        if (!initialValue || !finalValue) {
+            return true;
+        }
+        const valInitialDate = this.disclaimerUtil.ajustDate(initialValue).getTime();
+        const valFinalDate = this.disclaimerUtil.ajustDate(finalValue).getTime();
+        if (valInitialDate > valFinalDate) {
+            this.poNotification.error({
+                message: this.poI18nPipe.transform(this.literals['fieldVldRange'], [this.literals[initialField], this.literals[finalField]])
+            });
+            return false;
+        }
+        return true;
+    }
+    vldFieldMultiSelect(field, value) {
+        if (!value || value.length === 0) {
+            this.poNotification.error({
+                message: this.poI18nPipe.transform(this.literals['fieldVldSelected'], [this.literals[field]])
+            });
+            return false;
+        }
+        return true;
+    }
+    vldFieldCheckbox(field, value) {
+        if (!value || value.length === 0) {
+            this.poNotification.error({
+                message: this.poI18nPipe.transform(this.literals['fieldVldSelected'], [this.literals[field]])
+            });
+            return false;
+        }
+        return true;
+    }
+    // Valida formato conforme regra: "9" apenas números, "X" qualquer caracter, "!" apenas letras maiúsculas
+    vldFieldFormat(field, value, format, replacePoint = false) {
+        let lOK = true;
+        let oldFormat;
+        if (!value) {
+            return lOK;
+        }
+        /*Retira os pontos do formato*/
+        if (replacePoint) {
+            oldFormat = format;
+            format = format.replace(/\./g, '');
+        }
+        if (value.length !== format.length) {
+            lOK = false;
+        }
+        else {
+            for (let idx = 0; idx < format.length; idx++) {
+                if (format[idx] === '9') {
+                    if (value[idx].replace(/[0-9]/, '9') !== '9') {
+                        lOK = false;
+                        break;
+                    }
+                }
+                if (format[idx] === '!') {
+                    if (value[idx].replace(/[A-Z]/, 'A') !== 'A') {
+                        lOK = false;
+                        break;
+                    }
+                }
+            }
+        }
+        if (replacePoint) {
+            format = oldFormat;
+        }
+        if (!lOK) {
+            this.poNotification.error({
+                message: this.poI18nPipe.transform(this.literals['fieldVldFormat'], [this.literals[field], format])
+            });
+        }
+        return lOK;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-validation.util.js","sourceRoot":"","sources":["../../../../../projects/dts-backoffice-util/src/lib/utils/field-validation.util.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\nVersão: 1.002\r\nData Criação: 19/02/2019\r\n*/\r\n\r\nimport { PoNotificationService, PoI18nPipe } from '@po-ui/ng-components';\r\nimport { DisclaimerUtil } from './disclaimer.util';\r\n\r\nexport class FieldValidationUtil {\r\n    poNotification: PoNotificationService;\r\n    poI18nPipe: PoI18nPipe;\r\n    literals: any = {};\r\n\r\n    disclaimerUtil: DisclaimerUtil;\r\n\r\n    constructor(\r\n        poNotification: PoNotificationService,\r\n        poI18nPipe: PoI18nPipe,\r\n        literals: Object\r\n    ) {\r\n        this.poNotification = poNotification;\r\n        this.poI18nPipe = poI18nPipe;\r\n        this.literals = literals;\r\n        this.disclaimerUtil = new DisclaimerUtil(this.poNotification, this.poI18nPipe, this.literals);\r\n    }\r\n\r\n    public vldFieldCharacter(field: string, value: string): boolean {\r\n        if (!value || value.trim() === '') {\r\n            this.poNotification.error({\r\n                message: this.poI18nPipe.transform(this.literals['fieldVldRequered'], [this.literals[field]])\r\n            });\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    // Valida uma faixa de caracteres se o inicial é menor que final\r\n    public vldRangeCharacter(initialField: string, finalField: string, initialValue: string, finalValue: string): boolean {\r\n        if (!initialValue || !finalValue) {\r\n            return true;\r\n        }\r\n\r\n        if (initialValue.trim().toUpperCase() > finalValue.trim().toUpperCase()) {\r\n            this.poNotification.error({\r\n                message: this.poI18nPipe.transform(this.literals['fieldVldRange'],\r\n                    [this.literals[initialField], this.literals[finalField]])\r\n            });\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    public vldFieldNumber(field: string, value: number, vldValue = false, zeroAccept = false): boolean {\r\n        if (vldValue && !this.vldValueOfNumber(field, value)) {\r\n            return false;\r\n        }\r\n\r\n        if ((!value) || value <= 0) {\r\n            if (value === 0 && zeroAccept === true) {\r\n                return true;\r\n            }\r\n\r\n            this.poNotification.error({\r\n                message: this.poI18nPipe.transform(this.literals['fieldVldRequered'], [this.literals[field]])\r\n            });\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    public vldValueOfNumber(field: string, value: number): boolean {\r\n        if (value && value < 0) {\r\n            this.poNotification.error(\r\n                { message: this.poI18nPipe.transform(this.literals['fieldVldNumber'], [value.toString(), this.literals[field]]) });\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    public vldFieldPercent(field: string, value: number, vldValue = false): boolean {\r\n        if (vldValue && !this.vldValueOfPercent(field, value)) {\r\n            return false;\r\n        }\r\n\r\n        if (!this.vldFieldNumber(field, value)) {\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    public vldValueOfPercent(field: string, value: number): boolean {\r\n        if (value && value < 0) {\r\n            this.poNotification.error(\r\n                { message: this.poI18nPipe.transform(this.literals['fieldVldNumber'], [value.toString(), this.literals[field]]) });\r\n            return false;\r\n        }\r\n\r\n        if (value && value > 100) {\r\n            this.poNotification.error(\r\n                { message: this.poI18nPipe.transform(this.literals['fieldVldNumber'], [value.toString(), this.literals[field]]) });\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    // Valida uma faixa de números se o inicial é menor que final\r\n    public vldRangeNumber(initialField: string, finalField: string, initialValue: number, finalValue: number): boolean {\r\n        if (!initialValue) { initialValue = 0; }\r\n        if (!finalValue) { finalValue = 0; }\r\n\r\n        if (initialValue > finalValue) {\r\n            this.poNotification.error({\r\n                message: this.poI18nPipe.transform(this.literals['fieldVldRange'],\r\n                    [this.literals[initialField], this.literals[finalField]])\r\n            });\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    public vldFieldDate(field: string, value: Date): boolean {\r\n        const valDate = this.disclaimerUtil.ajustDate(value);\r\n\r\n        if (!this.disclaimerUtil.isValidDate(valDate)) {\r\n            this.poNotification.error({\r\n                message: this.poI18nPipe.transform(this.literals['fieldVldDate'], [this.literals[field]])\r\n            });\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    // Valida uma faixa de datas se o inicial é menor que final\r\n    public vldRangeDate(initialField: string, finalField: string, initialValue: Date, finalValue: Date): boolean {\r\n        if (!initialValue || !finalValue) {\r\n            return true;\r\n        }\r\n\r\n        const valInitialDate = this.disclaimerUtil.ajustDate(initialValue).getTime();\r\n        const valFinalDate = this.disclaimerUtil.ajustDate(finalValue).getTime();\r\n\r\n        if (valInitialDate > valFinalDate) {\r\n            this.poNotification.error({\r\n                message: this.poI18nPipe.transform(this.literals['fieldVldRange'],\r\n                    [this.literals[initialField], this.literals[finalField]])\r\n            });\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    public vldFieldMultiSelect(field: string, value: Array<any>): boolean {\r\n        if (!value || value.length === 0) {\r\n            this.poNotification.error({\r\n                message: this.poI18nPipe.transform(this.literals['fieldVldSelected'], [this.literals[field]])\r\n            });\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    public vldFieldCheckbox(field: string, value: Array<string>): boolean {\r\n        if (!value || value.length === 0) {\r\n            this.poNotification.error({\r\n                message: this.poI18nPipe.transform(this.literals['fieldVldSelected'], [this.literals[field]])\r\n            });\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    // Valida formato conforme regra: \"9\" apenas números, \"X\" qualquer caracter, \"!\" apenas letras maiúsculas\r\n    public vldFieldFormat(field: string, value: string, format: string, replacePoint = false): boolean {\r\n        let lOK = true;\r\n        let oldFormat: string;\r\n\r\n        if (!value) { return lOK; }\r\n\r\n        /*Retira os pontos do formato*/\r\n        if (replacePoint) {\r\n            oldFormat = format;\r\n            format = format.replace(/\\./g, '');\r\n        }\r\n\r\n        if (value.length !== format.length) {\r\n            lOK = false;\r\n        } else {\r\n            for (let idx = 0; idx < format.length; idx++) {\r\n                if (format[idx] === '9') {\r\n                    if (value[idx].replace(/[0-9]/, '9') !== '9') { lOK = false; break; }\r\n                }\r\n\r\n                if (format[idx] === '!') {\r\n                    if (value[idx].replace(/[A-Z]/, 'A') !== 'A') { lOK = false; break; }\r\n                }\r\n            }\r\n        }\r\n\r\n        if (replacePoint) {\r\n            format = oldFormat;\r\n        }\r\n\r\n        if (!lOK) {\r\n            this.poNotification.error({\r\n                message: this.poI18nPipe.transform(this.literals['fieldVldFormat'], [this.literals[field], format])\r\n            });\r\n        }\r\n\r\n        return lOK;\r\n    }\r\n}\r\n"]}

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

@@ -0,0 +1,122 @@
+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 }));
+        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        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    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"]}

package/esm2020/lib/utils/filter-range.util.mjs

@@ -0,0 +1,33 @@
+/*
+Versão: 1.000
+Data Criação: 06/08/2018
+*/
+export class FilterRangeUtil {
+    constructor() {
+    }
+    static makeFilterRangeCharacter(iniInitial, iniFinal) {
+        return {
+            iniInitial,
+            iniFinal,
+            valInitial: iniInitial,
+            valFinal: iniFinal
+        };
+    }
+    static makeFilterRangeNumber(iniInitial, iniFinal) {
+        return {
+            iniInitial,
+            iniFinal,
+            valInitial: iniInitial,
+            valFinal: iniFinal
+        };
+    }
+    static makeFilterRangeDate(iniInitial, iniFinal) {
+        return {
+            iniInitial,
+            iniFinal,
+            valInitial: iniInitial,
+            valFinal: iniFinal
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/generic-functions.utils.mjs

@@ -0,0 +1,170 @@
+/*
+Versão: 1.003
+Data Criação: 18/04/2019
+*/
+export class GenericFunctionsUtils {
+    constructor(literals) {
+        this.literals = {};
+        this.literals = literals;
+    }
+    /* Transforma uma Lista separada por "," em um Array */
+    static listToArrayCharacter(list) {
+        let returnArray = new Array();
+        if (list && list !== '') {
+            returnArray = list.split(',');
+        }
+        return returnArray;
+    }
+    /* Transforma um Array em uma Lista separada por ","  */
+    static ArrayToListCharacter(array) {
+        let list = '';
+        if (array && array.length > 0) {
+            list = array.join(',');
+        }
+        return list;
+    }
+    static isEmpty(object) {
+        let isEmpty = true;
+        for (const content in object) {
+            if (object.hasOwnProperty(content)) {
+                isEmpty = false;
+            }
+        }
+        return isEmpty;
+    }
+    static getChartValues(chartData) {
+        let chartValues;
+        let maxValue, minValue;
+        maxValue = undefined;
+        minValue = undefined;
+        chartData.map(item => {
+            if (maxValue === undefined && minValue === undefined) {
+                maxValue = item.data[0];
+                minValue = item.data[0];
+            }
+            else {
+                if (item.data < minValue) {
+                    minValue = item.data[0];
+                }
+                if (item.data > maxValue) {
+                    maxValue = item.data[0];
+                }
+            }
+        });
+        if (maxValue > 0 && minValue > 0) {
+            chartValues = { maxValue: maxValue, minValue: 0 };
+        }
+        if (maxValue > 0 && minValue < 0) {
+            chartValues = { maxValue: maxValue, minValue: minValue };
+        }
+        if (maxValue < 0 && minValue < 0) {
+            const max = (minValue / 3) * (-1);
+            chartValues = { maxValue: max, minValue: minValue };
+        }
+        if (maxValue > 0 && minValue === 0) {
+            chartValues = { maxValue: maxValue, minValue: 0 };
+        }
+        if (maxValue === 0 && minValue < 0) {
+            const max = (minValue / 3) * (-1);
+            chartValues = { maxValue: max, minValue: minValue };
+        }
+        if (maxValue === 0 && minValue === 0) {
+            chartValues = { maxValue: undefined, minValue: undefined };
+        }
+        chartValues.maxValue = Math.round(chartValues.maxValue);
+        chartValues.minValue = Math.round(chartValues.minValue);
+        return chartValues;
+    }
+    /*Deixa no list apenas o itens que existem no options*/
+    static atzMultiSelectListByOptions(options, list) {
+        let idx;
+        let newList;
+        if (!list) {
+            return list;
+        }
+        newList = new Array();
+        list.map(item => {
+            if (item) {
+                idx = options.findIndex(itemOptions => itemOptions.value === item);
+                if (idx >= 0) {
+                    newList.push(item);
+                }
+            }
+        });
+        return newList;
+    }
+    /*Carrega o Options com os valores defaults passados como parâmetro (list)*/
+    loadOptionsMultiSelect(options, list) {
+        let idx;
+        if (!list) {
+            return;
+        }
+        list.map(item => {
+            if (item) {
+                idx = options.findIndex(itemOptions => itemOptions.value === item);
+                if (idx === -1) {
+                    options.push({ label: item === 'all' ? this.literals['all'] : item, value: item });
+                }
+            }
+        });
+    }
+    /*Carrega o Options com os valores defaults passados como parâmetro (list)*/
+    loadOptionsSelect(options, selectValue, tradValue = false) {
+        let idx;
+        if (!selectValue) {
+            return;
+        }
+        if (selectValue) {
+            idx = options.findIndex(itemOptions => itemOptions.value === selectValue);
+            if (idx === -1) {
+                options.push({ label: tradValue ? this.literals[selectValue] : selectValue, value: selectValue });
+            }
+        }
+    }
+    /*Método que compara 2 objetos e retorna se são iguais ou diferentes*/
+    compareObjects(firstObject, secondObject) {
+        if (!firstObject || !secondObject) {
+            return false;
+        }
+        /*Pega a lista de nomes dos campos do objetos e compara*/
+        if (Object.getOwnPropertyNames(firstObject).length !== Object.getOwnPropertyNames(secondObject).length) {
+            return false;
+        }
+        for (const content in firstObject) {
+            if (content.substr(0, 1) === '$' || content.substr(0, 1) === '_') {
+                continue;
+            }
+            if (firstObject[content] !== secondObject[content]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    referenceGeneration(charInd, dateRef) {
+        let reference;
+        let random;
+        const iDay = dateRef.getDate();
+        const iMonth = dateRef.getMonth() + 1;
+        const iYear = dateRef.getFullYear();
+        reference = `${this.pad(iYear)}${this.pad(iMonth)}${this.pad(iDay)}${charInd}`;
+        random = btoa(`${(new Date()).getTime()}`);
+        random = random.replace(/[=]/g, '');
+        random = random.slice(random.length - 3, random.length);
+        return `${reference}${random}`;
+    }
+    pad(number) {
+        if (number < 10) {
+            return '0' + number;
+        }
+        if (number > 99) {
+            return (number + '').slice(2, 4);
+        }
+        return number;
+    }
+    focusInternalInput(idField) {
+        const fieldComponent = document.getElementById(idField);
+        const fieldInput = fieldComponent.getElementsByClassName('po-input')[0];
+        fieldInput.focus();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generic-functions.utils.js","sourceRoot":"","sources":["../../../../../projects/dts-backoffice-util/src/lib/utils/generic-functions.utils.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\nVersão: 1.003\r\nData Criação: 18/04/2019\r\n*/\r\n\r\nimport { PoMultiselectOption, PoSelectOption } from '@po-ui/ng-components';\r\n\r\nexport interface ChartSeries {\r\n      name?: string;\r\n      data?: Array<number>;\r\n}\r\nexport interface ChartValues {\r\n    minValue: number;\r\n    maxValue: number;\r\n}\r\n\r\nexport class GenericFunctionsUtils {\r\n\r\n    literals: any = {};\r\n\r\n    constructor(\r\n        literals: Object\r\n    ) {\r\n        this.literals = literals;\r\n    }\r\n\r\n    /* Transforma uma Lista separada por \",\" em um Array */\r\n    static listToArrayCharacter(list: string): Array<string> {\r\n        let returnArray = new Array<string>();\r\n\r\n        if (list && list !== '') {\r\n            returnArray = list.split(',');\r\n        }\r\n\r\n        return returnArray;\r\n    }\r\n\r\n    /* Transforma um Array em uma Lista separada por \",\"  */\r\n    static ArrayToListCharacter(array: Array<string>): string {\r\n        let list = '';\r\n\r\n        if (array && array.length > 0) {\r\n            list = array.join(',');\r\n        }\r\n\r\n        return list;\r\n    }\r\n\r\n    static isEmpty(object: object): boolean {\r\n        let isEmpty = true;\r\n\r\n        for (const content in object) {\r\n            if (object.hasOwnProperty(content)) {\r\n                isEmpty = false;\r\n            }\r\n        }\r\n\r\n        return isEmpty;\r\n    }\r\n\r\n    static getChartValues(chartData: Array<ChartSeries>): ChartValues {\r\n\r\n        let chartValues: ChartValues;\r\n\r\n        let maxValue,\r\n            minValue;\r\n\r\n        maxValue = undefined;\r\n        minValue = undefined;\r\n\r\n        chartData.map(item => {\r\n            if (maxValue === undefined && minValue === undefined) {\r\n                maxValue = item.data[0];\r\n                minValue = item.data[0];\r\n            } else {\r\n                if (item.data < minValue) {\r\n                    minValue = item.data[0];\r\n                }\r\n                if (item.data > maxValue) {\r\n                    maxValue = item.data[0];\r\n                }\r\n            }\r\n        });\r\n\r\n        if (maxValue > 0 && minValue > 0) {\r\n            chartValues = { maxValue: maxValue, minValue: 0 };\r\n        }\r\n\r\n        if (maxValue > 0 && minValue < 0) {\r\n            chartValues = { maxValue: maxValue, minValue: minValue };\r\n        }\r\n\r\n        if (maxValue < 0 && minValue < 0) {\r\n            const max = (minValue / 3) * (- 1);\r\n            chartValues = { maxValue: max, minValue: minValue };\r\n        }\r\n\r\n        if (maxValue > 0 && minValue === 0) {\r\n            chartValues = { maxValue: maxValue, minValue: 0 };\r\n        }\r\n\r\n        if (maxValue === 0 && minValue < 0) {\r\n            const max = (minValue / 3) * (- 1);\r\n            chartValues = { maxValue: max, minValue: minValue };\r\n        }\r\n\r\n        if (maxValue === 0 && minValue === 0) {\r\n            chartValues = { maxValue: undefined, minValue: undefined };\r\n        }\r\n\r\n        chartValues.maxValue = Math.round(chartValues.maxValue);\r\n        chartValues.minValue = Math.round(chartValues.minValue);\r\n\r\n        return chartValues;\r\n    }\r\n\r\n    /*Deixa no list apenas o itens que existem no options*/\r\n    static atzMultiSelectListByOptions(options: Array<PoMultiselectOption>, list: Array<string>): Array<string> {\r\n        let idx: number;\r\n        let newList: Array<string>;\r\n\r\n        if (!list) {\r\n            return list;\r\n        }\r\n\r\n        newList = new Array<string>();\r\n\r\n        list.map(item => {\r\n            if (item) {\r\n                idx = options.findIndex(itemOptions => itemOptions.value === item);\r\n                if (idx >= 0) {\r\n                    newList.push(item);\r\n                }\r\n            }\r\n        });\r\n\r\n        return newList;\r\n    }\r\n\r\n    /*Carrega o Options com os valores defaults passados como parâmetro (list)*/\r\n    public loadOptionsMultiSelect(options: Array<PoMultiselectOption>, list: Array<string>): void {\r\n        let idx: number;\r\n\r\n        if (!list) {\r\n            return;\r\n        }\r\n\r\n        list.map(item => {\r\n            if (item) {\r\n                idx = options.findIndex(itemOptions => itemOptions.value === item);\r\n                if (idx === -1) {\r\n                    options.push({ label: item === 'all' ? this.literals['all'] : item, value: item });\r\n                }\r\n            }\r\n        });\r\n    }\r\n\r\n    /*Carrega o Options com os valores defaults passados como parâmetro (list)*/\r\n    public loadOptionsSelect(options: Array<PoSelectOption>, selectValue: string, tradValue = false): void {\r\n        let idx: number;\r\n\r\n        if (!selectValue) {\r\n            return;\r\n        }\r\n\r\n        if (selectValue) {\r\n            idx = options.findIndex(itemOptions => itemOptions.value === selectValue);\r\n            if (idx === -1) {\r\n                options.push({ label: tradValue ? this.literals[selectValue] : selectValue, value: selectValue });\r\n            }\r\n        }\r\n    }\r\n\r\n    /*Método que compara 2 objetos e retorna se são iguais ou diferentes*/\r\n    public compareObjects(firstObject: Object, secondObject: Object): boolean {\r\n\r\n        if (!firstObject || !secondObject) {\r\n            return false;\r\n        }\r\n\r\n        /*Pega a lista de nomes dos campos do objetos e compara*/\r\n        if (Object.getOwnPropertyNames(firstObject).length !== Object.getOwnPropertyNames(secondObject).length) {\r\n            return false;\r\n        }\r\n\r\n        for (const content in firstObject) {\r\n            if (content.substr(0, 1) === '$' || content.substr(0, 1) === '_') {\r\n                continue;\r\n            }\r\n\r\n            if (firstObject[content] !== secondObject[content]) {\r\n                return false;\r\n            }\r\n\r\n        }\r\n\r\n        return true;\r\n    }\r\n\r\n    public referenceGeneration(charInd: string, dateRef: Date): string {\r\n        let reference: string;\r\n        let random: string;\r\n\r\n        const iDay = dateRef.getDate();\r\n        const iMonth = dateRef.getMonth() + 1;\r\n        const iYear = dateRef.getFullYear();\r\n\r\n        reference = `${this.pad(iYear)}${this.pad(iMonth)}${this.pad(iDay)}${charInd}`;\r\n\r\n        random = btoa(`${(new Date()).getTime()}`);\r\n        random = random.replace(/[=]/g, '');\r\n        random = random.slice(random.length - 3, random.length);\r\n\r\n        return `${reference}${random}`;\r\n    }\r\n\r\n    public pad(number): string {\r\n        if (number < 10) {\r\n            return '0' + number;\r\n        }\r\n        if (number > 99) {\r\n            return (number + '').slice(2, 4);\r\n        }\r\n        return number;\r\n    }\r\n\r\n    public focusInternalInput(idField: string) {\r\n        const fieldComponent = document.getElementById(idField);\r\n        const fieldInput = (<HTMLScriptElement[]><any>fieldComponent.getElementsByClassName('po-input'))[0];\r\n        fieldInput.focus();\r\n    }\r\n}\r\n"]}

package/esm2020/public-api.mjs

@@ -0,0 +1,34 @@
+/*
+ * Public API Surface of dts-backoffice-util
+ */
+// Services
+export * from './lib/services/session-info.service';
+export * from './lib/services/profile.service';
+export * from './lib/services/report.service';
+export * from './lib/services/breadcrumb-control.service';
+export * from './lib/services/menu-datasul.service';
+export * from './lib/services/cache-params.service';
+export * from './lib/services/translate.service';
+// Services
+// Utils
+export * from './lib/utils/date.util';
+export * from './lib/utils/disclaimer.util';
+export * from './lib/utils/field-validation.util';
+export * from './lib/utils/filter-range.util';
+export * from './lib/utils/generic-functions.utils';
+export * from './lib/utils/file.util';
+// Utils
+// Interfaces
+export * from './lib/interfaces/totvs-response.interface';
+export * from './lib/interfaces/filter-range.interface';
+// Interfaces
+// Schedule Execution
+export * from './lib/components/totvs-schedule-execution/totvs-schedule-execution.component';
+export * from './lib/components/totvs-schedule-execution/totvs-schedule-execution.model';
+export * from './lib/components/totvs-schedule-execution/totvs-schedule-execution.service';
+export * from './lib/dts-backoffice-util.module';
+// Schedule Execution
+// Pipes
+export * from './lib/pipes/dts-date-format.pipe';
+// Pipes
+//# sourceMappingURL=data:application/json;base64,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