@senior-gestao-pessoas/payroll-core 8.7.0 → 9.0.0

package/esm2015/components/utils/cpf-validator.js

@@ -0,0 +1,45 @@
+/**
+ * Created by Bruno.Curioletti on 30/05/2017.
+ */
+export class CPFValidator {
+    calcChecker1(firstNineDigits) {
+        let sum = null;
+        for (let j = 0; j < 9; ++j) {
+            sum += firstNineDigits.toString().charAt(j) * (10 - j);
+        }
+        const lastSumChecker1 = sum % 11;
+        const checker1 = lastSumChecker1 < 2 ? 0 : 11 - lastSumChecker1;
+        return checker1;
+    }
+    calcChecker2(cpfWithChecker1) {
+        let sum = null;
+        for (let k = 0; k < 10; ++k) {
+            sum += cpfWithChecker1.toString().charAt(k) * (11 - k);
+        }
+        const lastSumChecker2 = sum % 11;
+        const checker2 = lastSumChecker2 < 2 ? 0 : 11 - lastSumChecker2;
+        return checker2;
+    }
+    checkCPF(value) {
+        const cleanCPF = value.replace(/\.|\-|\s/g, ''), firstNineDigits = cleanCPF.substring(0, 9), checker = cleanCPF.substring(9, 11);
+        if (cleanCPF.length !== 11) {
+            return false;
+        }
+        // Checking if all digits are equal
+        for (let i = 0; i < 10; i++) {
+            if ('' + firstNineDigits + checker === Array(12).join(i.toString())) {
+                return false;
+            }
+        }
+        const checker1 = this.calcChecker1(firstNineDigits);
+        const checker2 = this.calcChecker2(firstNineDigits + '' + checker1);
+        if (checker.toString() === checker1.toString() + checker2.toString()) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+}
+export const cpfValidator = new CPFValidator();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/utils/date-validator/date-validators.js

@@ -0,0 +1,144 @@
+import * as _moment from "moment";
+import { CompareType } from "../../../core/enums";
+import { removeCharacteresSpecials } from "../helpers";
+const moment = _moment;
+const dateStartG5 = moment('31/12/1900', 'DD/MM/YYYY');
+const dateEndG5 = moment('04/06/2080', 'DD/MM/YYYY');
+export class DateValidator {
+    constructor() { }
+    /**
+     * Validador que verifica se a data está no formato correto.
+     * @param dateFormat Formato da data
+     * @param options Opções para validar a data
+     * @returns Objeto no formato { invalidDate: true } indicando que a data não é válida
+     */
+    static isValidDate(dateFormat, options) {
+        const validator = (control) => {
+            const useG5DateRange = options && options.hasOwnProperty('useG5DateRange') ? options.useG5DateRange : true;
+            const value = removeCharacteresSpecials(control.value);
+            dateFormat = removeCharacteresSpecials(dateFormat);
+            if (value && dateFormat && value.length === dateFormat.length && !control.value.includes('_')) {
+                const dateValue = moment(value, dateFormat);
+                const valid = dateValue.isValid();
+                const isValidRange = useG5DateRange ? dateValue.isBetween(dateStartG5, dateEndG5, null, '[]') : true;
+                return valid && isValidRange ? null : { invalidDate: true };
+            }
+            return null;
+        };
+        return validator;
+    }
+    /**
+     * Validador que verifica se data inserida no formulário é inferior à data informada.
+     * @param compareToDate Data a ser comparada.
+     * @param dateFormat Informações do local
+     * @param granularity Granularidade da comparação. Ex.: 'day', 'mounth', 'year'.
+     * @returns Objeto no formato { lowerDate: true } indicando que a data é menor
+     */
+    static isDateLower(compareToDate, dateFormat, granularity = 'day') {
+        const options = { compareName: "lowerDate", granularity: granularity };
+        const validator = this.isValidDateCompare(compareToDate, dateFormat, CompareType.isBefore, options);
+        return validator;
+    }
+    /**
+     * Validador genérico usando comparação entre datas
+     * @param compareToDate Data a ser comparada
+     * @param dateFormat Informações do local
+     * @param compareType Tipo de comparação
+     * @param options Opções para a comparação
+     * @returns Objeto no formato { nomeChave: true } indicando que a data não é válida
+     */
+    static isValidDateCompare(compareToDate, dateFormat, compareType, options) {
+        const validator = (control) => {
+            const value = removeCharacteresSpecials(control.value);
+            dateFormat = removeCharacteresSpecials(dateFormat);
+            if (value && dateFormat && value.length === dateFormat.length && !control.value.includes('_')) {
+                const referenceDate = moment(value, dateFormat);
+                const compareTo = moment(compareToDate, dateFormat);
+                return this.dateCompare(referenceDate, compareTo, compareType, options);
+            }
+            return null;
+        };
+        return validator;
+    }
+    /**
+     * Retorna o formato da data de acordo com o local
+     * @param calendar Informações de calendário
+     * @param removeDayPart Remove os dias do formato da data (Opcional)
+     * @returns Exemplo de retornos 'DDMMYYYY', 'MMYYYY', ou seja, retorna o formato somente com letras
+    */
+    static getDateFormatFromLocale(calendar, removeDayPart) {
+        const dateFormat = calendar && calendar.dateFormat;
+        if (dateFormat) {
+            let result = dateFormat.replace(/[y]/g, "YY").replace(/[^a-zA-Z]/g, "").toUpperCase();
+            if (removeDayPart) {
+                result = result.replace("DD", "");
+            }
+            return result;
+        }
+        return null;
+    }
+    /**
+     * Retorna o formato da data/hora de acordo com o local
+     * @param calendar Informações de calendário
+     * @returns Exemplo de retornos 'DD/MM/YYYY HH:mm:ss'
+     */
+    static getDateTimeFormatFromLocale(calendar) {
+        if (calendar) {
+            let dateFormat = calendar.dateFormat.toString();
+            dateFormat = dateFormat.replace(/[y]/g, "YY").toUpperCase();
+            dateFormat = dateFormat + " HH:mm:ss";
+            return dateFormat;
+        }
+        return null;
+    }
+    /**
+     * Retorna o formato da data de acordo com o local
+     * @param calendar Informações de calendário
+     * @returns Exemplo de retornos 'DD/MM/YYYY'
+     */
+    static getDateFormatFromCalendar(calendar) {
+        if (calendar && calendar.dateFormat) {
+            let dateFormat = calendar.dateFormat.toString();
+            dateFormat = dateFormat.replace(/[y]/g, "YY").toUpperCase();
+            return dateFormat;
+        }
+        return null;
+    }
+    /**
+     * Método auxiliar que realiza a comparação entre as datas e retorna um objeto caso a validação seja válida
+     * @param referenceDate Data de referência para a comparação
+     * @param compareToDate Data a ser comparada.
+     * @param compareType Tipo de comparação.
+     * @param options Opções para a comparação
+     * @returns Objeto no formato { nomeChave: true } indicando que a data não é válida
+     */
+    static dateCompare(referenceDate, compareToDate, compareType, options) {
+        const compareTypeName = compareType === CompareType.isNotSame ? CompareType.isSame : compareType;
+        const granularity = options && options.granularity ? options.granularity : "day";
+        let comparison = referenceDate[compareTypeName](compareToDate, granularity);
+        comparison = compareType === CompareType.isNotSame ? !comparison : comparison;
+        if (comparison) {
+            const keyName = options && options.compareName ? options.compareName : compareType;
+            const result = {};
+            result[keyName] = true;
+            return result;
+        }
+        return null;
+    }
+    /**
+     * Retorna uma mascara com as barras Ex: ‘DD/MM/YYYY‘
+     * @param calendar
+     */
+    static getFormatDateWithBar(calendar) {
+        if (calendar && calendar.dateFormat) {
+            let dateFormat = calendar.dateFormat.toString();
+            dateFormat = dateFormat
+                .replace("dd", "DD")
+                .replace("mm", "MM")
+                .replace("yy", "YYYY");
+            return dateFormat;
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-validators.js","sourceRoot":"ng://@senior-gestao-pessoas/payroll-core/","sources":["components/utils/date-validator/date-validators.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractControl, Validators, ValidatorFn, ValidationErrors } from \"@angular/forms\";\nimport { CalendarLocaleOptions } from \"@seniorsistemas/angular-components\";\nimport * as _moment from \"moment\";\nimport { unitOfTime } from \"moment\";\nimport { CompareType } from \"../../../core/enums\";\nimport { DateValidateOptions, DateCompareOptions } from \"../../../core/interfaces\";\nimport { removeCharacteresSpecials } from \"../helpers\";\n\nconst moment = _moment;\nconst dateStartG5 = moment('31/12/1900', 'DD/MM/YYYY');\nconst dateEndG5 = moment('04/06/2080', 'DD/MM/YYYY');\n\nexport class DateValidator {\n    constructor() { }\n\n    /**\n     * Validador que verifica se a data está no formato correto.\n     * @param dateFormat Formato da data\n     * @param options Opções para validar a data\n     * @returns Objeto no formato { invalidDate: true } indicando que a data não é válida\n     */\n    static isValidDate(dateFormat: string, options?: DateValidateOptions): ValidatorFn {\n        const validator: ValidatorFn = (control: AbstractControl): Validators => {\n            const useG5DateRange = options && options.hasOwnProperty('useG5DateRange') ? options.useG5DateRange : true;\n            const value = removeCharacteresSpecials(control.value);\n            dateFormat = removeCharacteresSpecials(dateFormat);\n            if (value && dateFormat && value.length === dateFormat.length && !control.value.includes('_')) {\n                const dateValue = moment(value, dateFormat);\n                const valid = dateValue.isValid();\n                const isValidRange = useG5DateRange ? dateValue.isBetween(dateStartG5, dateEndG5, null, '[]') : true;\n                return valid && isValidRange ? null : { invalidDate: true };\n            }\n            return null;\n        };\n        return validator;\n    }\n    /**\n     * Validador que verifica se data inserida no formulário é inferior à data informada.\n     * @param compareToDate Data a ser comparada.\n     * @param dateFormat Informações do local\n     * @param granularity Granularidade da comparação. Ex.: 'day', 'mounth', 'year'.\n     * @returns Objeto no formato { lowerDate: true } indicando que a data é menor\n     */\n    static isDateLower(compareToDate: string, dateFormat: string, granularity: unitOfTime.StartOf = 'day'): ValidatorFn {\n        const options: DateCompareOptions = { compareName: \"lowerDate\", granularity: granularity };\n        const validator = this.isValidDateCompare(compareToDate, dateFormat, CompareType.isBefore, options);\n        return validator;\n    }\n\n    /**\n     * Validador genérico usando comparação entre datas\n     * @param compareToDate Data a ser comparada\n     * @param dateFormat Informações do local\n     * @param compareType Tipo de comparação\n     * @param options Opções para a comparação\n     * @returns Objeto no formato { nomeChave: true } indicando que a data não é válida\n     */\n    static isValidDateCompare(compareToDate: string, dateFormat: string, compareType: CompareType, options?: DateCompareOptions):\n        ValidatorFn {\n        const validator: ValidatorFn = (control: AbstractControl): Validators => {\n            const value = removeCharacteresSpecials(control.value);\n            dateFormat = removeCharacteresSpecials(dateFormat);\n            if (value && dateFormat && value.length === dateFormat.length && !control.value.includes('_')) {\n                const referenceDate = moment(value, dateFormat);\n                const compareTo = moment(compareToDate, dateFormat);\n                return this.dateCompare(referenceDate, compareTo, compareType, options);\n            }\n            return null;\n        };\n        return validator;\n    }\n\n    /**\n     * Retorna o formato da data de acordo com o local\n     * @param calendar Informações de calendário\n     * @param removeDayPart Remove os dias do formato da data (Opcional)\n     * @returns Exemplo de retornos 'DDMMYYYY', 'MMYYYY', ou seja, retorna o formato somente com letras\n    */\n    static getDateFormatFromLocale(calendar: CalendarLocaleOptions, removeDayPart?: boolean): string {\n        const dateFormat = calendar && calendar.dateFormat;\n        if (dateFormat) {\n            let result = dateFormat.replace(/[y]/g, \"YY\").replace(/[^a-zA-Z]/g, \"\").toUpperCase();\n            if (removeDayPart) {\n                result = result.replace(\"DD\", \"\");\n            }\n            return result;\n        }\n        return null;\n    }\n\n    /**\n     * Retorna o formato da data/hora de acordo com o local\n     * @param calendar Informações de calendário\n     * @returns Exemplo de retornos 'DD/MM/YYYY HH:mm:ss'\n     */\n    static getDateTimeFormatFromLocale(calendar: CalendarLocaleOptions): string {\n        if (calendar) {\n            let dateFormat = calendar.dateFormat.toString();\n            dateFormat = dateFormat.replace(/[y]/g, \"YY\").toUpperCase();\n            dateFormat = dateFormat + \" HH:mm:ss\";\n\n            return dateFormat;\n        }\n        return null;\n    }\n\n    /**\n     * Retorna o formato da data de acordo com o local\n     * @param calendar Informações de calendário\n     * @returns Exemplo de retornos 'DD/MM/YYYY'\n     */\n    static getDateFormatFromCalendar(calendar: CalendarLocaleOptions): string {\n        if (calendar && calendar.dateFormat) {\n            let dateFormat = calendar.dateFormat.toString();\n            dateFormat = dateFormat.replace(/[y]/g, \"YY\").toUpperCase();\n\n            return dateFormat;\n        }\n        return null;\n    }\n\n    /**\n     * Método auxiliar que realiza a comparação entre as datas e retorna um objeto caso a validação seja válida\n     * @param referenceDate Data de referência para a comparação\n     * @param compareToDate Data a ser comparada.\n     * @param compareType Tipo de comparação.\n     * @param options Opções para a comparação\n     * @returns Objeto no formato { nomeChave: true } indicando que a data não é válida\n     */\n    private static dateCompare(referenceDate: any, compareToDate: any, compareType: CompareType, options?: DateCompareOptions):\n        ValidationErrors {\n        const compareTypeName: string = compareType === CompareType.isNotSame ? CompareType.isSame : compareType;\n        const granularity = options && options.granularity ? options.granularity : \"day\";\n\n        let comparison = referenceDate[compareTypeName](compareToDate, granularity);\n        comparison = compareType === CompareType.isNotSame ? !comparison : comparison;\n        if (comparison) {\n            const keyName = options && options.compareName ? options.compareName : compareType;\n            const result = {};\n            result[keyName] = true;\n            return result;\n        }\n        return null;\n    }\n\n    /**\n     * Retorna uma mascara com as barras Ex: ‘DD/MM/YYYY‘\n     * @param calendar\n     */\n    static getFormatDateWithBar(calendar: CalendarLocaleOptions): string {\n        if (calendar && calendar.dateFormat) {\n            let dateFormat = calendar.dateFormat.toString();\n            dateFormat = dateFormat\n                .replace(\"dd\", \"DD\")\n                .replace(\"mm\", \"MM\")\n                .replace(\"yy\", \"YYYY\");\n            return dateFormat;\n        }\n        return null;\n    }\n\n}\n"]}