public static String obtenerIdPrefijoDeTaxonomia(DocumentoInstanciaXbrlDto instancia)
{
if (instancia != null && instancia.DtsDocumentoInstancia != null &&
instancia.DtsDocumentoInstancia.Count() > 0)
{
DtsDocumentoInstanciaDto dts = instancia.DtsDocumentoInstancia[0];
if (dts.HRef != null)
{
if (dts.HRef.Contains(ReportConstants.CCD_ENTRY_POINT))
{
return(ReportConstants.PREFIJO_ID_CCD);
}
else if (dts.HRef.Contains(ReportConstants.DEUDA_ENTRY_POINT))
{
return(ReportConstants.PREFIJO_ID_DEUDA);
}
else if (dts.HRef.Contains(ReportConstants.TRAC_ENTRY_POINT))
{
return(ReportConstants.PREFIJO_ID_TRAC);
}
else if (dts.HRef.Contains(ReportConstants.IIFC_ENTRY_POINT))
{
return(ReportConstants.PREFIJO_ID_IIFC);
}
else if (dts.HRef.Contains(ReportConstants.ANNEXT_ENTRY_POINT))
{
return(ReportConstants.PREFIJO_ANNEXT);
}
else if (dts.HRef.Contains(ReportConstants.N_ENTRY_POINT) || dts.HRef.Contains(ReportConstants.NBIS_ENTRY_POINT) ||
dts.HRef.Contains(ReportConstants.NBIS1_ENTRY_POINT) || dts.HRef.Contains(ReportConstants.NBIS2_ENTRY_POINT) ||
dts.HRef.Contains(ReportConstants.NBIS3_ENTRY_POINT) || dts.HRef.Contains(ReportConstants.NBIS4_ENTRY_POINT) ||
dts.HRef.Contains(ReportConstants.NBIS5_ENTRY_POINT) || dts.HRef.Contains(ReportConstants.O_ENTRY_POINT) ||
dts.HRef.Contains(ReportConstants.H_ENTRY_POINT) || dts.HRef.Contains(ReportConstants.HBIS_ENTRY_POINT) ||
dts.HRef.Contains(ReportConstants.HBIS1_ENTRY_POINT) || dts.HRef.Contains(ReportConstants.HBIS2_ENTRY_POINT) ||
dts.HRef.Contains(ReportConstants.HBIS3_ENTRY_POINT) || dts.HRef.Contains(ReportConstants.HBIS4_ENTRY_POINT) ||
dts.HRef.Contains(ReportConstants.HBIS5_ENTRY_POINT) || dts.HRef.Contains(ReportConstants.L_ENTRY_POINT) ||
dts.HRef.Contains(ReportConstants.I_ENTRY_POINT))
{
return(ReportConstants.PREFIJO_AR_PROS);
}
else if (dts.HRef.Contains(ReportConstants.IIFC_ENTRY_POINT))
{
return(ReportConstants.PREFIJO_ID_IIFC);
}
else if (dts.HRef.Contains(ReportConstants.REL_EV_EMISORAS))
{
return(ReportConstants.PREFIJO_REL_EV_EMISORAS);
}
}
}
return(null);
}
/// <summary>
/// Convierte los registros de DTS Documento instancia de la base de datos a su representación en DTO
/// </summary>
/// <param name="instanciaDb"></param>
/// <param name="instanciaXbrlDto"></param>
private static void CargarDts(DocumentoInstancia instanciaDb, DocumentoInstanciaXbrlDto instanciaXbrlDto)
{
foreach (var dtsDb in instanciaDb.DtsDocumentoInstancia)
{
var dtsDto = new DtsDocumentoInstanciaDto();
dtsDto.Tipo = dtsDb.TipoReferencia;
dtsDto.HRef = dtsDb.Href;
dtsDto.Role = dtsDb.Rol;
dtsDto.RoleUri = dtsDb.RolUri;
instanciaXbrlDto.DtsDocumentoInstancia.Add(dtsDto);
}
}
/// <summary>
/// Busca la secuencia correspondiente a un hecho que corresponde a la descripción del pasivo y cuyo
/// valor es igual al nombre de pasivo enviado como parámetro
/// </summary>
/// <param name="hechosDeTipoPasivo"> Conjunto de hechos a buscar</param>
/// <param name="nombrePasivo">Valor buscado</param>
/// <returns></returns>
private string BuscarSecuenciaDePasivo(DocumentoInstanciaXbrlDto instancia, IList <HechoDto> hechosDeTipoPasivo, string nombrePasivo)
{
if (hechosDeTipoPasivo != null)
{
var hecho = hechosDeTipoPasivo.Where(x => _elementosDescripcionPasivo.Contains(x.IdConcepto)).Where(x => x.Valor == nombrePasivo).FirstOrDefault();
if (hecho != null)
{
return(ObtenerSecuenciaDeContexto(instancia.ContextosPorId[hecho.IdContexto], _idDimensionSecuencia));
}
}
return(null);
}
/// <summary>
/// Crea un nuevo hecho.
/// </summary>
/// <param name="valor">Valor del hecho.</param>
/// <param name="concepto">Concepto del hecho.</param>
/// <param name="contexto">Contexto del hecho.</param>
/// <param name="idUnidad">Identificador de la unidad.</param>
/// <param name="instancia">Documento de instancia.</param>
/// <param name="plantilla">Plantilla del documento.</param>
/// <param name="resumenImportacion">Detalle de la importación.</param>
/// <param name="nombreHoja">Nombre de la hoja.</param>
/// <param name="numeroFila">Indice de la fila.</param>
/// <param name="numeroColumna">Indice de la columna.</param>
private void CreaHecho(
String valor,
ConceptoDto concepto,
Dto.ContextoDto contexto,
String idUnidad,
DocumentoInstanciaXbrlDto instancia,
IDefinicionPlantillaXbrl plantilla,
ResumenProcesoImportacionExcelDto resumenImportacion,
String nombreHoja,
int numeroFila,
int numeroColumna)
{
var idHecho = "A" + Guid.NewGuid().ToString();
var hechoNuevo = instancia.CrearHecho(concepto.Id, idUnidad, contexto.Id, idHecho);
if (concepto.EsTipoDatoNumerico)
{
if (concepto.TipoDatoXbrl.Contains(TiposDatoXBRL.MonetaryItemType))
{
hechoNuevo.Decimales = "-3";
}
else
{
hechoNuevo.Decimales = "0";
}
}
if (!ActualizarValor(concepto, valor, hechoNuevo, plantilla))
{
resumenImportacion.AgregarErrorFormato(
UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, concepto.Id),
nombreHoja,
numeroFila.ToString(),
numeroColumna.ToString(),
valor);
}
else
{
resumenImportacion.TotalHechosImportados++;
var hechoImportado = new AbaxXBRLCore.Common.Dtos.InformacionHechoImportadoExcelDto()
{
IdConcepto = hechoNuevo.IdConcepto,
IdHecho = hechoNuevo.Id,
ValorImportado = valor,
HojaExcel = nombreHoja,
Renglon = numeroFila,
Columna = numeroColumna
};
resumenImportacion.AgregarHechoImportado(hechoImportado, UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, hechoNuevo.Id));
}
plantilla.InyectaHechoADocumentoInstancia(hechoNuevo);
}
/// <summary>
/// Procesa el documento de instancia que se encuentra dentro del archivo ZIP enviado como parámetro
/// </summary>
/// <param name="archivo"></param>
/// <param name="resultadoValidacion"></param>
/// <returns></returns>
private void ProcesarArchivoZip(String rutaAbsolutaArchivo, ResultadoValidacionDocumentoXBRLDto resultadoValidacion, IDictionary <string, string> parametros)
{
DocumentoInstanciaXbrlDto documentoXbrl = null;
string archivoXbrl = null;
DirectoryInfo tmpDir = null;
try
{
using (var zipFile = ZipFile.Read(rutaAbsolutaArchivo))
{
tmpDir = UtilAbax.ObtenerDirectorioTemporal();
zipFile.ExtractAll(tmpDir.FullName, ExtractExistingFileAction.OverwriteSilently);
if (zipFile.Count == 1)
{
foreach (var archivoInterno in zipFile)
{
if (!archivoInterno.IsDirectory &&
archivoInterno.FileName.ToLower().EndsWith(CommonConstants.ExtensionXBRL))
{
archivoXbrl = archivoInterno.FileName;
}
}
}
if (archivoXbrl == null)
{
AgregarErrorFatal(resultadoValidacion, null, null, null, "Debe existir un archivo dentro del archivo ZIP y debe tener la extensión XBRL");
}
}
}
catch (Exception ex)
{
LogUtil.Error(ex);
AgregarErrorFatal(resultadoValidacion, null, null, null, "Ocurrió un error al leer el archivo ZIP: " + ex.Message);
}
if (archivoXbrl != null)
{
try
{
var uriArchivo = new Uri(tmpDir.FullName + Path.DirectorySeparatorChar + archivoXbrl, UriKind.Absolute);
ProcesarArchivoXBRL(uriArchivo.AbsolutePath, resultadoValidacion, parametros);
}
catch (Exception ex)
{
LogUtil.Error(ex);
AgregarErrorFatal(resultadoValidacion, null, null, null, "Ocurrió un error al leer el archivo XBRL: " + ex.Message);
}
finally
{
documentoXbrl = null;
}
}
}
/// <summary>
/// Exportador a Word.
/// </summary>
/// <param name="docBuilder">Constructor del documento.</param>
/// <param name="instancia">DTO con la información de la instancia XBRL</param>
/// <param name="rolAExportar">DTO con la información del rol a exportar.</param>
/// <param name="estructuraReporte"></param>
public override void exportarRolAWord(DocumentBuilder docBuilder, DocumentoInstanciaXbrlDto instancia, IndiceReporteDTO rolAExportar, ReporteXBRLDTO estructuraReporte)
{
estructuraReporte.AgregarSignoAMonetarios = true;
InicializaConfiguracionPaginaDefault(docBuilder);
AgregarTituloPortada(docBuilder, rolAExportar);
InsertarLeyendaProspectoDefinitivo(docBuilder, instancia, estructuraReporte);
IsertaLogotipoDeEmisora(docBuilder, instancia, estructuraReporte);
ImprimirContenidoRol(docBuilder, instancia, rolAExportar, estructuraReporte);
ImprimirFirmasArt13(docBuilder, instancia);
imprimirIndice(docBuilder, BreakType.SectionBreakNewPage);
ImprimirConceptosDespuesIndice(docBuilder, instancia, rolAExportar, estructuraReporte);
escribirEncabezado(docBuilder, instancia, estructuraReporte, true);
}
/// <summary>
/// Pinta todas las filas de la tabla de hechos.
/// </summary>
/// <param name="instancia">Documento de instancia donde se obtiene la información.</param>
/// <param name="listacontextos">Lista con los contextos a presentar.</param>
/// <param name="diccionarioHechos">Diccionario con los hechos a presentar.</param>
/// <param name="docBuilder">Constructor del documento.</param>
/// <param name="exportadorBase">Exportador original del reporte.</param>
/// <param name="estructuraReporte">Dto con datos auxiliares para la presentación del documento.</param>
public void PintaFilasHechos(
DocumentoInstanciaXbrlDto instancia,
IList <ContextoDto> listacontextos,
IDictionary <string, IDictionary <string, HechoDto> > diccionarioHechos,
DocumentBuilder docBuilder,
ExportadorRolDocumentoBase exportadorBase,
ReporteXBRLDTO estructuraReporte)
{
var numeroColumnas = listacontextos.Count + 1;
foreach (var idConcepto in ConceptosTabla)
{
ConceptoDto concepto;
if (instancia.Taxonomia.ConceptosPorId.TryGetValue(idConcepto, out concepto))
{
var etiquetaConcepto =
DesgloseDeCreditosHelper
.obtenerEtiquetaDeConcepto(instancia.Taxonomia, concepto.Id, estructuraReporte.Lenguaje, ReporteXBRLUtil.ETIQUETA_DEFAULT);
if (concepto.EsAbstracto ?? false)
{
PintaFilaSubTitulo(etiquetaConcepto, docBuilder, numeroColumnas, exportadorBase);
}
else
{
if (!concepto.EsTipoDatoNumerico)
{
continue;
}
docBuilder.InsertCell();
docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;
docBuilder.Bold = true;
docBuilder.Write(etiquetaConcepto);
IDictionary <string, HechoDto> diccionarioHechosPorContexto = null;
diccionarioHechos.TryGetValue(concepto.Id, out diccionarioHechosPorContexto);
foreach (var contexto in listacontextos)
{
docBuilder.InsertCell();
docBuilder.Bold = false;
HechoDto hecho;
if (diccionarioHechosPorContexto != null && diccionarioHechosPorContexto.TryGetValue(contexto.Id, out hecho))
{
docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Right;
exportadorBase.EscribirValorHecho(docBuilder, estructuraReporte, hecho, concepto);
}
}
docBuilder.EndRow();
}
}
}
docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;
}
/// <summary>
/// Crea los datos de una unidad de base de datos en base a los datos del DTO de origen
/// </summary>
/// <param name="documentoOrigen"></param>
/// <param name="unidadDTO"></param>
/// <returns></returns>
public static Unidad CrearUnidadDb(DocumentoInstanciaXbrlDto documentoOrigen, UnidadDto unidadDTO)
{
var unidadDb = new Unidad
{
EsFraccion = unidadDTO.Tipo == Unit.Divisoria,
IdRef = unidadDTO.Id
};
if (!unidadDb.EsFraccion)
{
//Obtener la lista de medidas
string sMedidas = "";
foreach (var medidaDTO in unidadDTO.Medidas)
{
if (!String.IsNullOrEmpty(sMedidas))
{
sMedidas += ",";
}
sMedidas += medidaDTO.EspacioNombres + ":" + medidaDTO.Nombre;
}
unidadDb.Medida = sMedidas;
}
else
{
//Numerador
string sMedidas = "";
foreach (var medidaDTO in unidadDTO.MedidasNumerador)
{
if (!String.IsNullOrEmpty(sMedidas))
{
sMedidas += ",";
}
sMedidas += medidaDTO.EspacioNombres + ":" + medidaDTO.Nombre;
}
unidadDb.Numerador = sMedidas;
//Denominador
sMedidas = "";
foreach (var medidaDTO in unidadDTO.MedidasDenominador)
{
if (!String.IsNullOrEmpty(sMedidas))
{
sMedidas += ",";
}
sMedidas += medidaDTO.EspacioNombres + ":" + medidaDTO.Nombre;
}
unidadDb.Denominador = sMedidas;
}
return(unidadDb);
}
///
/// (non-Javadoc)
/// @see com.bmv.spread.xbrl.reportes.builder.ReporteBuilder#obtenerValoresIniciales(com.hh.xbrl.abax.viewer.application.dto.DocumentoInstanciaXbrlDto)
////
public override void obtenerValoresIniciales(DocumentoInstanciaXbrlDto instancia)
{
String nombreReporte = ReporteXBRLUtil.NOMBRE_REPORTE_FIDU;
String claveCotizacion = ReporteXBRLUtil.obtenerValorHecho(reporteXBRLDTO.PrefijoTaxonomia + ReportConstants.NOMBRE_CONCEPTO_EMISORA, instancia);
String fechaReporte = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.ID_FECHA_CIERRE_REPORTE_2014, instancia);
String anio = fechaReporte.Substring(0, fechaReporte.IndexOf("-"));
String trimestre = ReporteXBRLUtil.obtenerValorHecho(reporteXBRLDTO.PrefijoTaxonomia + ReportConstants.NOMBRE_CONCEPTO_NUMERO_TRIMESTRE, instancia);
String moneda = ReporteXBRLUtil.obtenerValorMoneda(instancia);
Boolean consolidado = false;
String fideicomiso = ReporteXBRLUtil.obtenerValorHecho(reporteXBRLDTO.PrefijoTaxonomia + ReportConstants.NOMBRE_CONCEPTO_NUMERO_FIDEICOMISO, instancia);
String fechaCreacion = DateTime.Now.ToString(ReporteXBRLUtil.FORMATO_FECHA_CREACION);
if (reporteXBRLDTO.Taxonomia.Equals(ReportConstants.CLAVE_CCD))
{
consolidado = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.NOMBRE_CONCEPTO_CCD_CONSOLIDADO, instancia).ToUpper().Trim().Equals(ReportConstants.VALOR_SI) ||
ReporteXBRLUtil.obtenerValorHecho(ReportConstants.NOMBRE_CONCEPTO_CCD_CONSOLIDADO, instancia).ToLower().Trim().Equals(ReportConstants.VALOR_SI_TRUE) ||
ReporteXBRLUtil.obtenerValorHecho(ReportConstants.NOMBRE_CONCEPTO_CCD_CONSOLIDADO, instancia).ToLower().Trim().Equals(ReportConstants.VALOR_SI_2) ? true : false;
reporteXBRLDTO.AplicaConsolidado = true;
}
else
{
reporteXBRLDTO.AplicaConsolidado = false;
}
reporteXBRLDTO.ClaveCotizacion = claveCotizacion;
reporteXBRLDTO.FechaReporte = fechaReporte;
reporteXBRLDTO.RazonSocial = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.ID_NOMBRE_RAZON_SOCIAL, instancia);
reporteXBRLDTO.Anio = anio;
reporteXBRLDTO.Trimestre = trimestre;
reporteXBRLDTO.Moneda = moneda;
reporteXBRLDTO.Consolidado = consolidado;
reporteXBRLDTO.Fideicomiso = fideicomiso;
reporteXBRLDTO.FechaCreacion = fechaCreacion;
if (claveCotizacion != null && fechaReporte != null && trimestre != null && moneda != null && consolidado != null)
{
nombreReporte = nombreReporte.
Replace(ReporteXBRLUtil.CLAVE_COTIZACION, claveCotizacion).
Replace(ReporteXBRLUtil.ANIO, anio).
Replace(ReporteXBRLUtil.TRIMESTRE, trimestre).
Replace(ReporteXBRLUtil.MONEDA, moneda).
Replace(ReporteXBRLUtil.CONSOLIDACION, (consolidado ? ReporteXBRLUtil.CONSOLIDADO : ReporteXBRLUtil.NO_CONSOLIDADO)).
Replace(ReporteXBRLUtil.FIDEICOMISO, fideicomiso).
Replace(ReporteXBRLUtil.FECHA_CREACION, fechaCreacion);
reporteXBRLDTO.NombreReporte = nombreReporte;
}
}
override public void exportarRolAWord(DocumentBuilder docBuilder, DocumentoInstanciaXbrlDto instancia, IndiceReporteDTO rolAExportar, ReporteXBRLDTO estructuraReporte)
{
docBuilder.CurrentSection.PageSetup.Orientation = Orientation.Portrait;
docBuilder.CurrentSection.PageSetup.PaperSize = PaperSize.Letter;
docBuilder.CurrentSection.PageSetup.LeftMargin = 40;
docBuilder.CurrentSection.PageSetup.RightMargin = 40;
escribirEncabezado(docBuilder, instancia, estructuraReporte, true);
imprimirTituloRol(docBuilder, rolAExportar);
var listaConseptosReporte = estructuraReporte.Roles[rolAExportar.Rol];
PintaTabla(docBuilder, instancia, rolAExportar, estructuraReporte, listaConseptosReporte);
}
/// <summary>
/// Gets the member value.
/// </summary>
/// <param name="dimension">Dimension to evaluate.</param>
/// <param name="document">Document owner of the dimension.</param>
/// <returns>Member value.</returns>
private static String GetDimensionMember(DimensionInfoDto dimension, DocumentoInstanciaXbrlDto document)
{
var member = String.Empty;
if (dimension.Explicita)
{
member = dimension.IdItemMiembro;
}
else
{
member = CellStoreUtil.EliminaEtiquetas(dimension.ElementoMiembroTipificado);
}
return(member);
}
/// <summary>
/// Crea el conetenido para el rol indicado.
/// </summary>
/// <param name="docBuilder">Constructor del docuemnto.</param>
/// <param name="instancia">Instancia XBRL con la información a pintar.</param>
/// <param name="rolAExportar">Rol que se pinta.</param>
/// <param name="estructuraReporte">DTO con información general del reporte.</param>
public void ImprimirContenidoRol(
DocumentBuilder docBuilder,
DocumentoInstanciaXbrlDto instancia,
IndiceReporteDTO rolAExportar,
ReporteXBRLDTO estructuraReporte)
{
var posicionActual = 1;
IList <String> listaIdConceptoPosicion;
foreach (ConceptoReporteDTO concepto in estructuraReporte.Roles[rolAExportar.Rol])
{
EscribeConcepto(concepto, docBuilder, estructuraReporte);
}
}
/// <summary>
/// Gets the first element of the concepts in the list.
/// </summary>
/// <param name="conceptsIdsList"></param>
/// <param name="document"></param>
/// <returns></returns>
public static HechoDto GetFirstFact(IList <String> conceptsIdsList, DocumentoInstanciaXbrlDto document)
{
HechoDto fact = null;
foreach (var concetptId in conceptsIdsList)
{
fact = GetFirstFactOfConcept(concetptId, document);
if (fact != null)
{
break;
}
}
return(fact);
}
/// <summary>
/// Genera los hechos de la fila indicada.
/// </summary>
/// <param name="fila">Fila que se pretende evaluar.</param>
/// <param name="concepto">Concepto que se pretende evaluar.</param>
/// <param name="diccionarioContextos">Diccionario de contextos.</param>
/// <param name="instancia">Documento de instancia.</param>
/// <param name="plantilla">Plantilla de documento.</param>
/// <param name="resumenImportacion">Resume de importación.</param>
/// <param name="nombreHoja">Nombre de la hoja.</param>
public void GeneraHechos(
IRow fila,
ConceptoDto concepto,
IDictionary <int, Dto.ContextoDto> diccionarioContextos,
DocumentoInstanciaXbrlDto instancia,
IDefinicionPlantillaXbrl plantilla,
ResumenProcesoImportacionExcelDto resumenImportacion,
String nombreHoja)
{
UnidadDto unidad = ObtenUniadConcepto(concepto, instancia, plantilla);
var idUnidad = unidad == null ? null : unidad.Id;
foreach (var indexColumna in diccionarioContextos.Keys)
{
ICell celda = null;
try
{
celda = fila.GetCell(indexColumna);
String valorHecho = String.Empty;
if (celda != null && !celda.CellType.Equals(CellType.Blank))
{
valorHecho = ExcelUtil.ObtenerValorCelda(celda.CellType, celda);
}
var contexto = diccionarioContextos[indexColumna];
CreaHecho(
valorHecho,
concepto,
contexto,
idUnidad,
instancia,
plantilla,
resumenImportacion,
nombreHoja,
fila.RowNum,
celda.ColumnIndex);
}
catch (Exception ex)
{
LogUtil.Error(ex);
var columnaCelda = (celda == null ? 0 : celda.ColumnIndex);
resumenImportacion.InformeErrores.Add(new InformeErrorImportacion()
{
Mensaje = "Error al obtener el valor de la celda en la fila \"" + fila.RowNum +
"\" columna \"" + columnaCelda +
"\" de la hoja \"" + nombreHoja +
"\".(" + ex.Message + ")"
});
}
}
}
/// <summary>
/// Actualiza o crea un hecho en base a los criterios enviados como parámetro
/// </summary>
/// <param name="instancia">Documento instnacia actual</param>
/// <param name="idConcepto">Concepto actual</param>
/// <param name="hojaAImportar">Hoja actualmente procesada</param>
/// <param name="renglonActual">Renglón actualmente procesado</param>
/// <param name="numColumna">Columna actualmente procesada</param>
/// <param name="contextoDestino">Contexto a donde se asignarán los hechos creados</param>
private void ActualizarValorHecho(DocumentoInstanciaXbrlDto instancia, string idConcepto, ISheet hojaAImportar, int renglonActual, int numColumna,
AbaxXBRLCore.Viewer.Application.Dto.ContextoDto contextoDestino, IDefinicionPlantillaXbrl plantillaDocumento, AbaxXBRLCore.Common.Dtos.ResumenProcesoImportacionExcelDto resumenImportacion)
{
var valorCelda = ExcelUtil.ObtenerValorCelda(hojaAImportar, renglonActual, numColumna);
var fechaDefault = plantillaDocumento.ObtenerVariablePorId("fecha_2016_10_12");
if (!String.IsNullOrEmpty(valorCelda))
{
ConceptoDto conceptoImportado = instancia.Taxonomia.ConceptosPorId[idConcepto];
HechoDto hechoActualizar = null;
var hechos = instancia.BuscarHechos(idConcepto, null, null, contextoDestino.Periodo.FechaInstante, contextoDestino.Periodo.FechaInstante, null, false);
if (hechos.Count > 0)
{
hechoActualizar = hechos[0];
}
else
{
hechoActualizar = instancia.CrearHecho(idConcepto, null, contextoDestino.Id, "A" + Guid.NewGuid().ToString());
plantillaDocumento.InyectaHechoADocumentoInstancia(hechoActualizar);
}
if (!UtilAbax.ActualizarValorHecho(conceptoImportado, hechoActualizar, valorCelda, fechaDefault))
{
resumenImportacion.AgregarErrorFormato(
UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, conceptoImportado.Id),
hojaAImportar.SheetName,
renglonActual.ToString(),
numColumna.ToString(),
valorCelda);
}
else
{
resumenImportacion.TotalHechosImportados++;
var hechoImportado = new AbaxXBRLCore.Common.Dtos.InformacionHechoImportadoExcelDto()
{
IdConcepto = hechoActualizar.IdConcepto,
IdHecho = hechoActualizar.Id,
ValorImportado = valorCelda,
HojaExcel = hojaAImportar.SheetName,
Renglon = renglonActual,
Columna = numColumna
};
resumenImportacion.AgregarHechoImportado(hechoImportado, UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, conceptoImportado.Id));
}
}
}
/// <summary>
/// Crea el hint en MongoDB de empresas
/// </summary>
/// <param name="documentoInstanciXbrlDto">Informacion del documento Instancia</param>
private void CrearHintEmpresas(DocumentoInstanciaXbrlDto documentoInstanciXbrlDto)
{
foreach (var IdEntidad in documentoInstanciXbrlDto.EntidadesPorId)
{
var Entidad = IdEntidad.Value;
var query = Query.EQ("IdEntidad", Entidad.IdEntidad);
var resultado = BlockStoreConsulta.consulta(CollectionEmpresas, query);
if (resultado.Count == 0)
{
BlockStoreDocumentoInstancia.insertarBlockStore(CollectionEmpresas, BlockStoreConsulta.armarBlockStoreEntidad(Entidad));
}
}
}
/// <summary>
/// Genera nombre legible de contexto
/// </summary>
/// <param name="ctxNuevo">Contexto origen</param>
/// <returns>Nombre propuesto</returns>
private static string ProponerNombreContexto(ContextoDto ctxNuevo, DocumentoInstanciaXbrlDto instancia)
{
StringBuilder sb = new StringBuilder();
sb.Append("ctx");
//tipo de periodo - fechas
if (ctxNuevo.Periodo.Tipo == PeriodoDto.ParaSiempre)
{
sb.Append("_porSiempre");
}
else if (ctxNuevo.Periodo.Tipo == PeriodoDto.Duracion)
{
sb.Append("_" + XmlUtil.ToUnionDateTimeString(ctxNuevo.Periodo.FechaInicio) + "_" + XmlUtil.ToUnionDateTimeString(ctxNuevo.Periodo.FechaFin));
}
else
{
sb.Append("_" + XmlUtil.ToUnionDateTimeString(ctxNuevo.Periodo.FechaInstante));
}
//Dimensiones
var dimTotales = new List <DimensionInfoDto>();
if (ctxNuevo.ValoresDimension != null)
{
dimTotales.AddRange(ctxNuevo.ValoresDimension);
}
if (ctxNuevo.Entidad.ValoresDimension != null)
{
dimTotales.AddRange(ctxNuevo.Entidad.ValoresDimension);
}
foreach (var dimension in dimTotales)
{
if (dimension.Explicita)
{
sb.Append("_" + instancia.Taxonomia.ConceptosPorId[dimension.IdItemMiembro].Nombre);
}
else
{
if (String.IsNullOrEmpty(dimension.ElementoMiembroTipificado))
{
sb.Append("_" + instancia.Taxonomia.ConceptosPorId[dimension.IdDimension].Nombre);
}
else
{
sb.Append("_" + ReporteXBRLUtil.eliminaEtiquetas(dimension.ElementoMiembroTipificado));
}
}
}
return(sb.ToString());
}
/// <summary>
/// Genera un contexto con la información definida en la plantilla.
/// </summary>
/// <param name="instancia">Documento de instancia.</param>
/// <param name="definicionPlantilla">Plantilla donde se obtendran las variables para la generación del contexto.</param>
/// <param name="listaDimensiones">Lista de dimensiones que se aplican al contexto.</param>
/// <returns></returns>
public ContextoDto GeneraContexto(DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl definicionPlantilla, IList <DimensionInfoDto> listaDimensiones = null)
{
var periodo = this.Periodo.GeneraPeriodo(definicionPlantilla);
var entidadAuxiliar = instancia.EntidadesPorId.Values.First();
var entidad = new EntidadDto()
{
ContieneInformacionDimensional = false,
EsquemaId = entidadAuxiliar.EsquemaId,
Id = entidadAuxiliar.Id,
};
var diccionarioMiembrosdimensio = new Dictionary <String, DimensionInfoDto>();
if (listaDimensiones != null)
{
foreach (var itemDimension in listaDimensiones)
{
if (!diccionarioMiembrosdimensio.ContainsKey(itemDimension.IdDimension))
{
diccionarioMiembrosdimensio.Add(itemDimension.IdDimension, itemDimension);
}
}
}
if (ValoresDimension != null)
{
foreach (var valorDimension in ValoresDimension)
{
if (!diccionarioMiembrosdimensio.ContainsKey(valorDimension.IdDimension))
{
diccionarioMiembrosdimensio.Add(valorDimension.IdDimension, valorDimension);
}
}
}
var dimensiones = new List <DimensionInfoDto>();
foreach (var miembro in diccionarioMiembrosdimensio.Values)
{
dimensiones.Add(miembro);
}
var contexto = new ContextoDto()
{
Id = "C" + Guid.NewGuid().ToString(),
Periodo = periodo,
Entidad = entidad,
ContieneInformacionDimensional = this.ContieneInformacionDimensional,
ValoresDimension = dimensiones
};
return(contexto);
}
/// <summary>
/// Obtiene los miembros dimensionales del contexto del hecho indicado según su tipo.
/// </summary>
/// <param name="hecho">Hecho a evaluar</param>
/// <param name="instancia">Instancia a evaluar.</param>
/// <param name="explicita">Si buscará dimensiones explicitas o implicitas.</param>
/// <returns>Miembros dimensionales del tipo indicado.</returns>
public IList <DimensionInfoDto> ObtenDimensionesTipo(HechoDto hecho, DocumentoInstanciaXbrlDto instancia, bool explicita)
{
var contexto = instancia.ContextosPorId[hecho.IdContexto];
var idsDimensiones = new List <DimensionInfoDto>();
for (var indexMiembro = 0; indexMiembro < contexto.ValoresDimension.Count; indexMiembro++)
{
var miembro = contexto.ValoresDimension[indexMiembro];
if (miembro.Explicita.Equals(explicita))
{
idsDimensiones.Add(miembro);
}
}
return(idsDimensiones);
}
/// <summary>
/// Muestra el documento del articulo 13
/// </summary>
/// <param name="docBuilder">Constructor del documento.</param>
/// <param name="instancia">Documento de instacia</param>
private void ImprimirFirmasArt13(DocumentBuilder docBuilder, DocumentoInstanciaXbrlDto instancia)
{
IList <String> listaIdHechoFirmaLeyenda13 = null;
if (instancia.HechosPorIdConcepto.TryGetValue("ar_pros_IssuanceUnderArt13OfTheCUELegendPDF", out listaIdHechoFirmaLeyenda13) &&
listaIdHechoFirmaLeyenda13.Count() > 0)
{
var idHechoFirmas = listaIdHechoFirmaLeyenda13.First();
HechoDto hechoFirmas = null;
if (instancia.HechosPorId.TryGetValue(idHechoFirmas, out hechoFirmas))
{
AgregaImagenFirmas(docBuilder, hechoFirmas);
}
}
}
/// <summary>
/// Determina la fecha de colocación para los reportes de tipo prospecto.
/// </summary>
/// <param name="documentoInstancia">Documento de instancia a evaluar.</param>
/// <returns>Valor del concepto de fecha de colocación.</returns>
private string DeterminaFechaColocacion(DocumentoInstanciaXbrlDto documentoInstancia)
{
string fechaColocacion = null;
IList <string> idsConceptosFechaPublicacion;
if (documentoInstancia.HechosPorIdConcepto.TryGetValue("ar_pros_DateOfPublicationOfTenderNotice", out idsConceptosFechaPublicacion))
{
var hechoFechaColocacion = ObtenHechoMayorFechaReporte(idsConceptosFechaPublicacion, documentoInstancia);
if (hechoFechaColocacion != null)
{
fechaColocacion = hechoFechaColocacion.Valor;
}
}
return(fechaColocacion);
}
/// <summary>
/// Propone un ID de hecho en base a sus datos
/// </summary>
/// <param name="hechoNuevo"></param>
/// <param name="instancia"></param>
/// <returns></returns>
public static string CrearHechoID(HechoDto hechoNuevo, DocumentoInstanciaXbrlDto instancia)
{
var idHecho = "hecho_" + RemoveSpecialCharacters(instancia.Taxonomia.ConceptosPorId[hechoNuevo.IdConcepto].Nombre);
long idxHecho = 0;
while (instancia.HechosPorId.ContainsKey(idHecho + (idxHecho > 0?"_" + idxHecho:"")))
{
idxHecho++;
}
return(idHecho + (idxHecho > 0 ? "_" + idxHecho : ""));
}
/// <summary>
/// Concatena los archivos al final del documento.
/// </summary>
/// <param name="docBuilder">Constructor del documento.</param>
/// <param name="instancia">Documento de instancia.</param>
/// <param name="rolAExportar">Rol que se exporta</param>
/// <param name="estructuraReporte">DTO con información general del reporte.</param>
public void ConcatenaArchivosAdjuntos(
DocumentBuilder docBuilder,
DocumentoInstanciaXbrlDto instancia,
IndiceReporteDTO rolAExportar,
ReporteXBRLDTO estructuraReporte)
{
if (estructuraReporte.ArchivosAdjuntos != null)
{
foreach (var archivoAdjuntar in estructuraReporte.ArchivosAdjuntos.Values)
{
GeneraPortadaArchivoAdjunto(archivoAdjuntar, docBuilder);
AgregaImagenHechoPDF(docBuilder, archivoAdjuntar.HechoArchivo);
}
}
}
/// <summary>
/// Obtiene el primer hecho con el identificador de concepto indicado.
/// </summary>
/// <param name="instancia">Documento de instancia con la información.</param>
/// <param name="idConcepto">Identificador del concepto buscado.</param>
/// <returns>Primer hecho encontrado o null si no se encontro hecho.</returns>
public HechoDto ObtenPrimerHechoPorIdConcepto(DocumentoInstanciaXbrlDto instancia, String idConcepto)
{
HechoDto hecho = null;
IList <String> listaIdsHechosPorconcepto;
if (instancia.HechosPorIdConcepto.TryGetValue(idConcepto, out listaIdsHechosPorconcepto))
{
var idHecho = listaIdsHechosPorconcepto.FirstOrDefault();
if (!String.IsNullOrEmpty(idHecho))
{
instancia.HechosPorId.TryGetValue(idHecho, out hecho);
}
}
return(hecho);
}
/// <summary>
/// Filtra un conjunto de hechos por el contenido de un item miembro de una dimensión en específico
/// </summary>
/// <param name="instancia"></param>
/// <param name="listaHechos"></param>
/// <param name="_idDimensionIntervalo"></param>
/// <param name="p"></param>
/// <returns></returns>
private IList <HechoDto> FiltrarHechosPorDimensionYMiembro(DocumentoInstanciaXbrlDto instancia, IList <HechoDto> listaHechos, string idDimension, string idItemMiembro)
{
var hechosFinales = new List <HechoDto>();
ContextoDto contexto = null;
foreach (var hechoActual in listaHechos)
{
contexto = instancia.ContextosPorId[hechoActual.IdContexto];
if (ContieneDimension(idDimension, idItemMiembro, contexto))
{
hechosFinales.Add(hechoActual);
}
}
return(hechosFinales);
}
/// <summary>
/// Crea el DTO de entidad con los datos de origen enviados como parámetro
/// </summary>
/// <param name="documentoInstanciaXbrl">Modelo de instancia</param>
/// <param name="entidadDb">Entidad origen de BD</param>
/// <returns>Objeto entidad resultante</returns>
private static EntidadDto CrearEntidad(DocumentoInstanciaXbrlDto documentoInstanciaXbrl, Contexto ctx)
{
//Crear entidad
var entidad = new EntidadDto
{
EsquemaId = ctx.EsquemaEntidad,
Id = ctx.IdentificadorEntidad,
Segmento = ctx.Segmento
};
entidad.ValoresDimension = RecuperarValoresDimension(entidad.Segmento);
entidad.ContieneInformacionDimensional = entidad.ValoresDimension != null &&
entidad.ValoresDimension.Count > 0;
return(entidad);
}
/// <summary>
/// Obtiene y escribe el valor del primer hecho correspondiente al id de concepto enviado como parámetro
/// </summary>
/// <param name="instancia">Documento de instancia actualmente procesado</param>
/// <param name="idConcepto">Concepto a escribir</param>
private void EscribirValorPrimerHecho(DocumentoInstanciaXbrlDto instancia, string idConcepto, ISheet hojaAExportar,
int renglonDestino, int columnaDestino)
{
if (instancia.HechosPorIdConcepto.ContainsKey(idConcepto) && instancia.HechosPorIdConcepto[idConcepto].Count > 0)
{
var hecho = instancia.HechosPorId[instancia.HechosPorIdConcepto[idConcepto][0]];
if (hecho != null)
{
ExcelUtil.AsignarValorCelda(hojaAExportar, renglonDestino, columnaDestino, hecho.Valor,
instancia.Taxonomia.ConceptosPorId[idConcepto].EsTipoDatoNumerico ?
CellType.Numeric : CellType.String
, hecho);
}
}
}
/// <summary>
/// Obtiene el valor a presentar como título del concepto.
/// </summary>
/// <param name="celda">Celda que se pretende presentar.</param>
/// <param name="instancia">Documento de instancia.</param>
/// <param name="exportadorOrigen">Exportador original.</param>
/// <param name="estructuraReporte">Datos generales del reporte.</param>
/// <returns>Texto a presentar como título.</returns>
private String ObtenTextoTituloConcepto(
CeldasPresentacionHipercuboDto celda,
DocumentoInstanciaXbrlDto instancia,
ExportadorRolDocumentoBase exportadorOrigen,
ReporteXBRLDTO estructuraReporte)
{
var idConceptoTitulo = !String.IsNullOrEmpty(celda.IdConceptoTitulo) ? celda.IdConceptoTitulo : celda.IdConcepto;
var tituloConcepto = exportadorOrigen.ObtenEtiquetaConcepto(idConceptoTitulo, instancia, estructuraReporte.Lenguaje);
if (String.IsNullOrEmpty(tituloConcepto))
{
tituloConcepto = idConceptoTitulo;
}
return(tituloConcepto);
}
/// <summary>
/// Procesa un objeto "DocumentoInstanciaXbrlDto" para obtener una estructura procesada para la generacion del reporte
/// </summary>
/// <param name="documentoInstanciaXbrlDto"> Modelo DTO </param>
/// <param name="idioma">Idioma de presentación</param>
/// <param name="agruparPorUnidad">Por default es "True", permite agrupar por Moneda, si es "False" agrupa por Entidad </param>
/// <returns> Estructura con los filtros establecidos y un listado de conceptos por rol </returns>
public EstructuraReporteGenerico GeneracionReporteGenerico(DocumentoInstanciaXbrlDto documentoInstanciaXbrlDto, string idioma = "es", bool agruparPorUnidad = true)
{
EstructuraReporteGenerico estructuraReporteGenerico = new EstructuraReporteGenerico();
List <EstructuraRolReporte> estructuraReporteGenericoPorRol = new List <EstructuraRolReporte>();
foreach (RolDto <EstructuraFormatoDto> rol in documentoInstanciaXbrlDto.Taxonomia.RolesPresentacion)
{
var listaDeConceptosEnHiperCubos = ObtenerListaDeHiperCubosPorRol(documentoInstanciaXbrlDto.Taxonomia, rol.Uri);
estructuraReporteGenericoPorRol.Add(listaDeConceptosPorRol(documentoInstanciaXbrlDto, rol, listaDeConceptosEnHiperCubos, idioma, agruparPorUnidad));
}
estructuraReporteGenerico.ReporteGenericoPorRol = estructuraReporteGenericoPorRol;
estructuraReporteGenerico.Idioma = idioma;
estructuraReporteGenerico.AgruparPorUnidad = agruparPorUnidad;
return(estructuraReporteGenerico);
}
/// <summary>
/// Crea el hint en MongoDB de unidades
/// </summary>
/// <param name="documentoInstanciXbrlDto">Informacion del documento Instancia</param>
private void CrearHintUnidades(DocumentoInstanciaXbrlDto documentoInstanciXbrlDto)
{
foreach (var IdUnidad in documentoInstanciXbrlDto.UnidadesPorId)
{
var Unidad = IdUnidad.Value;
if (Unidad.Medidas != null)
{
foreach (var medida in Unidad.Medidas)
{
var query = Query.EQ("Nombre", medida.Nombre);
var resultado = BlockStoreConsulta.consulta(CollectionUnidades, query);
if (resultado.Count == 0)
{
BlockStoreDocumentoInstancia.insertarBlockStore(CollectionUnidades, BlockStoreConsulta.armarBlockStoreUnidad(medida));
}
}
}
if (Unidad.MedidasDenominador != null)
{
foreach (var medida in Unidad.MedidasDenominador)
{
var query = Query.EQ("Nombre", medida.Nombre);
var resultado = BlockStoreConsulta.consulta(CollectionUnidades, query);
if (resultado.Count == 0)
{
BlockStoreDocumentoInstancia.insertarBlockStore(CollectionUnidades, BlockStoreConsulta.armarBlockStoreUnidad(medida));
}
}
}
if (Unidad.MedidasNumerador != null)
{
foreach (var medida in Unidad.MedidasNumerador)
{
var query = Query.EQ("Nombre", medida.Nombre);
var resultado = BlockStoreConsulta.consulta(CollectionUnidades, query);
if (resultado.Count == 0)
{
BlockStoreDocumentoInstancia.insertarBlockStore(CollectionUnidades, BlockStoreConsulta.armarBlockStoreUnidad(medida));
}
}
}
}
}
