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

package/esm2015/components/utils/helpers.js

@@ -0,0 +1,476 @@
+import { FormArray, FormControl, FormGroup, Validators } from '@angular/forms';
+import * as chance from 'chance';
+import * as momentImported from 'moment';
+import business from 'moment-business';
+const moment = momentImported;
+export function isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+}
+export function isShallow(item) {
+    return Array.isArray(item) && item.find(value => typeof value === 'object') ? false : true;
+}
+export function convertBooleanString(value) {
+    if (typeof value === 'boolean') {
+        return value === true ? 'true' : 'false';
+    }
+    return value;
+}
+export function convertStringToBoolean(value) {
+    return value === true || value.toLowerCase() === 'true';
+}
+export function assign(target, ...sources) {
+    if (!sources.length) {
+        return target;
+    }
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key]) {
+                    Object.assign(target, { [key]: {} });
+                }
+                assign(target[key], source[key]);
+            }
+            else {
+                if (isShallow(source[key])) {
+                    Object.assign(target, { [key]: source[key] });
+                }
+                else {
+                    if (!target[key]) {
+                        Object.assign(target, { [key]: [] });
+                    }
+                    Object.assign(target, { [key]: source[key].map((item, index) => assign(target[key][index] || {}, item)) });
+                }
+            }
+        }
+    }
+    return assign(target, ...sources);
+}
+export function isValid(value) {
+    return value === 0 || typeof value === 'boolean' ? true : value !== undefined && value !== null && value !== '';
+}
+export function isValidDate(value, withDays = true) {
+    if (value && isFullDate(value, withDays)) {
+        if (withDays) {
+            return moment(value.replace(/[^\d]+/g, ''), 'DDMMYYYY').isValid();
+        }
+        else {
+            return moment(value.replace(/[^\d]+/g, ''), 'MMYYYY').isValid();
+        }
+    }
+    return true;
+}
+export function isFullDate(value, withDays = true) {
+    if (value) {
+        let totalLength;
+        if (withDays) {
+            totalLength = 8;
+        }
+        else {
+            totalLength = 6;
+        }
+        return value.replace(/[^\d]+/g, '').length === totalLength;
+    }
+    return true;
+}
+export function autoCompleteObjectForIdObject(tableIdObject) {
+    if (!isObject(tableIdObject)) {
+        console.error('Paramentro não é um objeto');
+        return false;
+    }
+    if (tableIdObject.hasOwnProperty('tableId')) {
+        console.error('Paramentro não é um objeto Auto Complete válido, falta tableId');
+    }
+    if (!isValid(tableIdObject.tableId)) {
+        console.error('tableId esta vazio');
+    }
+    return { id: tableIdObject.tableId };
+}
+export function isDateField(name, value) {
+    const testDate = name.search('Date');
+    if (testDate !== -1) {
+        return invertFieldDate(value);
+    }
+    return value;
+}
+export function invertFieldDate(value, inFormat = 'DDMMYYYY', outFormat = 'YYYY-MM-DD') {
+    if (!isValid(value)) {
+        return;
+    }
+    const formatIn = getFormatDate(value, inFormat);
+    return moment(value.replace(/[^\d]+/g, ''), formatIn).format(outFormat);
+}
+export function getAddWeekDaysBusiness(value, quantidade) {
+    return business.addWeekDays(getMoment(value), quantidade).format('DD/MM/YYYY');
+}
+export function getWeekDaysBusiness(startDate, endDate) {
+    const endMoment = endDate ? getMoment(endDate) : getMoment(startDate).endOf('month');
+    return business.weekDays(getMoment(startDate), endMoment);
+}
+export function getFormatDate(value, inFormat) {
+    if (value.search('/') !== -1) {
+        return 'DDMMYYYY';
+    }
+    else if (value.search('-') !== -1) {
+        return 'YYYYMMDD';
+    }
+    return inFormat;
+}
+/**
+ * FIXME - Está fixo para uso do calendário portugues Brasil
+ * @param value
+ * @param outFormat
+ * @returns
+ */
+export function ngCalendarFormat(value, outFormat = 'DD/MM/YYYY') {
+    if (isValidDate(value)) {
+        if (typeof value === 'string') {
+            return value;
+        }
+        else {
+            return _moment(value).format(outFormat);
+        }
+    }
+}
+export function getNowDate(outFormat = 'YYYY-MM-DD') {
+    return moment().format(outFormat);
+}
+export function getMoment(value, inFormat = 'DDMMYYYY') {
+    const formatIn = getFormatDate(value, inFormat);
+    return moment(value.replace(/[^\d]+/g, ''), formatIn);
+}
+export function _moment(value, format) {
+    if (format) {
+        return moment(value, format);
+    }
+    return moment(value);
+}
+export function getObjValids(objs) {
+    const json = Object.assign({}, objs);
+    const jsonReturn = {};
+    Object.keys(json).map(key => {
+        if (isValid(json[key])) {
+            jsonReturn[key] = isDateField(key, json[key]);
+        }
+    });
+    return jsonReturn;
+}
+export function removeEmpty(obj) {
+    Object.keys(obj).forEach(k => (obj[k] && typeof obj[k] === 'object' && removeEmpty(obj[k])) || (!obj[k] && obj[k] !== undefined && delete obj[k]));
+    return obj;
+}
+export function formatMoney(value, i18n = 'EN') {
+    switch (i18n) {
+        case 'EN':
+            return isValid(value)
+                ? value
+                    .toString()
+                    .replace('.', '')
+                    .replace(',', '.')
+                : '';
+        case 'BR':
+            return isValid(value)
+                ? value
+                    .toString()
+                    .replace('.', ',')
+                    .replace(/(\d)(?=(\d{3})+(?!\d))/g, '$1.')
+                : '';
+        default:
+            return isValid(value)
+                ? value
+                    .toString()
+                    .replace('.', '')
+                    .replace(',', '.')
+                : '';
+    }
+}
+export function uiid() {
+    return new chance()
+        .guid()
+        .replace(/[^a-zA-Z0-9.]/g, '')
+        .toUpperCase();
+}
+export function mountCustomForSave(custom, customEntity = null, locale = null) {
+    const custonField = [];
+    if (customEntity && custom.length) {
+        customEntity.map((val, key) => {
+            const field = Object.keys(custom[key]).toString();
+            const valOrnull = isValid(custom[key][field]) ? custom[key][field] : null;
+            const value = val.type === 'date' && locale && isValid(valOrnull) ? moment(valOrnull, getFormat(locale)).format('YYYY-MM-DD') : valOrnull;
+            custonField.push({
+                field: field,
+                value: value,
+            });
+        });
+    }
+    return custonField.length ? custonField : null;
+}
+/**
+ * Prepara o objeto de campos customizados para salvar as entidades que
+ * são utilizadas a partir do CRUD customizado.
+ * @param objectFields objeto com os campos customizados da entidade.
+ */
+export function mountCustomToSave(objectFields) {
+    const customFields = [];
+    Object.entries(objectFields).forEach(([field, value]) => {
+        customFields.push({
+            field: field,
+            value: value,
+        });
+    });
+    return customFields;
+}
+/**
+ * Prepara o objeto de campos customizados para exibir as entidades que
+ * são utilizadas a partir do CRUD customizado.
+ * @param customFields objeto com os campos customizados da entidade.
+ */
+export function mountCustomToShow(customFields) {
+    const customFieldsToShow = {};
+    if (customFields && customFields.length) {
+        customFields.forEach(item => {
+            if (item.type === 'date' && item.value) {
+                item.value = _moment(item.value).format('L');
+            }
+            customFieldsToShow[item.field] = item.value;
+        });
+    }
+    return customFieldsToShow;
+}
+/**
+ * Prepara o objeto de campos customizados para salvar as entidades que
+ * são utilizadas a partir do CRUD gerado.
+ * @param objectFields objeto com os campos customizados da entidade.
+ */
+export function mountGeneratedCustomToSave(objectFields) {
+    Object.entries(objectFields).forEach(([key, value]) => {
+        if (!value) {
+            delete objectFields[key];
+        }
+    });
+    return objectFields;
+}
+export function mountCustomForShow(custom) {
+    const customField = [];
+    Object.keys(custom || {}).forEach(val => {
+        if (custom[val].type === 'date' && custom[val].value) {
+            custom[val].value = _moment(custom[val].value).format('L');
+        }
+        customField.push(custom[val]);
+    });
+    return customField;
+}
+export function setValueCustom(custonFields, custom) {
+    const isCustons = custom ? Object.keys(custom).length : 0;
+    custonFields.map(val => {
+        val.value = isCustons > 0 ? custom[val.field] : null;
+    });
+    return custonFields;
+}
+/**
+ *  Adiciona um erro no controle do formulário. Deve ser chamado com .call passando o contexto da class.
+ *  Ex.: setErrors.call(this.contractGroup, 'registerEmployeeNumber', 'exist', !payload)
+ *
+ * @param formControlName Nome do controle do formulário.
+ * @param keyError Nome do error a ser exibido em tela.
+ * @param isInvalid Se houver algum erro de validação no campo.
+ */
+export function setErrors(formControlName, keyError, isInvalid) {
+    setTimeout(() => {
+        if (isInvalid) {
+            const errors = Object.assign({}, this.get(formControlName).errors);
+            errors[keyError] = isInvalid;
+            this.get(formControlName).setErrors(errors);
+        }
+        else {
+            const errors = this.get(formControlName).errors;
+            if (errors && Object.keys(errors).length) {
+                delete errors[keyError];
+                if (!Object.keys(errors).length) {
+                    this.get(formControlName).setErrors(null);
+                }
+            }
+        }
+    }, 0);
+}
+/**
+ * Faz loop do nos controls do formulário e subArray caso existir
+ * setando os inválidos
+ * Ex.: verifyValidationsForm.call(this.initialGroup);
+ */
+export function verifyValidationsForm() {
+    Object.keys(this.controls).map(field => {
+        const control = this.get(field);
+        control.markAsDirty();
+        if (control instanceof FormGroup || control instanceof FormArray) {
+            verifyValidationsForm.call(control);
+        }
+    });
+}
+/**
+ * Retorna a idade de acordo com a data de nascimento.
+ *
+ * @param birthdayDate Data de nascimento.
+ */
+export function getYears(birthday) {
+    const currentDate = moment();
+    const years = currentDate.diff(birthday, 'years', false);
+    return years;
+}
+export function setCustonFields(customFields) {
+    customFields.map(val => {
+        const addCuston = {};
+        let value = val.value || null;
+        if (typeof value === 'boolean') {
+            value = value ? 'true' : 'false';
+        }
+        addCuston[val.field] = new FormControl(value);
+        this.push(new FormGroup(addCuston));
+    });
+    return customFields;
+}
+export function setRequired(formGroup, name, required, validators) {
+    if (required) {
+        formGroup.controls[name].setValidators(Validators.compose(validators && validators.length ? validators : [Validators.required]));
+        formGroup.controls[name].updateValueAndValidity();
+    }
+    else {
+        formGroup.controls[name].setValidators(null);
+        formGroup.controls[name].updateValueAndValidity();
+    }
+}
+/**
+ * Esse método tem como função setar os campos enable ou disable.
+ * @param formGroup FormGroup onde se encontra os campos a serem alterados.
+ * @param condition Condição para validação. True = enabled, False = disabled.
+ * @param fields Campos a serem manipulados.
+ * @param fieldsToClear Campos a serem limpos. É opicional e se não foi passado o método limpará os mesmos campos dos fields.
+ */
+export function configEnabledFields(formGroup, condition, fields, fieldsToClear) {
+    if (condition) {
+        fields.forEach(field => formGroup.get(field).enable());
+    }
+    else {
+        fields.forEach(field => formGroup.get(field).disable());
+        clearValues(formGroup, fieldsToClear ? fieldsToClear : fields);
+    }
+}
+/**
+ * Esse método tem como função setar os campos como requeridos ou não.
+ *
+ * @param formGroup FormGroup onde se encontra os campos a serem alterados.
+ * @param condition Se será ou não requeridos.
+ * @param fields Lista de campos.
+ */
+export function setRequiredFields(formGroup, condition, fields) {
+    if (condition) {
+        fields.forEach(field => setRequired(formGroup, field, true, [Validators.required]));
+    }
+    else {
+        fields.forEach(field => setRequired(formGroup, field, false));
+    }
+}
+/**
+ * Esse método tem como função setar validações dinâmicas nos campos.
+ *
+ * @param formGroup FormGroup onde se encontra os campos a serem alterados.
+ * @param fields Lista de objetos [{field: campo, validators: validações, disable: boolean}].
+ */
+export function setValidatorsAndDisableFields(formGroup, fields) {
+    fields.forEach((currentField) => {
+        setValidator(formGroup, currentField.field, currentField.validators);
+        setDisableField(formGroup, currentField.disabled, currentField.field, currentField.clearValue);
+    });
+}
+export function setValidator(formGroup, name, validators) {
+    if (validators && validators.length) {
+        formGroup.controls[name].setValidators(Validators.compose(validators));
+        formGroup.controls[name].updateValueAndValidity();
+    }
+    else {
+        formGroup.controls[name].setValidators(null);
+        formGroup.controls[name].updateValueAndValidity();
+    }
+}
+/**
+ * Esse método tem como função setar os campos enable ou disable.
+ * @param formGroup FormGroup onde se encontra os campos a serem alterados.
+ * @param condition Condição para validação. True = disabled, False = enabled.
+ * @param field Campo a ser manipulados.
+ * @param clearValue Campos a ser limpos. É opicional e se não foi passado o método limpará o campo do field.
+ */
+export function setDisableField(formGroup, condition, field, clearValue = true) {
+    if (condition) {
+        formGroup.get(field).disable();
+        if (clearValue)
+            formGroup.get(field).reset();
+    }
+    else {
+        formGroup.get(field).enable();
+    }
+}
+/**
+ * Ordena array de objetos
+ * @param key o campo que deseja ordenar
+ * @param order a ordem que deseja ordenar o campo
+ */
+export function compareValues(key, order = "ASC") {
+    return function innerSort(a, b) {
+        if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) {
+            return 0;
+        }
+        const varA = (typeof a[key] === "string")
+            ? a[key].toUpperCase() : a[key];
+        const varB = (typeof b[key] === "string")
+            ? b[key].toUpperCase() : b[key];
+        let comparison = 0;
+        if (varA > varB) {
+            comparison = 1;
+        }
+        else if (varA < varB) {
+            comparison = -1;
+        }
+        return ((order === "DESC") ? (comparison * -1) : comparison);
+    };
+}
+/**
+ * Esse método tem como função limpar o valor dos campos.
+ *
+ * @param formGroup FormGroup onde se encontra os campos a serem limpos.
+ * @param fields Campos a serem limpos.
+ */
+export function clearValues(formGroup, fields) {
+    fields.forEach(field => formGroup.get(field).reset());
+}
+/**
+ *
+ * @param qs = window.location.search
+ * @returns Object com parametros query string
+ */
+export function getQueryParams(qs) {
+    qs = qs.split('+').join(' ');
+    const params = {};
+    let tokens;
+    const re = /[?&]?([^=]+)=([^&]*)/g;
+    while ((tokens = re.exec(qs))) {
+        params[decodeURIComponent(tokens[1])] = decodeURIComponent(tokens[2]);
+    }
+    return params;
+}
+export function getFormat(locale) {
+    if (locale) {
+        let dateFormat = locale.calendar.dateFormat.toString();
+        dateFormat = dateFormat.replace(/[y]/g, 'YY');
+        dateFormat = dateFormat.replace(/[/]/g, '');
+        return dateFormat.toUpperCase();
+    }
+}
+/**
+ * Remove os caracteres que não sejam números do valor
+ * @param value valor a ser tratado
+ * @returns string O valor sem caracteres especiais
+ */
+export function removeCharacteresSpecials(value) {
+    return value ? value.toString().replace(/[&\/\\#,+()$~%.'":*?<>{}-]/g, "") : null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"ng://@senior-gestao-pessoas/payroll-core/","sources":["components/utils/helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import { FormArray, FormControl, FormGroup, Validators } from '@angular/forms';\nimport { ValidatorFn } from '@angular/forms/';\nimport * as chance from 'chance';\nimport * as momentImported from 'moment';\nimport business from 'moment-business';\nimport { LocaleOptions } from '@seniorsistemas/angular-components';\nimport { FieldValidatorsObject } from '../../core/interfaces/field-validators-object';\n\nconst moment = momentImported;\n\nexport function isObject(item) {\n  return item && typeof item === 'object' && !Array.isArray(item);\n}\n\nexport function isShallow(item) {\n  return Array.isArray(item) && item.find(value => typeof value === 'object') ? false : true;\n}\n\nexport function convertBooleanString(value) {\n  if (typeof value === 'boolean') {\n    return value === true ? 'true' : 'false';\n  }\n  return value;\n}\n\nexport function convertStringToBoolean(value) {\n  return value === true || value.toLowerCase() === 'true';\n}\n\nexport function assign(target, ...sources) {\n  if (!sources.length) {\n    return target;\n  }\n\n  const source = sources.shift();\n  if (isObject(target) && isObject(source)) {\n    for (const key in source) {\n      if (isObject(source[key])) {\n        if (!target[key]) {\n          Object.assign(target, { [key]: {} });\n        }\n        assign(target[key], source[key]);\n      } else {\n        if (isShallow(source[key])) {\n          Object.assign(target, { [key]: source[key] });\n        } else {\n          if (!target[key]) {\n            Object.assign(target, { [key]: [] });\n          }\n          Object.assign(target, { [key]: source[key].map((item, index) => assign(target[key][index] || {}, item)) });\n        }\n      }\n    }\n  }\n  return assign(target, ...sources);\n}\n\nexport function isValid(value) {\n  return value === 0 || typeof value === 'boolean' ? true : value !== undefined && value !== null && value !== '';\n}\n\nexport function isValidDate(value, withDays = true) {\n  if (value && isFullDate(value, withDays)) {\n    if (withDays) {\n      return moment(value.replace(/[^\\d]+/g, ''), 'DDMMYYYY').isValid();\n    } else {\n      return moment(value.replace(/[^\\d]+/g, ''), 'MMYYYY').isValid();\n    }\n  }\n  return true;\n}\n\nexport function isFullDate(value, withDays = true) {\n  if (value) {\n    let totalLength;\n    if (withDays) {\n      totalLength = 8;\n    } else {\n      totalLength = 6;\n    }\n    return value.replace(/[^\\d]+/g, '').length === totalLength;\n  }\n  return true;\n}\n\nexport function autoCompleteObjectForIdObject(tableIdObject) {\n  if (!isObject(tableIdObject)) {\n    console.error('Paramentro não é um objeto');\n    return false;\n  }\n\n  if (tableIdObject.hasOwnProperty('tableId')) {\n    console.error('Paramentro não é um objeto Auto Complete válido, falta tableId');\n  }\n\n  if (!isValid(tableIdObject.tableId)) {\n    console.error('tableId esta vazio');\n  }\n\n  return { id: tableIdObject.tableId };\n}\n\nexport function isDateField(name, value) {\n  const testDate = name.search('Date');\n  if (testDate !== -1) {\n    return invertFieldDate(value);\n  }\n  return value;\n}\n\nexport function invertFieldDate(value, inFormat = 'DDMMYYYY', outFormat = 'YYYY-MM-DD') {\n  if (!isValid(value)) {\n    return;\n  }\n  const formatIn = getFormatDate(value, inFormat);\n  return moment(value.replace(/[^\\d]+/g, ''), formatIn).format(outFormat);\n}\n\nexport function getAddWeekDaysBusiness(value, quantidade) {\n  return business.addWeekDays(getMoment(value), quantidade).format('DD/MM/YYYY');\n}\n\nexport function getWeekDaysBusiness(startDate, endDate) {\n  const endMoment = endDate ? getMoment(endDate) : getMoment(startDate).endOf('month');\n  return business.weekDays(getMoment(startDate), endMoment);\n}\n\nexport function getFormatDate(value, inFormat) {\n  if (value.search('/') !== -1) {\n    return 'DDMMYYYY';\n  } else if (value.search('-') !== -1) {\n    return 'YYYYMMDD';\n  }\n  return inFormat;\n}\n\n/**\n * FIXME - Está fixo para uso do calendário portugues Brasil\n * @param value\n * @param outFormat\n * @returns\n */\nexport function ngCalendarFormat(value, outFormat = 'DD/MM/YYYY') {\n  if (isValidDate(value)) {\n    if (typeof value === 'string') {\n      return value;\n    } else {\n      return _moment(value).format(outFormat);\n    }\n  }\n}\n\nexport function getNowDate(outFormat = 'YYYY-MM-DD') {\n  return moment().format(outFormat);\n}\n\nexport function getMoment(value, inFormat = 'DDMMYYYY') {\n  const formatIn = getFormatDate(value, inFormat);\n  return moment(value.replace(/[^\\d]+/g, ''), formatIn);\n}\n\nexport function _moment(value, format?: string) {\n  if (format) {\n    return moment(value, format);\n  }\n  return moment(value);\n}\n\nexport function getObjValids(objs) {\n  const json = Object.assign({}, objs);\n  const jsonReturn = {};\n  Object.keys(json).map(key => {\n    if (isValid(json[key])) {\n      jsonReturn[key] = isDateField(key, json[key]);\n    }\n  });\n  return jsonReturn;\n}\n\nexport function removeEmpty(obj) {\n  Object.keys(obj).forEach(\n    k => (obj[k] && typeof obj[k] === 'object' && removeEmpty(obj[k])) || (!obj[k] && obj[k] !== undefined && delete obj[k])\n  );\n  return obj;\n}\n\nexport function formatMoney(value, i18n = 'EN') {\n  switch (i18n) {\n    case 'EN':\n      return isValid(value)\n        ? value\n            .toString()\n            .replace('.', '')\n            .replace(',', '.')\n        : '';\n    case 'BR':\n      return isValid(value)\n        ? value\n            .toString()\n            .replace('.', ',')\n            .replace(/(\\d)(?=(\\d{3})+(?!\\d))/g, '$1.')\n        : '';\n    default:\n      return isValid(value)\n        ? value\n            .toString()\n            .replace('.', '')\n            .replace(',', '.')\n        : '';\n  }\n}\n\nexport function uiid() {\n  return new chance()\n    .guid()\n    .replace(/[^a-zA-Z0-9.]/g, '')\n    .toUpperCase();\n}\n\nexport function mountCustomForSave(custom, customEntity = null, locale = null) {\n  const custonField = [];\n  if (customEntity && custom.length) {\n    customEntity.map((val, key) => {\n      const field = Object.keys(custom[key]).toString();\n      const valOrnull = isValid(custom[key][field]) ? custom[key][field] : null;\n      const value =\n        val.type === 'date' && locale && isValid(valOrnull) ? moment(valOrnull, getFormat(locale)).format('YYYY-MM-DD') : valOrnull;\n      custonField.push({\n        field: field,\n        value: value,\n      });\n    });\n  }\n  return custonField.length ? custonField : null;\n}\n\n/**\n * Prepara o objeto de campos customizados para salvar as entidades que\n * são utilizadas a partir do CRUD customizado.\n * @param objectFields objeto com os campos customizados da entidade.\n */\nexport function mountCustomToSave(objectFields) {\n  const customFields = [];\n  Object.entries(objectFields).forEach(([field, value]) => {\n    customFields.push({\n      field: field,\n      value: value,\n    });\n  });\n  return customFields;\n}\n\n/**\n * Prepara o objeto de campos customizados para exibir as entidades que\n * são utilizadas a partir do CRUD customizado.\n * @param customFields objeto com os campos customizados da entidade.\n */\nexport function mountCustomToShow(customFields) {\n  const customFieldsToShow = {};\n  if (customFields && customFields.length) {\n    customFields.forEach(item => {\n      if (item.type === 'date' && item.value) {\n        item.value = _moment(item.value).format('L');\n      }\n      customFieldsToShow[item.field] = item.value;\n    });\n  }\n  return customFieldsToShow;\n}\n\n/**\n * Prepara o objeto de campos customizados para salvar as entidades que\n * são utilizadas a partir do CRUD gerado.\n * @param objectFields objeto com os campos customizados da entidade.\n */\nexport function mountGeneratedCustomToSave(objectFields) {\n  Object.entries(objectFields).forEach(([key, value]) => {\n    if (!value) {\n      delete objectFields[key];\n    }\n  });\n  return objectFields;\n}\n\nexport function mountCustomForShow(custom) {\n  const customField = [];\n  Object.keys(custom || {}).forEach(val => {\n    if (custom[val].type === 'date' && custom[val].value) {\n      custom[val].value = _moment(custom[val].value).format('L');\n    }\n    customField.push(custom[val]);\n  });\n  return customField;\n}\n\nexport function setValueCustom(custonFields, custom) {\n  const isCustons = custom ? Object.keys(custom).length : 0;\n  custonFields.map(val => {\n    val.value = isCustons > 0 ? custom[val.field] : null;\n  });\n  return custonFields;\n}\n\n/**\n *  Adiciona um erro no controle do formulário. Deve ser chamado com .call passando o contexto da class.\n *  Ex.: setErrors.call(this.contractGroup, 'registerEmployeeNumber', 'exist', !payload)\n *\n * @param formControlName Nome do controle do formulário.\n * @param keyError Nome do error a ser exibido em tela.\n * @param isInvalid Se houver algum erro de validação no campo.\n */\nexport function setErrors(formControlName: string, keyError: string, isInvalid: boolean): void {\n  setTimeout(() => {\n    if (isInvalid) {\n      const errors = Object.assign({}, this.get(formControlName).errors);\n      errors[keyError] = isInvalid;\n      this.get(formControlName).setErrors(errors);\n    } else {\n      const errors = this.get(formControlName).errors;\n\n      if (errors && Object.keys(errors).length) {\n        delete errors[keyError];\n\n        if (!Object.keys(errors).length) {\n          this.get(formControlName).setErrors(null);\n        }\n      }\n    }\n  }, 0);\n}\n\n/**\n * Faz loop do nos controls do formulário e subArray caso existir\n * setando os inválidos\n * Ex.: verifyValidationsForm.call(this.initialGroup);\n */\nexport function verifyValidationsForm() {\n  Object.keys(this.controls).map(field => {\n    const control = this.get(field);\n    control.markAsDirty();\n    if (control instanceof FormGroup || control instanceof FormArray) {\n      verifyValidationsForm.call(control);\n    }\n  });\n}\n\n/**\n * Retorna a idade de acordo com a data de nascimento.\n *\n * @param birthdayDate Data de nascimento.\n */\nexport function getYears(birthday) {\n  const currentDate = moment();\n  const years = currentDate.diff(birthday, 'years', false);\n  return years;\n}\n\nexport function setCustonFields(customFields) {\n  customFields.map(val => {\n    const addCuston = {};\n    let value = val.value || null;\n    if (typeof value === 'boolean') {\n      value = value ? 'true' : 'false';\n    }\n    addCuston[val.field] = new FormControl(value);\n    this.push(new FormGroup(addCuston));\n  });\n  return customFields;\n}\n\n    export function setRequired(formGroup: FormGroup, name: string, required: boolean, validators?: ValidatorFn[]) {\n  if (required) {\n    formGroup.controls[name].setValidators(Validators.compose(validators && validators.length ? validators : [Validators.required]));\n    formGroup.controls[name].updateValueAndValidity();\n  } else {\n    formGroup.controls[name].setValidators(null);\n    formGroup.controls[name].updateValueAndValidity();\n  }\n}\n\n/**\n * Esse método tem como função setar os campos enable ou disable.\n * @param formGroup FormGroup onde se encontra os campos a serem alterados.\n * @param condition Condição para validação. True = enabled, False = disabled.\n * @param fields Campos a serem manipulados.\n * @param fieldsToClear Campos a serem limpos. É opicional e se não foi passado o método limpará os mesmos campos dos fields.\n */\nexport function configEnabledFields(formGroup: FormGroup, condition: boolean, fields: Array<string>, fieldsToClear?: Array<string>) {\n  if (condition) {\n    fields.forEach(field => formGroup.get(field).enable());\n  } else {\n    fields.forEach(field => formGroup.get(field).disable());\n    clearValues(formGroup, fieldsToClear ? fieldsToClear : fields);\n  }\n}\n\n/**\n * Esse método tem como função setar os campos como requeridos ou não.\n *\n * @param formGroup FormGroup onde se encontra os campos a serem alterados.\n * @param condition Se será ou não requeridos.\n * @param fields Lista de campos.\n */\nexport function setRequiredFields(formGroup: FormGroup, condition: boolean, fields: Array<string>) {\n  if (condition) {\n    fields.forEach(field => setRequired(formGroup, field, true, [Validators.required]));\n  } else {\n    fields.forEach(field => setRequired(formGroup, field, false));\n  }\n}\n\n\n/**\n * Esse método tem como função setar validações dinâmicas nos campos.\n *\n * @param formGroup FormGroup onde se encontra os campos a serem alterados.\n * @param fields Lista de objetos [{field: campo, validators: validações, disable: boolean}].\n */\nexport function setValidatorsAndDisableFields(formGroup: FormGroup, fields: Array<FieldValidatorsObject>) {\n    fields.forEach((currentField: FieldValidatorsObject) => {\n        setValidator(formGroup, currentField.field,  currentField.validators);\n        setDisableField(formGroup, currentField.disabled,  currentField.field, currentField.clearValue);\n    });\n}\n\n\nexport function setValidator(formGroup: FormGroup, name: string, validators?: ValidatorFn[]) {\n    if (validators && validators.length) {\n        formGroup.controls[name].setValidators(Validators.compose(validators));\n        formGroup.controls[name].updateValueAndValidity();\n    } else {\n        formGroup.controls[name].setValidators(null);\n        formGroup.controls[name].updateValueAndValidity();\n    }\n}\n\n\n/**\n * Esse método tem como função setar os campos enable ou disable.\n * @param formGroup FormGroup onde se encontra os campos a serem alterados.\n * @param condition Condição para validação. True = disabled, False = enabled.\n * @param field Campo a ser manipulados.\n * @param clearValue Campos a ser limpos. É opicional e se não foi passado o método limpará o campo do field.\n */\nexport function setDisableField(formGroup: FormGroup, condition: boolean, field: string, clearValue: boolean = true) {\n    if (condition) {\n        formGroup.get(field).disable();\n        if (clearValue) formGroup.get(field).reset();\n    } else {\n        formGroup.get(field).enable();\n    }\n}\n\n/**\n * Ordena array de objetos\n * @param key o campo que deseja ordenar\n * @param order a ordem que deseja ordenar o campo\n */\nexport function compareValues(key: string, order: string = \"ASC\") {\n    return function innerSort(a: any, b: any) {\n        if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) {\n            return 0;\n        }\n\n        const varA = (typeof a[key] === \"string\")\n            ? a[key].toUpperCase() : a[key];\n        const varB = (typeof b[key] === \"string\")\n            ? b[key].toUpperCase() : b[key];\n\n        let comparison = 0;\n        if (varA > varB) {\n            comparison = 1;\n        } else if (varA < varB) {\n            comparison = -1;\n        }\n        return (\n            (order === \"DESC\") ? (comparison * -1) : comparison\n        );\n    };\n}\n\n/**\n * Esse método tem como função limpar o valor dos campos.\n *\n * @param formGroup FormGroup onde se encontra os campos a serem limpos.\n * @param fields Campos a serem limpos.\n */\nexport function clearValues(formGroup: FormGroup, fields: Array<string>) {\n  fields.forEach(field => formGroup.get(field).reset());\n}\n\n/**\n *\n * @param qs = window.location.search\n * @returns Object com parametros query string\n */\nexport function getQueryParams(qs) {\n  qs = qs.split('+').join(' ');\n\n  const params = {};\n  let tokens;\n  const re = /[?&]?([^=]+)=([^&]*)/g;\n\n  while ((tokens = re.exec(qs))) {\n    params[decodeURIComponent(tokens[1])] = decodeURIComponent(tokens[2]);\n  }\n\n  return params;\n}\n\nexport function getFormat(locale) {\n  if (locale) {\n    let dateFormat = locale.calendar.dateFormat.toString();\n    dateFormat = dateFormat.replace(/[y]/g, 'YY');\n    dateFormat = dateFormat.replace(/[/]/g, '');\n    return dateFormat.toUpperCase();\n  }\n}\n\n/**\n * Remove os caracteres que não sejam números do valor\n * @param value valor a ser tratado\n * @returns string O valor sem caracteres especiais\n */\nexport function removeCharacteresSpecials(value: any): string {\n    return value ? value.toString().replace(/[&\\/\\\\#,+()$~%.'\":*?<>{}-]/g, \"\") : null;\n}\n"]}