Beispiel #1
0
        public object validacionSIF([FromBody] dynamic objetoRecibido)// objetoRecibido = {cod_entidad:cod_entidad}
        {
            inicializaDatos(objetoRecibido.cod_entidad.ToString());
            this.archivosEntidadCadena = ArchivosController.encadenaArchivosDeEntidadMes(this.codigoEntidad, this.mesControl);
            // realiza la validacion_________________________________________________>>>>>>
            dynamic valContenido   = this.realizarValidacionContenido();
            int     estadoValidezC = valContenido.estadoValidez;

            // obtiene el estado de validez que tiene seguimiento_envio ya guardado en la validacion de formato
            dynamic segEntidad    = SgmntController.seguimientoAperturaActivaEntidad(this.codigoEntidad);
            int     estadoValidez = Convert.ToInt16(segEntidad.estado);

            ////------------------------------------- se añade val EF dentro del proceso por un error al llamar en paralelo  ----------------------------------------
            this.cambio_2 = this.aperturaDatos.mCompra;
            this.cambio_4 = this.aperturaDatos.mUFV;
            this.cambio_5 = this.aperturaDatos.mEuroBS;
            this.margenEF = this.aperturaDatos.margen_partes_ef;
            this.factorTC = this.aperturaDatos.factor_tc;

            this.archivosEntidadCadena = ArchivosController.encadenaArchivosDeEntidadMes(this.codigoEntidad, this.mesControl);
            ////////_____________________________>>>> Validacion de Partes de Producción y Siniestros  con Estados Financieros ///////////////////////////////////////////
            int estadoValidezEF = this.validaPartesEF();

            estadoValidez = Math.Min(estadoValidez, Math.Min(estadoValidezC, estadoValidezEF));
            SgmntController.modificaEstado(segEntidad.id_seguimiento_envio, estadoValidez);

            foreach (Error error in this.errores)
            {
                if (!error.valido)
                {
                    error.id_seguimiento_envio = segEntidad.id_seguimiento_envio;
                    ErroresController.insertarError(error);
                }
            }

            List <dynamic> constantes = ConstantesController.obtieneConstantesDeDimension("estado_seguimiento");
            dynamic        estadoSeg  = constantes.Where(x => x.codigo == estadoValidez.ToString()).FirstOrDefault();

            this.con.Close();
            this.resultado.status             = "success";
            this.resultado.estadoValidez      = estadoValidez;
            this.resultado.estadoValidez_desc = estadoSeg.valor + " - " + estadoSeg.descripcion;

            this.resultado.estadoValidezC = estadoValidezC;
            this.resultado.validoC        = estadoValidezC > 2;
            this.resultado.datosC         = this.listaValCont;

            this.resultado.estadoValidezEF = estadoValidezEF;
            this.resultado.validoEF        = estadoValidezEF > 2;
            this.resultado.datosEF         = listaValEF;

            return(this.resultado);
        }
        private void inicializaGlobalVars()
        {
            // this.fechaCorte = this.ctxSeguimiento.fecha_corte;
            this.anoControl    = this.fechaCorte.ToString("yyyy");
            this.mesControl    = this.fechaCorte.ToString("MM");
            this.diaControl    = this.fechaCorte.ToString("dd");
            this.anoControlInt = this.fechaCorte.Year;
            this.mesControlInt = this.fechaCorte.Month;
            this.diaControlInt = this.fechaCorte.Day;
            this.FechaCorteInt = this.anoControlInt * 10000 + this.mesControlInt * 100 + this.diaControlInt;
            dynamic mesesSolvencia = ConstantesController.obtieneConstantesDeDimension("meses_calculo_solvencia").FirstOrDefault();

            this.esMesSolvencia = mesesSolvencia.valor.Contains("|" + this.mesControlInt.ToString() + "|");
        }
Beispiel #3
0
        public object validacionConsultaPartesEF(string web_reporte, int idSeguimientoEnvio) //objetoRecibido = {id_seguimiento_envio }
        {
            try
            {
                // my code
                string token = HttpHelpers.GetTokenFromHeader(HttpContext);
                if (token == "")
                {
                    return(Unauthorized());
                }

                Base helper = new Base(AppSettings, token, HttpContext.Connection.RemoteIpAddress.ToString());

                List <Error> erroresLista            = ErroresController.getErroresDeSeguimiento(idSeguimientoEnvio);
                dynamic      seguimientoEntidadDatos = SgmntController.getSeguimientoEntidadDatos(idSeguimientoEnvio);
                this.codigoEntidad      = seguimientoEntidadDatos.cod_entidad.ToString();
                this.erroresDiccionario = ConstantesController.obtieneConstantesDeDimension("error");
                this.aperturaDatos      = AperturaController.getAperturaDeSeguimiento(idSeguimientoEnvio);

                this.fechaCorte = this.aperturaDatos.fecha_corte;
                this.anoControl = this.fechaCorte.Year;
                this.mesControl = this.fechaCorte.Month;
                this.diaControl = this.fechaCorte.Day;

                this.cambio_2 = this.aperturaDatos.mCompra;
                this.cambio_4 = this.aperturaDatos.mUFV;
                this.cambio_5 = this.aperturaDatos.mEuroBS;
                this.margenEF = this.aperturaDatos.margen_partes_ef;
                this.factorTC = this.aperturaDatos.factor_tc;

                this.archivosEntidadCadena = ArchivosController.encadenaArchivosDeEntidadMes(this.codigoEntidad, this.mesControl);

                ////////////////////// FORMATO ////////////////////////////////////////////////
                IEnumerable <Error> erroresF = erroresLista.Where(x => x.cod_error.Substring(0, 1) == "0").OrderBy(x => x.cod_error);
                bool validoF       = true;
                int  estadoValidez = 4;
                foreach (Error errorF in erroresF)
                {
                    errorF.desc_error    = descError(errorF.cod_error);
                    errorF.estadoValidez = estadoValidezDeError(errorF);
                    if (errorF.estadoValidez < estadoValidez)
                    {
                        estadoValidez = errorF.estadoValidez;
                    }
                }
                if (estadoValidez > 1) // si no hay EE
                {
                    // //////////////////////////////Validacion contenidos SIf y varios
                    dynamic valContenido   = this.realizarValidacionContenido();
                    int     estadoValidezC = valContenido.estadoValidez;
                    this.resultado.estadoValidezC = estadoValidezC;
                    this.resultado.validoC        = estadoValidezC > 2;
                    if (web_reporte == "web") //si es WEB se carga en una lista
                    {
                        this.resultado.datosC      = this.listaValCont;
                        this.resultado.validacionC = null;
                    }
                    else if (web_reporte == "reporte") //  sie es en para reporte se separa en objetos que tinen la misma estuctura
                    {
                        this.resultado.validacionC = valContenido;
                        this.resultado.datosC      = null;
                    }

                    /////////////////////////////// Validacion de Partes de Producción y Siniestros  con Estados Financieros ///////////////////////////////////////////
                    int estadoValidezEF = this.validaPartesEF();
                    this.resultado.estadoValidezEF = estadoValidezEF;
                    this.resultado.validoEF        = estadoValidezEF > 2;
                    this.resultado.datosEF         = listaValEF;

                    // del resultado gral
                    estadoValidez = Math.Min(estadoValidez, Math.Min(estadoValidezC, estadoValidezEF));
                }
                else
                {
                    validoF = false;
                }

                this.resultado.aperturaDatos           = this.aperturaDatos;
                this.resultado.seguimientoEntidadDatos = seguimientoEntidadDatos;


                List <dynamic> constantes = ConstantesController.obtieneConstantesDeDimension("estado_seguimiento");
                dynamic        estadoSeg  = constantes.Where(x => x.codigo == estadoValidez.ToString()).FirstOrDefault();

                this.con.Close();
                this.resultado.status             = "success";
                this.resultado.estadoValidez      = estadoValidez;
                this.resultado.estadoValidez_desc = estadoSeg.valor + " - " + estadoSeg.descripcion;

                this.resultado.validoF  = validoF;
                this.resultado.erroresF = erroresF;

                return(this.resultado);
            }
            catch (Exception ex)
            {
                return(new
                {
                    status = "error",
                    mensaje = ex.Message
                });
            }
        }
Beispiel #4
0
        public object validacionSIF([FromBody] dynamic objetoRecibido)// objetoRecibido = {cod_entidad:cod_entidad}
        {
            try
            {
                // my code
                string token = HttpHelpers.GetTokenFromHeader(HttpContext);
                if (token == "")
                {
                    return(Unauthorized());
                }

                Base helper = new Base(AppSettings, token, HttpContext.Connection.RemoteIpAddress.ToString());
                if (helper.Role == "carga_informacion")
                {
                    objetoRecibido.cod_entidad = helper.CiaId;
                }

                inicializaDatos(objetoRecibido.cod_entidad.ToString());
                this.archivosEntidadCadena = ArchivosController.encadenaArchivosDeEntidadMes(this.codigoEntidad, this.mesControl);
                // realiza la validacion_________________________________________________>>>>>>
                dynamic valContenido   = this.realizarValidacionContenido();
                int     estadoValidezC = valContenido.estadoValidez;

                // obtiene el estado de validez que tiene seguimiento_envio ya guardado en la validacion de formato
                dynamic segEntidad    = SgmntController.seguimientoAperturaActivaEntidad(this.codigoEntidad);
                int     estadoValidez = Convert.ToInt16(segEntidad.estado);

                ////------------------------------------- se añade val EF dentro del proceso por un error al llamar en paralelo  ----------------------------------------
                this.cambio_2 = this.aperturaDatos.mCompra;
                this.cambio_4 = this.aperturaDatos.mUFV;
                this.cambio_5 = this.aperturaDatos.mEuroBS;
                this.margenEF = this.aperturaDatos.margen_partes_ef;
                this.factorTC = this.aperturaDatos.factor_tc;

                this.archivosEntidadCadena = ArchivosController.encadenaArchivosDeEntidadMes(this.codigoEntidad, this.mesControl);
                ////////_____________________________>>>> Validacion de Partes de Producción y Siniestros  con Estados Financieros ///////////////////////////////////////////
                int estadoValidezEF = this.validaPartesEF();

                estadoValidez = Math.Min(estadoValidez, Math.Min(estadoValidezC, estadoValidezEF));
                SgmntController.modificaEstado(segEntidad.id_seguimiento_envio, estadoValidez);

                foreach (Error error in this.errores)
                {
                    if (!error.valido)
                    {
                        error.id_seguimiento_envio = segEntidad.id_seguimiento_envio;
                        ErroresController.insertarError(error);
                    }
                }

                List <dynamic> constantes = ConstantesController.obtieneConstantesDeDimension("estado_seguimiento");
                dynamic        estadoSeg  = constantes.Where(x => x.codigo == estadoValidez.ToString()).FirstOrDefault();

                this.con.Close();
                this.resultado.status             = "success";
                this.resultado.estadoValidez      = estadoValidez;
                this.resultado.estadoValidez_desc = estadoSeg.valor + " - " + estadoSeg.descripcion;

                this.resultado.estadoValidezC = estadoValidezC;
                this.resultado.validoC        = estadoValidezC > 2;
                this.resultado.datosC         = this.listaValCont;

                this.resultado.estadoValidezEF = estadoValidezEF;
                this.resultado.validoEF        = estadoValidezEF > 2;
                this.resultado.datosEF         = listaValEF;

                return(this.resultado);
            }
            catch (Exception ex)
            {
                return(new
                {
                    status = "error",
                    mensaje = ex.Message
                });
            }
        }
Beispiel #5
0
        [Authorize(Roles = "carga_informacion,operador,administrador")] // definir sólo los roles que pueden invocar a esta acción
        public object validacionFormato([FromBody] dynamic objetoRecibido)
        {
            try
            {
                // my code
                string token = HttpHelpers.GetTokenFromHeader(HttpContext);
                if (token == "")
                {
                    return(Unauthorized());
                }

                Base helper = new Base(AppSettings, token, HttpContext.Connection.RemoteIpAddress.ToString());


                // some stuff


                //if (helper.CiaId == "101")
                //{

                //}
                // end my code


                if (helper.Role == "carga_informacion")
                {
                    objetoRecibido.cod_entidad = helper.CiaId;
                }

                inicializaDatos(objetoRecibido.cod_entidad.ToString());
                bool correcto = true;
                int  validezF = 4; //valido

                foreach (var item in objetoRecibido.archivosCargados)
                {
                    ArchivoCargado env = new ArchivoCargado();
                    env.nombre = item.nombre.ToString();
                    env.texto  = item.texto.ToString();
                    archivosEnv.Add(env);
                }

                // ####  PROCESOS DE VALIDACION

                this.resultado.erroresF = this.errores;
                // #### Verifica si la entidad con la que el usuario se hace log, existe y esta activa, caso contrario se sale con errorF:  error de Entida no existente
                if (correcto && !validarEntidad())
                {
                    correcto = false;
                    validezF = 1;
                    return(resultado);
                }

                // #### Verifica que los archivos enviados son los correctos correctos.  Si no estan todos los archivos correctos, retorna mostrando los errores
                if (correcto && !validarArchivosEnviadosNombres(this.archivosEnv))
                {
                    correcto = false;
                    validezF = 1;
                }

                // #### SI  LOS ARCHIVOS SON LOS CORRECTOS SE REALIZA ESTA PARTE
                // convierte el campo validaciones a un JSON y transforma el texto en un Array de filas y columnas
                if (correcto)
                {
                    this.transformaDatos(this.archivosEnv);
                }

                // #### VERIFICA LAS VALIDACIONES JSON
                // #### Se realiza la  Validacion de formato de texto (columnas, y typos de datos),
                // llegando aqui se cargan las listas de departamentos, monedas, modalidades, modalidadesRamos, modalidadesRamosPolizas
                // la funcion devuelve V EE o A; segun el error o advertencia en caso de las validaciones mayor que 0.
                string estadoValidaFormato = "";
                if (correcto)
                {
                    estadoValidaFormato = this.validarFormatoTexto(this.archivosEnv);
                }

                if (correcto && estadoValidaFormato != "V")                //si es distinto de valido se setea el estadoEnvio segun el error //////////////////////////
                {
                    validezF = estadoValidaFormato == "EE" ? 1 : 3;        // es Error 1: EE o 3:  Advertencia
                    correcto = estadoValidaFormato == "EE" ? false : true; // En esta validacion de formato solo puede ser EE A o V, si no es EE es correcto
                }

                // antes de insertar se eliminan los registros de los archivos , de igual manera si hubieron errors se eliminan los registros
                eliminarDeTablaVal("A", this.codigoEntidad, this.fechaCorte);
                eliminarDeTablaVal("B", this.codigoEntidad, this.fechaCorte);
                eliminarDeTablaVal("C", this.codigoEntidad, this.fechaCorte);
                eliminarDeTablaVal("D", this.codigoEntidad, this.fechaCorte);
                eliminarDeTablaVal("E", this.codigoEntidad, this.fechaCorte);
                eliminarDeTablaVal("F", this.codigoEntidad, this.fechaCorte);
                eliminarDeTablaVal("G", this.codigoEntidad, this.fechaCorte);
                eliminarDeTablaVal("H", this.codigoEntidad, this.fechaCorte);
                //ingresa los datos a las tablas
                if (correcto)
                {
                    foreach (var arch in this.archivosEnv)
                    {
                        int i = 0;
                        foreach (var registro in arch.objetosFila)
                        {
                            try
                            {
                                insertarITF(arch.codigo, registro);
                                i++;
                            }
                            catch (System.Exception ex)
                            {
                                // EE - 00 "No se pudo guardar la información, por favor intente de enviar nuevamente todos los archivos, ",
                                errores.Add(err("000", arch.nombre, "Si continua el error, comuniquese con la APS, comunicando el siguiente mensaje:  \n Error de tabla al insertar, " + ex.Message, 0, 0));
                                eliminarDeTablaVal("A", this.codigoEntidad, this.fechaCorte);
                                eliminarDeTablaVal("B", this.codigoEntidad, this.fechaCorte);
                                eliminarDeTablaVal("C", this.codigoEntidad, this.fechaCorte);
                                eliminarDeTablaVal("D", this.codigoEntidad, this.fechaCorte);
                                eliminarDeTablaVal("E", this.codigoEntidad, this.fechaCorte);
                                eliminarDeTablaVal("F", this.codigoEntidad, this.fechaCorte);
                                eliminarDeTablaVal("G", this.codigoEntidad, this.fechaCorte);
                                eliminarDeTablaVal("H", this.codigoEntidad, this.fechaCorte);
                                correcto = false;
                                validezF = 1;
                                break;
                            }
                        }
                    }
                }

                // borra los errores relacionados con seguiiento_envios no vigentes
                ErroresController.borrarErroresDelLaMismaApertura(this.codigoEntidad);
                int idSeguimiento = SgmntController.insertarSeguimientoEnvio(this.codigoEntidad, validezF);
                int estadoValidez = 4;
                foreach (Error errorF in this.errores)
                {
                    errorF.id_seguimiento_envio = idSeguimiento;
                    errorF.creado_por           = helper.UsuarioId;
                    ErroresController.insertarError(errorF);

                    errorF.desc_error = descError(errorF.cod_error);
                    if (errorF.estadoValidez < estadoValidez)
                    {
                        estadoValidez = errorF.estadoValidez;
                    }
                }
                con.Close();
                List <dynamic> constantes = ConstantesController.obtieneConstantesDeDimension("estado_seguimiento");
                dynamic        estadoSeg  = constantes.Where(x => x.codigo == estadoValidez.ToString()).LastOrDefault();


                this.resultado.status             = "success";
                this.resultado.validoF            = correcto;
                this.resultado.estadoValidez      = estadoValidez;
                this.resultado.estadoValidez_desc = estadoSeg.valor + " - " + estadoSeg.descripcion;
                this.resultado.tipoValidacion     = "formato";
                this.resultado.erroresF           = this.errores;
                // resultado.env = this.archivosEnv;
                return(this.resultado);
            }
            catch (Exception ex)
            {
                return(new
                {
                    status = "error",
                    mensaje = ex.Message
                });
            }
        }