366 lines
15 KiB
JavaScript
366 lines
15 KiB
JavaScript
import Cookie from 'js-cookie'
|
|
import functions from 'v-functions'
|
|
import presets from './globalPresets'
|
|
import { findWhere } from 'underscore'
|
|
import { execute } from '@/helper/clientApi'
|
|
|
|
/**
|
|
* @typedef {Object} Environment
|
|
* @property {function} getResultParameters - Funcion para obtener los parametros de un resultado
|
|
* @property {function} buildFunctiontsHeaders - Funcion para construir las funciones de los headers
|
|
* @property {function} setEnvUser - Funcion para guardar el usuario en el localstorage
|
|
* @property {function} getEnvUser - Funcion para obtener el usuario del localstorage
|
|
* @property {function} logout - Funcion para cerrar sesion
|
|
* @property {function} login - Funcion para iniciar sesion
|
|
* @property {function} getTime - Funcion para obtener la hora actual
|
|
* @property {function} validaResultadoDB - Funcion para validar el resultado de una peticion a la base de datos
|
|
* @property {function} getFileParams - Funcion para obtener los parametros de un archivo
|
|
* @property {function} validaPermisos - Funcion para validar los permisos de un usuario
|
|
* @property {function} i18nHeaders - Funcion para traducir los headers
|
|
*
|
|
* @type {Environment}
|
|
* @exports environment
|
|
* @description Este archivo contiene las funciones globales de la aplicacion
|
|
* @example
|
|
* import environment from '@/utils/environment'
|
|
*
|
|
* environment.getResultParameters(confParameters, item, mainParameters)
|
|
*
|
|
*/
|
|
const environment = {
|
|
getResultParameters: (confParameters, item, mainParameters) => {
|
|
const resultParameters = []
|
|
if (confParameters != null && confParameters.length) {
|
|
confParameters.forEach((orParam) => {
|
|
if (orParam.type === 'param') {
|
|
const _parameters = [...mainParameters]
|
|
const arrParam = _parameters.filter((paramSel) => (paramSel.name === orParam.id))
|
|
if (arrParam.length) {
|
|
resultParameters.push(arrParam[0].value)
|
|
} else {
|
|
resultParameters.push(null)
|
|
}
|
|
} else {
|
|
if (item != null && item[orParam.id] != null) {
|
|
resultParameters.push(item[orParam.id])
|
|
} else {
|
|
resultParameters.push(null)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
return resultParameters
|
|
},
|
|
buildFunctiontsHeaders: (baseHeaders, iconResponse = () => {}, substituteValOnForm) => {
|
|
const newHeaders = []
|
|
if (baseHeaders != null && baseHeaders.length) {
|
|
for (let i = 0; i < baseHeaders.length; i++) {
|
|
const field = baseHeaders[i]
|
|
if (field.substituteValOnForm != null && substituteValOnForm != null) {
|
|
field.substituteValOnForm = (head, _model, _field, _isEdit) => { return substituteValOnForm(head, _model, _field, _isEdit) }
|
|
}
|
|
if (field.mappingRules != null && field.mappingRules.length) {
|
|
const _mappingRules = [...field.mappingRules]
|
|
// Insertar Funcion para substituteVal
|
|
const rulesValue = _mappingRules.filter((rule) => (rule.type === 'value' || rule.type === 'icon' || rule.type === 'format' || rule.type === 'fieldValue'))
|
|
if (rulesValue.length) {
|
|
field.substituteVal = (item) => {
|
|
const id = field.value
|
|
const rules = [...rulesValue]
|
|
if (rules.length) {
|
|
for (let i = 0; i < rules.length; i++) {
|
|
const rule = { ...rules[i] }
|
|
const numberRuleValue = Number(rule.value)
|
|
const numberFieldValue = Number(item[rule.field])
|
|
const areNums = !isNaN(numberRuleValue) && !isNaN(numberFieldValue)
|
|
let response = rule.result
|
|
if (rule.type === 'icon') {
|
|
response = iconResponse(item[id], rule.result, item)
|
|
}
|
|
if (rule.rule === 'equal') {
|
|
if ((!areNums && item[rule.field] === rule.value) || (areNums && numberFieldValue === numberRuleValue)) {
|
|
return response
|
|
} else if ((rule.value === null || rule.value === '') && (item[rule.field] === null || item[rule.field] === '')) {
|
|
return response
|
|
}
|
|
} else if (rule.rule === 'greater_than') {
|
|
if ((!areNums && item[rule.field] > rule.value) || (areNums && numberFieldValue > numberRuleValue)) {
|
|
return response
|
|
}
|
|
} else if (rule.rule === 'less_than') {
|
|
if ((!areNums && item[rule.field] < rule.value) || (areNums && numberFieldValue < numberRuleValue)) {
|
|
return response
|
|
}
|
|
} else if (rule.rule === 'not_equal') {
|
|
if ((!areNums && item[rule.field] !== rule.value) || (areNums && numberFieldValue !== numberRuleValue)) {
|
|
return response
|
|
} else if ((rule.value === null || rule.value === '') && (item[rule.field] !== null || item[rule.field] !== '')) {
|
|
return response
|
|
}
|
|
}
|
|
if (rule.type === 'format') {
|
|
const isNum = !isNaN(numberFieldValue)
|
|
try {
|
|
if (rule.rule === 'number') {
|
|
if (isNum) {
|
|
return functions.formatNumber(numberFieldValue, rule.result)
|
|
}
|
|
return functions.formatNumber(item[rule.field], rule.result)
|
|
} else if (rule.rule === 'date') {
|
|
if (isNum) {
|
|
return functions.formatDate(numberFieldValue, rule.result)
|
|
}
|
|
return functions.formatDate(item[rule.field], rule.result)
|
|
}
|
|
} catch (e) {
|
|
return item[id]
|
|
}
|
|
}
|
|
if (rule.type === 'fieldValue') {
|
|
try {
|
|
return item[rule.result]
|
|
} catch (e) {
|
|
return item[id]
|
|
}
|
|
}
|
|
}
|
|
return item[id]
|
|
}
|
|
return item[id]
|
|
}
|
|
} else {
|
|
field.substituteVal = field.substituteVal || null
|
|
}
|
|
// Insertar Funcion para classItem
|
|
const rulesClass = _mappingRules.filter((rule) => (rule.type === 'class'))
|
|
if (rulesClass.length) {
|
|
field.classItem = (item) => {
|
|
const rules = [...rulesClass]
|
|
let resultClass = ''
|
|
if (rules.length) {
|
|
for (let i = 0; i < rules.length; i++) {
|
|
const rule = { ...rules[i] }
|
|
const numberRuleValue = Number(rule.value)
|
|
const numberFieldValue = Number(item[rule.field])
|
|
const areNums = !isNaN(numberRuleValue) && !isNaN(numberFieldValue)
|
|
if (rule.rule === 'equal') {
|
|
if ((!areNums && item[rule.field] === rule.value) || (areNums && numberFieldValue === numberRuleValue)) {
|
|
resultClass = `${resultClass} ${rule.result}`
|
|
} else if ((rule.value === null || rule.value === '') && (item[rule.field] === null || item[rule.field] === '')) {
|
|
resultClass = `${resultClass} ${rule.result}`
|
|
}
|
|
} else if (rule.rule === 'greater_than') {
|
|
if ((!areNums && item[rule.field] > rule.value) || (areNums && numberFieldValue > numberRuleValue)) {
|
|
resultClass = `${resultClass} ${rule.result}`
|
|
}
|
|
} else if (rule.rule === 'less_than') {
|
|
if ((!areNums && item[rule.field] < rule.value) || (areNums && numberFieldValue < numberRuleValue)) {
|
|
resultClass = `${resultClass} ${rule.result}`
|
|
}
|
|
} else if (rule.rule === 'not_equal') {
|
|
if ((!areNums && item[rule.field] !== rule.value) || (areNums && numberFieldValue !== numberRuleValue)) {
|
|
resultClass = `${resultClass} ${rule.result}`
|
|
} else if ((rule.value === null || rule.value === '') && (item[rule.field] !== null || item[rule.field] !== '')) {
|
|
resultClass = `${resultClass} ${rule.result}`
|
|
}
|
|
}
|
|
}
|
|
return resultClass
|
|
}
|
|
return resultClass
|
|
}
|
|
} else {
|
|
field.classItem = null
|
|
}
|
|
} else {
|
|
field.classItem = null
|
|
field.substituteVal = field.substituteVal || null
|
|
}
|
|
|
|
if (field.showInForm != null && field.showInForm === true) {
|
|
if (field.formatDefinition != null && field.formatDefinition.action != null) {
|
|
if (field.formatDefinition.action === 'format') {
|
|
field.format = (val, definition = field.formatDefinition) => {
|
|
if (val != null) {
|
|
if (definition.value === 'lowercase') {
|
|
const valString = String(val)
|
|
return valString.toLowerCase()
|
|
} else if (definition.value === 'uppercase') {
|
|
const valString = String(val)
|
|
return valString.toUpperCase()
|
|
}
|
|
}
|
|
return val
|
|
}
|
|
}
|
|
} else {
|
|
field.format = null
|
|
}
|
|
}
|
|
newHeaders.push({ ...field })
|
|
}
|
|
}
|
|
return newHeaders
|
|
},
|
|
setEnvUser: (user) => {
|
|
functions.setEncodeStorage(`${process.env.idApp}/${process.env.NODE_ENV}`, user)
|
|
},
|
|
getEnvUser: () => {
|
|
return new Promise((resolve, reject) => {
|
|
const token = Cookie.get(`${process.env.idApp}:${process.env.NODE_ENV}`)
|
|
const user = functions.getDecodeStorage(`${process.env.idApp}/${process.env.NODE_ENV}`)
|
|
if (!token || !user) {
|
|
resolve({ token: undefined, user: undefined, redirectPath: '/login' })
|
|
}
|
|
resolve({ token, user })
|
|
})
|
|
},
|
|
logout: () => {
|
|
return new Promise((resolve, reject) => {
|
|
Cookie.remove(`${process.env.idApp}:${process.env.NODE_ENV}`)
|
|
functions.setEncodeStorage(`${process.env.idApp}/${process.env.NODE_ENV}`, '')
|
|
resolve('/')
|
|
})
|
|
},
|
|
login: (token, user) => {
|
|
return new Promise((resolve, reject) => {
|
|
Cookie.set(`${process.env.idApp}:${process.env.NODE_ENV}`, token)
|
|
functions.setEncodeStorage(`${process.env.idApp}/${process.env.NODE_ENV}`, user)
|
|
resolve()
|
|
})
|
|
},
|
|
getTime: () => {
|
|
// return (new Date()).getTime()
|
|
return 1668220842700
|
|
},
|
|
validaResultadoDB: (resultado, i18n, toast, showOKMessage = false) => {
|
|
const showToast = (i18n, toast, message, type, i18nCode = null) => {
|
|
const displayMessage = message
|
|
|
|
// if (displayMessage.includes(':console-message:')) {
|
|
// console.warn(displayMessage.replace(':console-message:', ''))
|
|
// } else
|
|
if (toast && showOKMessage) {
|
|
const cleanedMessage = displayMessage.replace(':no-display:', '')
|
|
toast[type](
|
|
<span dangerouslySetInnerHTML={{ __html: cleanedMessage }} />,
|
|
presets.toaster
|
|
)
|
|
}
|
|
}
|
|
|
|
if (!resultado) {
|
|
showToast(i18n, toast, i18n.t('common.errorApi'), 'error')
|
|
return false
|
|
}
|
|
|
|
if (Array.isArray(resultado) && resultado.length > 0) {
|
|
const { status, message, mensaje, i18n: i18nCode } = resultado[0]
|
|
|
|
if (status === 'ERROR' || status === 'error' || status === 'WARNING' || status === 'warning' || status === 'INFO' || status === 'info') {
|
|
if (i18n === 'session.inactive' || i18n === 'session.inactiva' || message === 'Sesión inactiva') {
|
|
// if (store.state.sessionInactive === false) {
|
|
// store.actions.setSessionInactive(true)
|
|
// }
|
|
} else {
|
|
showToast(i18n, toast, (message || mensaje), status === 'ERROR' ? 'error' : 'warning', i18nCode)
|
|
}
|
|
return false
|
|
}
|
|
|
|
if ((status === 'OK' || status === 'ok' || status === 'SUCCESS' || status === 'success') && showOKMessage) {
|
|
showToast(i18n, toast, (message || mensaje), 'success', i18nCode)
|
|
}
|
|
}
|
|
|
|
return true
|
|
},
|
|
getFileParams (model, headers, value, prefix) {
|
|
const head = findWhere(headers, { value })
|
|
const { filename, extension } = functions.getFilePattern(model[value])
|
|
const params = {}
|
|
if (head.logicalName && head.logicalName !== null) {
|
|
if (typeof head.logicalName === 'function') {
|
|
params.logico = head.logicalName(model)
|
|
} else {
|
|
params.logico = head.logicalName
|
|
}
|
|
} else {
|
|
params.logico = filename
|
|
}
|
|
if (prefix && prefix !== null) {
|
|
params.logico = `${prefix}${params.logico}`
|
|
}
|
|
if (head.logicalExtension && head.logicalExtension !== null) {
|
|
if (typeof head.logicalExtension === 'function') {
|
|
params.ext = head.logicalExtension(model)
|
|
} else {
|
|
params.ext = head.logicalExtension
|
|
}
|
|
} else {
|
|
params.ext = extension
|
|
}
|
|
return params
|
|
},
|
|
validaPermisos: async (token, administra, configura, graba_modifica, consulta) => {
|
|
let permisos = await execute('FUN_INFO_SESION_ENTIDAD', [token])
|
|
if (permisos === undefined || permisos.length <= 0) {
|
|
return false
|
|
}
|
|
if (permisos[0].status === 'ERROR') {
|
|
return false
|
|
} else if (permisos[0].status === 'WARNING') {
|
|
return false
|
|
} else {
|
|
permisos = permisos[0]
|
|
const secVal = []
|
|
if (permisos.administra === 'S') {
|
|
return true
|
|
} else if (permisos.configura === 'S') {
|
|
secVal.push(2)
|
|
} else if (permisos.graba_modifica === 'S') {
|
|
secVal.push(3)
|
|
} else if (permisos.consulta === 'S') {
|
|
secVal.push(4)
|
|
}
|
|
if (configura === 'S' && secVal.includes(2) === true) {
|
|
return true
|
|
} else if (graba_modifica === 'S' && secVal.includes(3) === true) {
|
|
return true
|
|
} else if (consulta === 'S' && secVal.includes(4) === true) {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
},
|
|
i18nHeaders: (i18n, headers) => {
|
|
return new Promise((resolve) => {
|
|
const newHeaders = []
|
|
for (const hds of headers) {
|
|
if (hds.i18n && hds.i18n.length > 0) {
|
|
hds.text = i18n.t(hds.i18n)
|
|
}
|
|
if (hds.pristineMessages) {
|
|
Object.keys(hds.pristineMessages).forEach((msg) => {
|
|
if (msg.includes('-params') === false) {
|
|
if (hds.pristineMessages[`${msg}-params`]) {
|
|
hds.inputProps[`data-pristine-${msg}-message`] = hds.pristineMessages[msg]
|
|
? i18n.t(hds.pristineMessages[msg], hds.pristineMessages[`${msg}-params`])
|
|
: 'txtNone'
|
|
} else {
|
|
hds.inputProps[`data-pristine-${msg}-message`] = hds.pristineMessages[msg]
|
|
? i18n.t(hds.pristineMessages[msg])
|
|
: 'txtNone'
|
|
}
|
|
}
|
|
})
|
|
}
|
|
newHeaders.push(hds)
|
|
}
|
|
resolve(newHeaders)
|
|
})
|
|
}
|
|
}
|
|
|
|
export default environment
|