[Authorize(Roles = "administrador,carga_informacion,operador")] //Obtiene todo el contexto de entidad y seguimiento activo de una entidad de la apertura activa
public dynamic getSeguimientoAperturaActivaEntidad(string cod_entidad)
{
string token = HttpHelpers.GetTokenFromHeader(HttpContext);
if (token == "")
{
return(Unauthorized());
}
Base helper = new Base(AppSettings, token, HttpContext.Connection.RemoteIpAddress.ToString());
if (helper.Role == "carga_informacion")
{
cod_entidad = helper.CiaId;
}
dynamic seguimientoActivoEntidad = SgmntController.seguimientoAperturaActivaEntidad(cod_entidad);
return(new
{
status = "success",
mensaje = "encontrado",
codigo = "200",
data = seguimientoActivoEntidad
});
}
public object validacionPartesEF([FromBody] dynamic objetoRecibido) // objetoRecibido = {cod_entidad:cod_entidad}
{
inicializaDatos(objetoRecibido.cod_entidad.ToString());
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();
dynamic segEntidad = SgmntController.seguimientoAperturaActivaEntidad(this.codigoEntidad);
if (estadoValidezEF < Convert.ToInt16(segEntidad.estado)) // si el estado de error de la validacion es peor que el de seguimiento actual, entonces se guarda el peor en el estado del seguimiento: estados 1 E grave, 2 error , 3 advertencia 4 valido
{
SgmntController.modificaEstado(segEntidad.id_seguimiento_envio, estadoValidezEF);
}
foreach (Error error in this.errores)
{
if (!error.valido)
{
error.id_seguimiento_envio = segEntidad.id_seguimiento_envio;;
ErroresController.insertarError(error);
}
}
con.Close();
this.resultado.status = "success";
this.resultado.validoEF = estadoValidezEF > 2;
this.resultado.validacionEF = listaValEF; //cada item contiene { validacion:'titulo', data:{datos de la validacion}, valido: true or false, error:{error con descripcion}, tipo_parte: 'produccion o siniestro' }
return(this.resultado);
}
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);
}
public dynamic getSeguimientoAperturaActivaEntidad(string cod_entidad)
{
dynamic seguimientoActivoEntidad = SgmntController.seguimientoAperturaActivaEntidad(cod_entidad);
return(new
{
status = "success",
mensaje = "encontrado",
codigo = "200",
data = seguimientoActivoEntidad
});
}
// puede ser envios/2016-03-31 o envios/apertura_activa
public dynamic get_SeguimientoEntidades(string aperActiva_fCorte)
{
List <dynamic> listaActivos = SgmntController.getSeguimientoEntidades(aperActiva_fCorte);
return(new
{
status = "success",
mensaje = "encontrados",
codigo = "200",
data = listaActivos
});
}
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
});
}
}
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
});
}
}
[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
});
}
}
public object consolidacionDeEntidad([FromBody] dynamic objObservaciones)
{
string token = HttpHelpers.GetTokenFromHeader(HttpContext);
if (token == "")
{
return(Unauthorized());
}
Base helper = new Base(AppSettings, token, HttpContext.Connection.RemoteIpAddress.ToString());
List <dynamic> enviosAct = SgmntController.getSeguimientoEntidades("apertura_activa");
enviosAct = enviosAct.Where(x => x.valido && (x.estado_cierre == null || x.estado_cierre == "")).ToList();
this.fechaCorte = con.Query <DateTime>("Select fecha_corte from aperturas where activo").FirstOrDefault();
con.Close();
this.inicializaGlobalVars();
string estadoCierre = this.esMesSolvencia ? "consolidado" : "cerrado";
List <dynamic> listaRes = new List <dynamic>();
bool procesoExitoso = true;
Exception excepcion = null; // TO DO habilitar error para visualizar errores, deshabilitar en produccion
if (objObservaciones.observaciones == null)
{
objObservaciones.observaciones = "";
}
if (enviosAct.Count > 0)
{
// dynamic consolidacionActiva = this.obtieneUltimaConsolidacion().data;
//INICIALIZA PROCESO CONSOLIDACION
int id_consolidacion = this.insertConsolidacion(objObservaciones.observaciones.ToString(), helper);
foreach (dynamic envio in enviosAct)
{
try
{
// Realiza la consolidacion por cada entidad que ha eviado y la info sea valida y activa, y no haya sido consolidaa
if (envio.valido && (envio.estado_cierre == null || envio.estado_cierre == ""))
{
this.ctxSeguimiento = envio;
this.codigoEntidad = ctxSeguimiento.cod_entidad;
// llena las tablas iftPartesProduccionSiniestros,
this.llenaIftPartesProduccionSiniestros(this.codigoEntidad);
// llena las tablas iftPartesProduccionRamos,
this.llenaIftPartesProduccionRamos(this.codigoEntidad);
// llena iftPartesSiniestrosRamos
this.llenaIftPartesSiniestrosRamos(this.codigoEntidad);
// llena tabla , iftPartesSegurosLargoPlazo
this.llenaIftPartesSegurosLargoPlazo(this.codigoEntidad);
// Se realiza la consolidacion
// carga los saldos totales de la tabla val_balance_estado_resultados
this.llenaSaldosTotales(this.codigoEntidad);
// 1 realiza la carga a la tabla iftBalanceEstadoResultados sin duplicados
this.consolidaInfoMensualAntesDeCierre(this.codigoEntidad);
// 2. Consolida PartesProduccionCorredoras iftPartesProduccionCorredoras
this.consolidaProduccionCorredoras(this.codigoEntidad);
// 3 inserta las excepciones Caso BUPA 201
this.insertarComodines();
if (esMesSolvencia)
{
//inserta campos vacios por la entidad en las tablas iftPatrimonioTecnico y tMSPrevisionales
this.insertaPatrimonioTecnicoVacio();
this.insertaMargenSolvenciaPrevisionalesVacio();
}
this.paso = 1;
// llama al metodo que realiza pasos para el cierre
this.procedimientosHastaMargenSolvencia(this.codigoEntidad);
// llama a los procedimientos siguientes para informacion estadistica WEB y SIG
this.procedimientosCierreHastaSIG(this.codigoEntidad);
this.informacionFinancieraOLAP();
////_____________________________ se crea la respuesta que es una lista de las compañias enviadas ________________________
object seguimientoConsolidacion = new
{
id_seguimiento_envio = envio.id_seguimiento_envio,
cod_entidad = envio.cod_entidad,
id_consolidacion = id_consolidacion,
estado_cierre = estadoCierre
};
// asigna el valor de id_consolidacion al seguimiento y le asigna su estadoCierre
con.Execute(@"UPDATE seguimiento_envios SET id_consolidacion = @id_consolidacion, estado_cierre = @estado_cierre
WHERE id_seguimiento_envio = @id_seguimiento_envio", seguimientoConsolidacion);
con.Close();
listaRes.Add(seguimientoConsolidacion);
}
}
catch (Exception e)
{
procesoExitoso = false;
excepcion = e;
break;
};
}
;
estadoCierre = procesoExitoso ? estadoCierre : ""; // si no hubo error se cambi al estado Consolidado o cerrado , segun si fue normal o trimestral, caso contrario "consolidacion.estado" vuelve al valor que tenia originalmente
this.estadoConsolidacion(id_consolidacion, estadoCierre, false);
}
con.Close();
conSegSql.Close();
return(new
{
status = "success",
calculo_solvencia = this.esMesSolvencia,
errorEnCierre = !procesoExitoso,
excepcion = excepcion,
paso = this.paso,
data = new
{
lista = listaRes,
estadoCierre = estadoCierre
}
});
}
public object cerrarConsolidados([FromBody] List <dynamic> consolidadosOb) //consolidadosOB tiene los objetos envio con mPatTecnico y mMSPrevisional de cada entidad
{
List <dynamic> enviosAct = SgmntController.getSeguimientoEntidades("apertura_activa");
List <dynamic> consolidacionesList = enviosAct.Where(x => x.estado_cierre != null && x.estado_cierre == "consolidado").Select(x => x.id_consolidacion).Distinct().ToList();
this.fechaCorte = con.Query <DateTime>("Select fecha_corte from aperturas where activo").FirstOrDefault();
con.Close();
this.inicializaGlobalVars();
List <dynamic> listaRes = new List <dynamic>();
bool procesoExitoso = true;
Exception excepcion = null;
// Ya no se realiza este paso y aque pueden ser varias consolidaciones para un periodo
// dynamic consolidacionActiva = this.obtieneUltimaConsolidacion().data;
// //INICIALIZA PROCESO CONSOLIDACION
// int id_consolidacion = consolidacionActiva.id_consolidacion;
string estadoCierre = "cerrado";
foreach (dynamic consolidacionId in consolidacionesList)
{
int id_consolidacion = Convert.ToInt32(consolidacionId);
List <dynamic> enviosConsolidacion = enviosAct.Where(x => x.id_consolidacion == id_consolidacion).ToList();
// return consolidacionesList;
foreach (dynamic envio in enviosConsolidacion)
{
try
{
if ((bool)envio.valido == true && envio.estado_cierre == "consolidado" && envio.id_consolidacion == id_consolidacion)
{
this.ctxSeguimiento = envio;
this.codigoEntidad = envio.cod_entidad;
dynamic consolidadoOBItem = consolidadosOb.Where(x => x.id_seguimiento_envio == envio.id_seguimiento_envio).FirstOrDefault();
//inserta los valores de PAtrimonioTecnico y MSprevisional
decimal valorPT = Convert.ToDecimal(consolidadoOBItem.mPatTecnico.ToString().Replace(".", ",")); //envio.mPatTecnico.ToString().ToDecimal();
decimal valorMSprevisional = Convert.ToDecimal(consolidadoOBItem.mMSPrevisional.ToString().Replace(".", ","));
this.insertarPatrimonioTecnico(valorPT);
this.insertarMSolvenciaPrevisional(valorMSprevisional);
//______________________ Continua con los pasos Hasta Margen de Solvencia _______________________
// llama al metodo que realiza solo los pasos hasta el calculo de Margen de solvencia e indicadores
this.procedimientosHastaMargenSolvencia(this.codigoEntidad);
// Todos los consolidados pasan a estado cerrado
object seguimientoConsolidacion = new
{
id_seguimiento_envio = (int)envio.id_seguimiento_envio,
id_consolidacion = (int)envio.id_consolidacion,
estado_cierre = estadoCierre.ToString()
};
// asigna al seguimiento su estadoCierre
con.Execute(@"UPDATE seguimiento_envios SET id_consolidacion = @id_consolidacion, estado_cierre = @estado_cierre
WHERE id_seguimiento_envio = @id_seguimiento_envio", seguimientoConsolidacion);
con.Close();
listaRes.Add(seguimientoConsolidacion);
}
}
catch (Exception e)
{
procesoExitoso = false;
excepcion = e;
break;
}
}
string estado_cierre = procesoExitoso ? estadoCierre : "consolidado"; // si no hubo error se cambi al estado Consolidado o cerrado , segun si fue normal o trimestral, caso contrario "consolidacion.estado" vuelve al valor que tenia originalmente
this.estadoConsolidacion(id_consolidacion, estado_cierre, false);
}
con.Close();
conSegSql.Close();
return(new
{
status = "success",
calculo_solvencia = this.esMesSolvencia,
errorEnCierre2 = !procesoExitoso,
excepcion = excepcion,
data = new
{
lista = listaRes,
estadoCierre = procesoExitoso ? estadoCierre : "consolidado"
}
});
}
