public string formarCadenaRegla(Regla regla)
{
string retorno = "";
retorno += "SI ";
string[] antecedentes = regla.listarAntecedentes();
string[] consecuentes = regla.listarConsecuentes();
for (int i = 0; i < antecedentes.Length; i++)
{
if (i != 0)
{
retorno += " Y ";
}
Hecho hecho = base_conocimiento.leerHecho(antecedentes[i]);
retorno += hecho.hecho;
}
retorno += " ENTONCES ";
for (int i = 0; i < consecuentes.Length; i++)
{
if (i != 0)
{
retorno += " Y ";
}
Hecho hecho = base_conocimiento.leerHecho(consecuentes[i]);
retorno += hecho.hecho;
}
return(retorno);
}
public HechoAdapter(Hecho hecho)
{
this.EntHechoCheckun = new EntHechoCheckun
{
idTaxonomia = hecho.Taxonomia,
idEntidad = hecho.Entidad.Nombre,
espaciodeNombresEntidad = hecho.Entidad.Esquema,
espacioNombresPrincipal = hecho.Taxonomia,
codigoHashRegistro = hecho.IdHecho,
tipoDato = hecho.Concepto.TipoDato,
esTipoDatoNumerico = hecho.EsNumerico,
valor = hecho.Valor,
valorRedondeado = hecho.ValorNumerico.ToString(),
esValorChunks = hecho.EsValorChunks,
decimales = hecho.Decimales,
esTipoDatoFraccion = hecho.EsFraccion,
esValorNil = hecho.EsValorNil,
concepto = new ConceptoAdapter(hecho.Concepto).EntConcepto,
periodo = new PeriodoAdapter(hecho.Periodo).EntPeriodo,
unidades = new UnidadAdapter(hecho.Unidad).EntUnidades,
dimension = AdaptarDimensionesEntity(hecho.MiembrosDimensionales)
};
this.EntHechoCheckun.concepto.EspacioNombresTaxonomia = hecho.Taxonomia;
}
/// <summary>
/// Escribe en el reporte la sección de datos generales de la emisora.
/// </summary>
/// <param name="sheet">Hoja en la cual se escribirán los datos.</param>
/// <param name="hechos">Listado de hechos de reporte anual.</param>
public static void EscribirDatosGeneralesReporteCalculoMaterialidad(ISheet sheet, List <Hecho> hechos, IDictionary <String, object> parametrosReporte, IDictionary <String, object> datosReporte)
{
Hecho hechoNombreEmisora = null;
Hecho hechoTipoInstrumento = null;
if (hechos != null)
{
hechoNombreEmisora = hechos.Find(hecho => hecho.Concepto.IdConcepto.Equals("ar_pros_NameOfTheIssuer")) != null?hechos.Find(hecho => hecho.Concepto.IdConcepto.Equals("ar_pros_NameOfTheIssuer")) : null;
hechoTipoInstrumento = hechos.Find(hecho => hecho.Concepto.IdConcepto.Equals("ar_pros_TypeOfInstrument")) != null?hechos.Find(hecho => hecho.Concepto.IdConcepto.Equals("ar_pros_TypeOfInstrument")) : null;
}
if (hechoNombreEmisora != null)
{
sheet.GetRow(2).GetCell(1).SetCellValue(ReporteUtil.removeTextHTML(hechoNombreEmisora.Valor));
sheet.GetRow(3).GetCell(1).SetCellValue(hechoNombreEmisora.Entidad.Nombre);
}
else
{
object claveEmisora = "";
object razonSocialEmpresa = "";
datosReporte.TryGetValue("nombreCompletoEmpresa", out razonSocialEmpresa);
parametrosReporte.TryGetValue("'Entidad.Nombre'", out claveEmisora);
sheet.GetRow(2).GetCell(1).SetCellValue(razonSocialEmpresa != null ? razonSocialEmpresa.ToString() : "");
sheet.GetRow(3).GetCell(1).SetCellValue(claveEmisora != null ? claveEmisora.ToString().Replace("'", "") : "");
}
if (hechoTipoInstrumento != null)
{
sheet.GetRow(4).GetCell(1).SetCellValue(hechoTipoInstrumento.Valor);
}
else
{
object tipoDeInstrumento = "";
datosReporte.TryGetValue("datoTipoDeInstumento", out tipoDeInstrumento);
sheet.GetRow(4).GetCell(1).SetCellValue(tipoDeInstrumento != null ? tipoDeInstrumento.ToString() : "");
}
object noticia = new object();
object fecha = new object();
object moneda = new object();
object montoDeOperacion = new object();
object tipoDeCambio = new object();
datosReporte.TryGetValue("datoNoticia", out noticia);
datosReporte.TryGetValue("datoFecha", out fecha);
datosReporte.TryGetValue("datoMoneda", out moneda);
datosReporte.TryGetValue("datoMontoDeOperacion", out montoDeOperacion);
datosReporte.TryGetValue("datoTipoDeCambio", out tipoDeCambio);
sheet.GetRow(6).GetCell(1).SetCellValue(noticia != null ? noticia.ToString() : "");
sheet.GetRow(9).GetCell(1).SetCellValue(fecha != null ? fecha.ToString() : "");
sheet.GetRow(11).GetCell(1).SetCellValue(montoDeOperacion != null ? Convert.ToDouble(montoDeOperacion) : double.NaN);
sheet.GetRow(11).GetCell(2).SetCellValue(moneda != null ? moneda.ToString() : "");
sheet.GetRow(12).GetCell(1).SetCellValue(tipoDeCambio != null ? Convert.ToDouble(tipoDeCambio) : double.NaN);
}
/// <summary>
/// método que comprueba la integridad de las reglas
/// </summary>
/// <returns>Lista de errores encontrados</returns>
private List <string> comprobarIntegridadReglas()
{
List <string> errores_comprobacion = new List <string>();
string[] reglas = this.manejador_archivos.listarArchivosEnDirectorio(AccesoDatos.REGLA);
bool existen_variables_de_inicio_en_los_antecedentes = false;
bool existen_variables_objetivo_en_el_consecuente = false;
for (int i = 0; i < reglas.Length; i++)
{
Regla regla = manejador_archivos.extraerRegla(reglas[i]);
if (!regla.chequeo_de_consistencia)
{
errores_comprobacion.Add("Regla no chequeada " + regla.id_regla + " : " + regla);
}
if (!regla.id_regla.Equals(reglas[i]))
{
errores_comprobacion.Add("Regla corrupta (Eliminada)" + regla.id_regla + " : " + regla);
manejador_archivos.eliminarRegla(reglas[i]);
}
Hecho hecho_consecuente = manejador_archivos.extraerHecho(regla.id_hecho_consecuente);
if (hecho_consecuente.hecho_objetivo)
{
existen_variables_objetivo_en_el_consecuente = true;
}
if (hecho_consecuente.hecho_preguntable_al_usuario)
{
errores_comprobacion.Add("Regla " + regla.id_regla + "(Consecuente preguntable al usuario) : " + regla);
regla.chequeo_de_consistencia = false;
manejador_archivos.actualizarRegla(regla);
}
if (!existen_variables_de_inicio_en_los_antecedentes)
{
string[] antecedentes = regla.listarAntecedentes();
for (int k = 0; k < antecedentes.Length && !existen_variables_de_inicio_en_los_antecedentes; k++)
{
Hecho hecho_antecedente = manejador_archivos.extraerHecho(antecedentes[k]);
if (hecho_antecedente.hecho_preguntable_al_usuario)
{
existen_variables_de_inicio_en_los_antecedentes = true;
}
}
}
}
if (leerMetadatos().tipo_de_encadenamiento == MetadatosBaseDeConocimiento.ENCADENAMIENTO_HACIA_ADELANTE &&
!existen_variables_de_inicio_en_los_antecedentes)
{
errores_comprobacion.Add("No existen reglas con variables de inicio en el antecedente");
}
if (leerMetadatos().tipo_de_encadenamiento == MetadatosBaseDeConocimiento.ENCADENAMIENTO_HACIA_ATRAS &&
!existen_variables_objetivo_en_el_consecuente)
{
errores_comprobacion.Add("No existen reglas con variables objetivo en su consecuente.");
}
return(errores_comprobacion);
}
void ventana_selecion_de_objetivo_evento_cambio_en_seleccion_variable(string id_variable)
{
ventana_selecion_de_objetivo.limpiarPanelEstados();
string[] id_hechos = motor_atras.obtenertPosibleHechosObjetivos(id_variable);
for (int i = 0; i < id_hechos.Length; i++)
{
Hecho hecho = base_conocimiento.leerHecho(id_hechos[i]);
ventana_selecion_de_objetivo.agregarOpcionPanelEstados(hecho.id_hecho, hecho + "");
}
}
private bool escribirLogEnArchivo(List <string> log, ProcesadorLogInferencia procesador, bool guardar_variables, bool guardar_hechos, bool guardar_reglas, string ruta_archivo)
{
StringBuilder texto_archivo = new StringBuilder();
for (int i = 0; i < log.Count; i++)
{
string linea_log = procesador.ProcesarLineaDeLoggeo(log[i]);
if (linea_log != null)
{
texto_archivo.AppendLine(linea_log);
}
}
if (guardar_reglas)
{
texto_archivo.AppendLine("");
texto_archivo.AppendLine("");
texto_archivo.AppendLine("-----------------------------------------------------");
texto_archivo.AppendLine("----------- Reglas ----------------------------");
texto_archivo.AppendLine("-----------------------------------------------------");
string[] lista_de_reglas = base_conocimiento.listarReglas();
for (int i = 0; i < lista_de_reglas.Length; i++)
{
Regla regla = base_conocimiento.leerRegla(lista_de_reglas[i]);
texto_archivo.AppendLine("ID " + regla.id_regla + " | " + regla);
}
}
if (guardar_hechos)
{
texto_archivo.AppendLine("");
texto_archivo.AppendLine("");
texto_archivo.AppendLine("-----------------------------------------------------");
texto_archivo.AppendLine("----------- Hechos ----------------------------");
texto_archivo.AppendLine("-----------------------------------------------------");
string[] lista_de_hechos = base_conocimiento.listarHechos();
for (int i = 0; i < lista_de_hechos.Length; i++)
{
Hecho hecho = base_conocimiento.leerHecho(lista_de_hechos[i]);
texto_archivo.AppendLine("ID " + hecho.id_hecho + " (ID variable " + hecho.id_variable + ") | " + hecho);
}
}
if (guardar_variables)
{
texto_archivo.AppendLine("");
texto_archivo.AppendLine("");
texto_archivo.AppendLine("-----------------------------------------------------");
texto_archivo.AppendLine("----------- Variables ----------------------------");
texto_archivo.AppendLine("-----------------------------------------------------");
string[] lista_de_variables = base_conocimiento.listarVariables();
for (int i = 0; i < lista_de_variables.Length; i++)
{
texto_archivo.AppendLine(extraerDetalleVariable(base_conocimiento.leerVariable(lista_de_variables[i])));
}
}
return(generarArchivoDeTexto(texto_archivo, ruta_archivo));
}
int[] motor_inferencia_evento_confimar_hecho(string id_hecho, string id_regla)
{
Regla regla = base_conocimiento.leerRegla(id_regla);
Hecho hecho = base_conocimiento.leerHecho(id_hecho);
Variable variable = base_conocimiento.leerVariable(hecho.id_variable);
string[] lista_de_antecedentes = regla.listarAntecedentes();
Hecho[] hechos_antecedente = new Hecho[lista_de_antecedentes.Length];
for (int i = 0; i < lista_de_antecedentes.Length; i++)
{
hechos_antecedente[i] = base_conocimiento.leerHecho(lista_de_antecedentes[i]);
}
dialogo = new FormDialogoPanel(ventana_validar_hecho);
dialogo.FormClosing += dialogo_FormClosing;
ventana_validar_hecho.evento_respuesta_lista += evento_ventana_respuesta_lista;
ventana_validar_hecho.inciarConsultaHecho(id_regla, hecho, hechos_antecedente, variable.ruta_texto_descriptivo);
dialogo.ShowDialog(ventana_padre);
if (terminar_inferencia)
{
return(null);
}
int[] respuestas = new int[3];
if (ventana_validar_hecho.hecho_validado)
{
respuestas[0] = ConstantesShell.HECHO_CONFIRMADO;
}
else
{
respuestas[0] = ConstantesShell.HECHO_DESCARTADO;
}
if (ventana_validar_hecho.se_soluciono_el_problema)
{
respuestas[1] = ConstantesShell.PROBLEMA_SOLUCIONADO;
}
else
{
respuestas[1] = ConstantesShell.PROBLEMA_NO_SOLUCIONADO;
}
if (ventana_validar_hecho.continuar_inferencia)
{
respuestas[2] = ConstantesShell.CONTINUAR_PROCESO;
}
else
{
respuestas[2] = ConstantesShell.DETENER_PROCESO;
}
return(respuestas);
}
public void inicializarTextBox()
{
string[] lista_de_hechos = base_conocimiento.listarHechos();
for (int i = 0; i < lista_de_hechos.Length; i++)
{
Hecho hecho = base_conocimiento.leerHecho(lista_de_hechos[i]);
listBox_hechos.Items.Add(new ElementosListBox()
{
id = hecho.id_hecho,
info = hecho.hecho
});
}
}
public void listarHechos()
{
listBox_hechos.Items.Clear();
string[] ids_hechos = base_conocimiento.listarHechos();
for (int i = 0; i < ids_hechos.Length; i++)
{
Hecho hecho = base_conocimiento.leerHecho(ids_hechos[i]);
ElementoListBox elemento = new ElementoListBox()
{
id = hecho.id_hecho,
nombre = hecho + ""
};
listBox_hechos.Items.Add(elemento);
}
listBox_hechos.Refresh();
}
public string AgregarHechoProcesoVerbalAbreviado(CnpHechoDTO _cnpHechosDto)
{
Hecho cnpHechos = new Hecho();
cnpHechos.Fecha = _cnpHechosDto.Fecha;
cnpHechos.MunicipioId = _cnpHechosDto.MunicipioId;
cnpHechos.BarrioId = _cnpHechosDto.BarrioId;
cnpHechos.LocalidadId = _cnpHechosDto.LocalidadId;
cnpHechos.DireccionHechos = _cnpHechosDto.DireccionHechos;
//cnpHechos.IdComportamiento = _cnpHechosDto.IdComportamiento;
cnpHechos.Apelacion = _cnpHechosDto.Apelacion;
cnpHechos.RelatoHechos = _cnpHechosDto.RelatoHechos;
cnpHechos.Mop = _cnpHechosDto.Mop;
cnpHechos.Mrs = _cnpHechosDto.Mrs;
cnpHechos.Minc = _cnpHechosDto.Minc;
cnpHechos.Mtpp = _cnpHechosDto.Mtpp;
//cnpHechos.Msia = _cnpHechosDto.Msia;
//cnpHechos.Mtppp = _cnpHechosDto.Mtppp;
//cnpHechos.Minicoe = _cnpHechosDto.Minicoe;
//cnpHechos.Minisoe = _cnpHechosDto.Minisoe;
//cnpHechos.CnpArt = _cnpHechosDto.CnpArt;
//cnpHechos.CnpNum = _cnpHechosDto.CnpNum;
//cnpHechos.CnpLit = _cnpHechosDto.CnpLit;
cnpHechos.Latitud = _cnpHechosDto.Latitud;
cnpHechos.Longitud = _cnpHechosDto.Longitud;
//cnpHechos.IdTipoLugar = _cnpHechosDto.IdTipoLugar;
cnpHechos.Descargos = _cnpHechosDto.Descargos;
cnpHechos.HoraHechos = _cnpHechosDto.HoraHechos;
cnpHechos.AtiendeApelacion = _cnpHechosDto.AtiendeApelacion;
//cnpHechos.IdEntidadeRemiteApelac = _cnpHechosDto.IdEntidadeRemiteApelac;
//cnpHechos.Fuente = 1;
//cnpHechos.IdTipoTransp = _cnpHechosDto.IdTipoTransp;
cnpHechos.Vigente = true;
cnpHechos.UsuarioCreacion = HttpContext.Current.User.Identity.Name;
cnpHechos.MaquinaCreacion = HttpContext.Current.Request.UserHostAddress;
cnpHechos.FechaCreacion = DateTime.Now;
using (ContextCnp db = new ContextCnp())
{
cnpHechos.HechoId = Guid.NewGuid().ToString();
db.Hecho.Add(cnpHechos);
db.SaveChanges();
return(cnpHechos.HechoId);
}
}
private void agregarAntecedentes(Hecho hecho)
{
TextBox textBox_aux = new TextBox();
textBox_aux.Font = new System.Drawing.Font("Microsoft Sans Serif", 12F);
textBox_aux.Location = new System.Drawing.Point(x_inicial, ultimo_y);
textBox_aux.Name = "textBox";
textBox_aux.ReadOnly = true;
textBox_aux.Size = new System.Drawing.Size(390, 26);
textBox_aux.TabIndex = 16;
textBox_aux.Text = "" + hecho;
ultimo_y += espacio_control;
lista_de_antecedentes.Add(textBox_aux);
this.panel_antecedentes_int.Controls.Add(textBox_aux);
this.panel_antecedentes_int.Size = new System.Drawing.Size(400, ultimo_y);
/**/
}
/// <summary>
/// Método que inicia la consulta para comprobar un hecho
/// </summary>
/// <param name="hecho_a_validar">Hecho a comprobar</param>
/// <param name="ruta_rtf_descripcion">ruta de rtf a mostrar en pantalla, (Rtf correspondiente a la varaible del hecho)</param>
public void inciarConsultaHecho(string id_regla, Hecho hecho_a_validar, Hecho[] antecedentes, string ruta_rtf_descripcion)
{
limpiarControl();
this.id_regla = id_regla;
this.ruta_rtf_descriptivo = ruta_rtf_descripcion;
if (ruta_rtf_descriptivo != null && !ruta_rtf_descriptivo.Equals(""))
{
mostrarRTFDescripcion(ruta_rtf_descriptivo);
}
titulo = hecho_a_validar.nombre_variable;
for (int i = 0; i < antecedentes.Length; i++)
{
agregarAntecedentes(antecedentes[i]);
}
this.hecho_a_validar = hecho_a_validar + "";
button_validar_si.Enabled = true;
button_validar_no.Enabled = true;
}
/// <summary>
/// Escribe los valores en la tabla calculos.
/// </summary>
/// <param name="sheet"></param>
/// <param name="envio"></param>
/// <param name="listaHechosIFRS"></param>
public static void EscribirValoresCalculo(ISheet sheet, Envio envio, List <Hecho> listaHechosIFRS)
{
int renglon = 17;
int columna = 1;
if (envio != null)
{
DateTime fechaCierreTrimestreActual = new DateTime((envio.Periodo.Ejercicio - 1), 12, 31);
DateTime fechaCierreAcumuladoActual = new DateTime(envio.Periodo.Ejercicio, 12, 31);
DateTime inicioCierreAcumuladoActual = new DateTime(envio.Periodo.Ejercicio, 01, 01);
Hecho activos = listaHechosIFRS.Find(hecho => hecho.Concepto.IdConcepto.Equals("ifrs-full_Assets") && hecho.Periodo.TipoPeriodo == 1 && hecho.Periodo.FechaInstante.Equals(fechaCierreTrimestreActual));
Hecho pasivos = listaHechosIFRS.Find(hecho => hecho.Concepto.IdConcepto.Equals("ifrs-full_Liabilities") && hecho.Periodo.TipoPeriodo == 1 && hecho.Periodo.FechaInstante.Equals(fechaCierreTrimestreActual));
Hecho capital = listaHechosIFRS.Find(hecho => hecho.Concepto.IdConcepto.Equals("ifrs-full_Equity") && hecho.Periodo.TipoPeriodo == 1 && hecho.Periodo.FechaInstante.Equals(fechaCierreTrimestreActual));
Hecho ventas = listaHechosIFRS.Find(hecho => hecho.Concepto.IdConcepto.Equals("ifrs-full_Revenue") && hecho.Periodo.TipoPeriodo == 2 && hecho.Periodo.FechaInicio.Equals(inicioCierreAcumuladoActual) && hecho.Periodo.FechaFin.Equals(fechaCierreAcumuladoActual));
sheet.GetRow(renglon++).GetCell(columna).SetCellValue(activos != null ? Convert.ToDouble(activos.Valor) : double.NaN);
sheet.GetRow(renglon++).GetCell(columna).SetCellValue(pasivos != null ? Convert.ToDouble(pasivos.Valor) : double.NaN);
sheet.GetRow(renglon++).GetCell(columna).SetCellValue(capital != null ? Convert.ToDouble(capital.Valor) : double.NaN);
sheet.GetRow(renglon).GetCell(columna).SetCellValue(ventas != null ? Convert.ToDouble(ventas.Valor) : double.NaN);
}
}
/// <summary>
/// Método que comprueba la ambiguedad recursiva de las reglas
/// </summary>
/// <returns></returns>
private List <string> comprobarAmbiguedadRecursivaEnReglas()
{
List <string> errores_comprobacion = new List <string>();
List <InfoVariable> info_variables = new List <InfoVariable>();
//Inicio rellenado inicial info_variables
string[] reglas = this.manejador_archivos.listarArchivosEnDirectorio(AccesoDatos.REGLA);
for (int i = 0; i < reglas.Length; i++)
{
Regla regla = manejador_archivos.extraerRegla(reglas[i]);
Hecho hecho_consecuente = manejador_archivos.extraerHecho(regla.id_hecho_consecuente);
bool variable_encontrada_en_info_variables = false;
for (int j = 0; j < info_variables.Count; j++)
{
InfoVariable info_actual = info_variables[j];
string[] antecedentes = regla.listarAntecedentes();
string variable_consecuente = hecho_consecuente.id_variable;
string[] variables_antecedente = new string[antecedentes.Length];
for (int h = 0; h < antecedentes.Length; h++)//completamos la ids de las variables antecedente
{
Hecho hecho_antecedente = manejador_archivos.extraerHecho(antecedentes[h]);
variables_antecedente[h] = hecho_antecedente.id_variable;
}
if (info_actual.id_variable.Equals(variable_consecuente))//si variable asociada al consecuente ya se encuentra en el analisis, agregamos las variables antecedentes a variable asociada
{
//info_actual.reglas_relacionadas.Add(regla.id_regla);
info_actual.agregarElementoAReglasRelacionadas(regla.id_regla);
variable_encontrada_en_info_variables = true;
for (int k = 0; k < variables_antecedente.Length; k++)
{
if (!info_actual.buscarEnVariablesAsociadas(variables_antecedente[k]))//si no esta la variable la agregamos a las variables asociadas
{
info_actual.variables_asociadas.Add(variables_antecedente[k]);
}
}
}
else//Si el consecuente no esta en la variable principal, la buscamos en las asociadas
{
if (info_actual.buscarEnVariablesAsociadas(variable_consecuente))
{
//info_actual.reglas_relacionadas.Add(regla.id_regla);
info_actual.agregarElementoAReglasRelacionadas(regla.id_regla);
bool conflicto_regla = false;
for (int k = 0; k < variables_antecedente.Length; k++)//Comprobamos que el antecedente de la regla no contega la variable - lo cual provocaria ambiguedad
{
if (variables_antecedente[k].Equals(info_actual.id_variable))
{
conflicto_regla = true;
info_actual.agregarElementoAReglasEnConflicto(regla.id_regla);
//info_actual.reglas_en_conflicto.Add(regla.id_regla);
}
}
if (!conflicto_regla) //si no hubo conflicto de reglas agregamos las variables no repetidas a las variables asociadas
{
for (int k = 0; k < variables_antecedente.Length; k++)
{
if (!info_actual.buscarEnVariablesAsociadas(variables_antecedente[k]))//si no esta la variable la agregamos a las variables asociadas
{
info_actual.variables_asociadas.Add(variables_antecedente[k]);
}
}
}
}
}
info_variables[j] = info_actual;
}//end analisis info variables
if (!variable_encontrada_en_info_variables)
{
Variable variable = manejador_archivos.extraerVariable(hecho_consecuente.id_variable);
InfoVariable info = new InfoVariable();
info.id_variable = variable.id_variable;
info.nombre_variable = variable.nombre_variable;
info.variables_asociadas = new List <string>();
string[] antecedentes = regla.listarAntecedentes();
for (int x = 0; x < antecedentes.Length; x++)
{
Hecho h = manejador_archivos.extraerHecho(antecedentes[x]);
info.variables_asociadas.Add(h.id_variable);
}
info.reglas_relacionadas = new List <string>(); //Variables que se relacionan directa o recursivamente con la variable
info.reglas_relacionadas.Add(regla.id_regla);
info.reglas_en_conflicto = new List <string>();; //Reglas con problema de ambiguedad con la variable
info_variables.Add(info);
}
}//end analisis de reglas
//end rellenado inicial info_variables
//Proceso iterativo para que todas la variables se comparen con todas
bool flag_cambios = true;
while (flag_cambios)
{
flag_cambios = false;
for (int i = 0; i < info_variables.Count; i++)
{
for (int j = 0; j < info_variables.Count; j++)
{
if (i != j)
{
InfoVariable info_a = info_variables[i];
InfoVariable info_b = info_variables[j];
if (info_a.buscarEnVariablesAsociadas(info_b.id_variable))//si la variable b esta en las variables asociadas agregamos y analizamos las que falten
{
bool conflicto_regla = false;
for (int k = 0; k < info_b.variables_asociadas.Count; k++)//Comprobamos que el antecedente de la regla no contega la variable - lo cual provocaria ambiguedad
{
if (info_b.variables_asociadas[k].Equals(info_a.id_variable))
{
conflicto_regla = true;
}
}
if (!conflicto_regla) //si no hubo conflicto de reglas agregamos las variables no repetidas a las variables asociadas
{
for (int k = 0; k < info_b.variables_asociadas.Count; k++)
{
if (!info_a.buscarEnVariablesAsociadas(info_b.variables_asociadas[k]))//si no esta la variable la agregamos a las variables asociadas
{
info_a.variables_asociadas.Add(info_b.variables_asociadas[k]);
flag_cambios = true;
}
}
}
else//si hubo conflicto de reglas
{
info_a.agregarElementoAReglasEnConflicto(info_b.reglas_relacionadas);
info_a.agregarElementoAReglasRelacionadas(info_b.reglas_relacionadas);
}
}
info_variables[i] = info_a;
info_variables[j] = info_b;
}
}
}
}
//Rellenando reglas con errores
foreach (InfoVariable info in info_variables)
{
if (info.reglas_en_conflicto.Count > 0)
{
Variable variable = manejador_archivos.extraerVariable(info.id_variable);
string error = "";
error = "Variable " + variable.id_variable + " (" + variable.nombre_variable + ") Conflicto de ambiguedad \n\tReglas con conflicto : ";
for (int q = 0; q < info.reglas_en_conflicto.Count; q++)
{
if (q != 0)
{
error += "|";
}
error += info.reglas_en_conflicto[q];
}
error += "\n\t reglas relacionadas : ";
for (int q = 0; q < info.reglas_relacionadas.Count; q++)
{
if (q != 0)
{
error += "|";
}
error += info.reglas_relacionadas[q];
}
errores_comprobacion.Add(error);
}
}
return(errores_comprobacion);
}
/// <summary>
/// Crea un Hecho a partir de su representación en el modelo de instancia
/// </summary>
/// <param name="instanciaDb"></param>
/// <param name="hechoDto"></param>
/// <param name="listaTiposDato"></param>
/// <returns></returns>
public static Hecho CrearHechoDb(DocumentoInstancia instanciaDb, HechoDto hechoDto, List <TipoDato> listaTiposDato, DocumentoInstanciaXbrlDto documentoInstancia)
{
var hechoDb = new Hecho
{
IdConcepto = hechoDto.IdConcepto,
Concepto = hechoDto.NombreConcepto,
EspacioNombres = hechoDto.EspacioNombres,
IdRef = hechoDto.Id,
EsTupla = hechoDto.EsTupla,
IdInterno = hechoDto.Consecutivo
};
//Si el hecho DTO no tiene espacio de nombres y concepto, entonces intentar buscarlo de la taxonomía:
var tipoDatoXbrl = hechoDto.TipoDatoXbrl;
var tipoDato = hechoDto.TipoDato;
if ((String.IsNullOrEmpty(hechoDto.NombreConcepto) || String.IsNullOrEmpty(hechoDto.EspacioNombres)) && documentoInstancia.Taxonomia != null)
{
if (documentoInstancia.Taxonomia.ConceptosPorId.ContainsKey(hechoDto.IdConcepto))
{
hechoDb.Concepto = documentoInstancia.Taxonomia.ConceptosPorId[hechoDto.IdConcepto].Nombre;
hechoDb.EspacioNombres = documentoInstancia.Taxonomia.ConceptosPorId[hechoDto.IdConcepto].EspacioNombres;
if (String.IsNullOrEmpty(tipoDatoXbrl) || String.IsNullOrEmpty(tipoDato))
{
tipoDatoXbrl = documentoInstancia.Taxonomia.ConceptosPorId[hechoDto.IdConcepto].TipoDatoXbrl;
tipoDato = documentoInstancia.Taxonomia.ConceptosPorId[hechoDto.IdConcepto].TipoDato;
}
}
else
{
return(null);
}
}
if ((String.IsNullOrWhiteSpace(tipoDatoXbrl) || String.IsNullOrWhiteSpace(tipoDato)) && documentoInstancia.Taxonomia != null)
{
if (documentoInstancia.Taxonomia.ConceptosPorId.ContainsKey(hechoDto.IdConcepto))
{
tipoDatoXbrl = documentoInstancia.Taxonomia.ConceptosPorId[hechoDto.IdConcepto].TipoDatoXbrl;
tipoDato = documentoInstancia.Taxonomia.ConceptosPorId[hechoDto.IdConcepto].TipoDato;
}
}
if (hechoDto.TuplaPadre != null)
{
hechoDb.IdInternoTuplaPadre = hechoDto.TuplaPadre.Consecutivo;
}
if (!hechoDto.EsTupla)
{
hechoDb.Valor = hechoDto.Valor;
if (hechoDto.EsFraccion)
{
//TODO: agregar 2 campos mas a la tabla
}
//Buscar el contexto
var ctxDb = instanciaDb.Contexto.FirstOrDefault(x => x.Nombre.Equals(hechoDto.IdContexto));
if (ctxDb != null)
{
hechoDb.IdContexto = ctxDb.IdContexto;
}
//Buscar unidad
var unidadDb = instanciaDb.Unidad.FirstOrDefault(x => x.IdRef.Equals(hechoDto.IdUnidad));
if (unidadDb != null)
{
hechoDb.IdUnidad = unidadDb.IdUnidad;
}
if (!hechoDto.DecimalesEstablecidos && !hechoDto.PrecisionEstablecida)
{
hechoDto.Decimales = ConstantesGenerales.VALOR_DECIMALES_DEFAULT;
}
if (hechoDto.DecimalesEstablecidos)
{
hechoDb.Precision = null;
hechoDb.Decimales = hechoDto.Decimales;
}
if (hechoDto.PrecisionEstablecida)
{
hechoDb.Decimales = null;
hechoDb.Precision = hechoDto.Precision;
}
//Buscar el tipo de dato
var tipoDatoCatalogo = listaTiposDato.FirstOrDefault(x => x.Nombre.Equals(tipoDato));
if (tipoDatoCatalogo != null)
{
hechoDb.IdTipoDato = tipoDatoCatalogo.IdTipoDato;
}
else
{
tipoDatoCatalogo = listaTiposDato.FirstOrDefault(x => x.Nombre.Equals(tipoDatoXbrl));
if (tipoDatoCatalogo != null)
{
hechoDb.IdTipoDato = tipoDatoCatalogo.IdTipoDato;
}
}
}
hechoDb.IdDocumentoInstancia = instanciaDb.IdDocumentoInstancia;
return(hechoDb);
}
public ResultadoOperacionDto GenerarFichaAdministrativaEmisora(IDictionary <string, string> parametrosReporte)
{
ResultadoOperacionDto resultado = new ResultadoOperacionDto();
parametrosReporte.TryGetValue("ticker", out var claveCotizacion);
parametrosReporte.TryGetValue("anio", out var anio);
var taxonomia = taxonomiaAnexoN;
if (claveCotizacion != null && anio != null)
{
var parametros = "{ 'Entidad.Nombre': '" + claveCotizacion + "'," +
"'Periodo.Ejercicio': " + anio + "," +
"Taxonomia: '" + taxonomia + "'," +
"EsVersionActual: true }";
List <Envio> envios = AbaxXBRLCellStoreMongo.ConsultaElementos <Envio>("Envio", parametros).ToList();
Envio envio = null;
if (envios.Count > 0)
{
envio = envios.ElementAt(0);
}
List <Hecho> hechosAProcesar = new List <Hecho>();
if (envio != null)
{
parametros = "{IdEnvio: '" + envio.IdEnvio + "', 'Concepto.IdConcepto': {$in : [" + conceptos + "] }}";
hechosAProcesar = AbaxXBRLCellStoreMongo.ConsultaElementos <Hecho>("Hecho", parametros).ToList();
}
Hecho tipoInstrumento = hechosAProcesar.Find(hecho => hecho.Concepto.IdConcepto.Equals("ar_pros_TypeOfInstrument"));
List <AdministradorDTO> listaHechosConsejoAdministracion = ObtenerListadoHechosPorComite(hechosAProcesar, null);
List <AdministradorDTO> listaHechosComiteAuditoria = ObtenerListadoHechosPorComite(hechosAProcesar, "ar_pros_AdministratorParticipateInCommitteesAudit");
List <AdministradorDTO> listaHechosComitePracticasSocietarias = ObtenerListadoHechosPorComite(hechosAProcesar, "ar_pros_AdministratorParticipateInCommitteesCorporatePractices");
List <String[]> accionistas = ObtenerAccionistas(hechosAProcesar);
List <String[]> principalesFuncionarios = ObtenerPrincipalesFuncionarios(hechosAProcesar);
XSSFWorkbook workBookExportar = new XSSFWorkbook();
var hoja = workBookExportar.CreateSheet("Ficha Emisora");
hoja.DisplayGridlines = false;
var denominacion = hechosAProcesar.Find(hecho => hecho.Concepto.IdConcepto.Equals("ar_pros_NameOfTheIssuer")) != null?ReporteUtil.removeTextHTML(hechosAProcesar.Find(hecho => hecho.Concepto.IdConcepto.Equals("ar_pros_NameOfTheIssuer")).Valor) : "";
EscribirSeccionDatosGenerales(hoja, null, claveCotizacion, denominacion, (tipoInstrumento != null ? tipoInstrumento.Valor: ""));
EscribirSeccionConsejoAdministracion(hoja, listaHechosConsejoAdministracion);
EscribirSeccionPrincipalesFuncionarios(hoja, principalesFuncionarios);
EscribirSeccionAccionistas(hoja, accionistas);
EscribirSeccionComiteAuditoria(hoja, listaHechosComiteAuditoria);
EscribirSeccionComitePracticasSocietarias(hoja, listaHechosComitePracticasSocietarias);
var memoryStreamNew = new MemoryStream();
var currentCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
workBookExportar.Write(memoryStreamNew);
Thread.CurrentThread.CurrentCulture = currentCulture;
resultado.InformacionExtra = memoryStreamNew.ToArray();
resultado.Resultado = true;
}
else
{
resultado.Resultado = false;
resultado.Mensaje = "No se localizó ningún envío de la emisora:" + claveCotizacion + " para el año:" + anio;
}
return(resultado);
}