/// <summary> /// Obtiene en forma de lista plana, los conceptos utilizados en un rol de presentación de la taxonomía enviada como parámetro /// </summary> /// <param name="taxonomia">Taxonomía a evaluar</param> /// <param name="uriRolPresentacion">URI del rol o obtener su lista de conceptos utilizados</param> /// <returns></returns> public static IList <ConceptoDto> ObtenerListaConceptosDeRolPresentacion(TaxonomiaDto taxonomia, String uriRolPresentacion) { var listaConceptos = new List <ConceptoDto>(); if (taxonomia != null && taxonomia.RolesPresentacion != null) { RolDto <EstructuraFormatoDto> rol = taxonomia.RolesPresentacion.FirstOrDefault(x => x.Uri.Equals(uriRolPresentacion)); if (rol != null) { foreach (var estructura in rol.Estructuras) { AgregarNodoEstructura(listaConceptos, estructura, taxonomia); } } } return(listaConceptos); }
/// <summary> /// Obtiene una lista de todas las etiquetas asignadas al concepto, de cualquier idioma y rol /// </summary> /// <param name="taxonomia">Taxonomía de donde se buscarán las etiquetas</param> /// <param name="idConcepto">Concepto buscado</param> /// <returns>Conjunto de etiquetas encontradas</returns> public static IList <string> ObtenerEtiquetasConcepto(TaxonomiaDto taxonomia, String idConcepto) { var etiquetasResultado = new List <String>(); if (taxonomia != null && taxonomia.ConceptosPorId.ContainsKey(idConcepto)) { var concepto = taxonomia.ConceptosPorId[idConcepto]; if (concepto.Etiquetas != null) { foreach (var etqInRol in concepto.Etiquetas.Values) { foreach (var etq in etqInRol.Values) { etiquetasResultado.Add(etq.Valor); } } } } return(etiquetasResultado); }
/// <summary> /// Genera un lista de elementos que se encuentran en la estructura del hupercubo /// </summary> /// <param name="taxonomia">Taxonomía en la cuál se debe de inspeccionar el hipercubo del rol</param> /// <param name="uriRolPresentacion">Rol al cuál pertenece el hipercubo que se está examinando</param> /// <returns></returns> private IList <string> ObtenerListaDeHiperCubosPorRol(TaxonomiaDto taxonomia, String uriRolPresentacion) { var listaConceptos = new List <string>(); List <string> listaGeneralConceptosEnHiperCubo = new List <string>(); if (taxonomia != null && taxonomia.ListaHipercubos.Any() && taxonomia.ListaHipercubos.Where(x => x.Key.Equals(uriRolPresentacion)).Any()) { foreach (var dimensionId in taxonomia.ListaHipercubos.Where(x => x.Key.Equals(uriRolPresentacion))) { var dimension = taxonomia.ListaHipercubos[dimensionId.Key]; foreach (var listaDeEstructura in dimension) { foreach (string conceptoId in listaDeEstructura.ElementosPrimarios) { listaGeneralConceptosEnHiperCubo.Add(conceptoId); } } } } return(listaGeneralConceptosEnHiperCubo); }
/// <summary> /// Obtiene la etiqueta del concepto requerida en el idioma y rol de etiqueta preferido /// El idioma y el rol de etiqueta es opcional /// </summary> /// <param name="taxonomia">Taxonomía a buscar</param> /// <param name="idConcepto">Concepto a buscar</param> /// <param name="idioma">Idioma opcional a buscar</param> /// <param name="rolEtiquetaPreferido">Rol opcional a buscar</param> /// <returns>Etiqueta encontrada, null si no existe</returns> public static String ObtenerEtiquetaConcepto(TaxonomiaDto taxonomia, String idConcepto, String idioma, String rolEtiquetaPreferido) { String etiqueta = null; if (taxonomia != null && taxonomia.ConceptosPorId != null && taxonomia.ConceptosPorId.ContainsKey(idConcepto)) { var concepto = taxonomia.ConceptosPorId[idConcepto]; if (concepto.Etiquetas != null) { IDictionary <String, EtiquetaDto> etiquetasPorRol = null; if (idioma != null && concepto.Etiquetas.ContainsKey(idioma)) { etiquetasPorRol = concepto.Etiquetas[idioma]; } else { if (concepto.Etiquetas.Count > 0) { etiquetasPorRol = concepto.Etiquetas.First().Value; } } if (etiquetasPorRol != null) { if (rolEtiquetaPreferido != null && etiquetasPorRol.ContainsKey(rolEtiquetaPreferido)) { etiqueta = etiquetasPorRol[rolEtiquetaPreferido].Valor; } else { if (etiquetasPorRol.ContainsKey(EspacioNombresConstantes.DefaultLabelRole)) { etiqueta = etiquetasPorRol[EspacioNombresConstantes.DefaultLabelRole].Valor; } } } } } return(etiqueta); }
/// <summary> /// Obtiene la taxonomía en base al espacio de nombres. /// </summary> /// <param name="espacioNombres">Espacio de nombres de la taxonomía requerida</param> /// <returns>Taxonomía obtenida</returns> private TaxonomiaDto ObtenerTaxonomia(String espacioNombres) { TaxonomiaDto taxonomia = null; if (!TaxonomiasPorEspacioNombres.TryGetValue(espacioNombres, out taxonomia)) { String puntoEntrada; var xpe = AbaxXBRLCore.XPE.impl.XPEServiceImpl.GetInstance(); if (ArchivoTaxonomiasPorEspacioNombres.TryGetValue(espacioNombres, out puntoEntrada)) { var errores = new List <ErrorCargaTaxonomiaDto>(); taxonomia = xpe.CargarTaxonomiaXbrl(puntoEntrada, errores, true); if (errores.Count > 0) { LogUtil.Error(errores); } else { TaxonomiasPorEspacioNombres.Add(espacioNombres, taxonomia); } } } return(taxonomia); }
/// <summary> /// Obtiene el nombre de un concepto. /// </summary> /// <param name="idConcepto">Identificador del concepto.</param> /// <param name="taxonomia">Taxonomía.</param> /// <param name="claveIdioma">Idioma</param> /// <returns></returns> private String ObtenEtiquetaConcepto(String idConcepto, TaxonomiaDto taxonomia, String claveIdioma = "es") { String textoEtiqueta = String.Empty; ConceptoDto concepto; if (taxonomia.ConceptosPorId.TryGetValue(idConcepto, out concepto)) { IDictionary <string, EtiquetaDto> etiquetaPorRol; if (!concepto.Etiquetas.TryGetValue(claveIdioma, out etiquetaPorRol)) { etiquetaPorRol = concepto.Etiquetas.First().Value; } EtiquetaDto etiquetaDto; if (etiquetaPorRol.TryGetValue(ReporteXBRLUtil.ETIQUETA_DEFAULT, out etiquetaDto)) { etiquetaDto = etiquetaPorRol.First().Value; } if (etiquetaDto != null) { textoEtiqueta = etiquetaDto.Valor; } } return(textoEtiqueta); }
/// <summary> /// Genera un listado de los conceptos con la relacion de sus dimensiones /// </summary> /// <param name="taxonomia">Objeto de taxonomía utilizado para obtener etiquetas de presentación</param> /// <param name="documentoInstanciaXbrlDto"></param> /// <param name="concepto">concepto a procesar</param> /// <param name="uriRolPresentacion"></param> /// <param name="idioma">Idioma de presentación</param> /// <param name="columnas">lista de columnas que tiene el reporte</param> /// <param name="nombreconcepto">nombre del concepto que se mostrar en el reporte</param> /// <param name="indentacion">Nivel del concepto</param> /// <returns></returns> private IList <EstructuraConceptoReporte> BuscarConceptosConDimensiones(TaxonomiaDto taxonomia, DocumentoInstanciaXbrlDto documentoInstanciaXbrlDto, ConceptoDto concepto, string uriRolPresentacion, string idioma, List <EstructuraColumnaReporte> columnas, string nombreconcepto, int indentacion, bool agruparPorUnidad) { List <EstructuraConceptoReporte> listaDeEstructurasConceptos = new List <EstructuraConceptoReporte>(); if (!(concepto.EsAbstracto != null && concepto.EsAbstracto.Value)) { var hechoIdsEncontrados = new List <string>(); if (documentoInstanciaXbrlDto.HechosPorIdConcepto.ContainsKey(concepto.Id)) { hechoIdsEncontrados.AddRange(documentoInstanciaXbrlDto.HechosPorIdConcepto[concepto.Id]); } if (hechoIdsEncontrados.Count() == 0) { var combinacionDimensiones = new Dictionary <string, EstructuraDimensionReporte>(); listaDeEstructurasConceptos.Add(new EstructuraConceptoReporte() { ConceptoId = concepto.Id, NombreConcepto = nombreconcepto, NivelIndentacion = indentacion, EsAbstracto = concepto.EsAbstracto, Hechos = new EstructuraHechoReporte[columnas.Count], Dimensiones = combinacionDimensiones }); return(listaDeEstructurasConceptos); } else { foreach (var hechoId in hechoIdsEncontrados) { HechoDto hecho = documentoInstanciaXbrlDto.HechosPorId[hechoId]; List <DimensionInfoDto> listaDimensionesTotales = new List <DimensionInfoDto>(); ContextoDto contexto = documentoInstanciaXbrlDto.ContextosPorId[hecho.IdContexto]; if (contexto.ValoresDimension != null) { listaDimensionesTotales.AddRange(contexto.ValoresDimension); } if (contexto.Entidad.ValoresDimension != null) { listaDimensionesTotales.AddRange(contexto.Entidad.ValoresDimension); } AgregarDimensionesDefault(listaDimensionesTotales, taxonomia, concepto.Id, uriRolPresentacion); EstructuraConceptoReporte estructuraEncontrada = null; var estructuraDimensionesBuscada = CrearEstructuraDimensiones(listaDimensionesTotales, taxonomia, idioma); foreach (var estConceptoActual in listaDeEstructurasConceptos) { if (EsMismaCombinacionDeDimensiones(estConceptoActual.Dimensiones, estructuraDimensionesBuscada)) { estructuraEncontrada = estConceptoActual; break; } } //Si no se encontró la combinación de dimensiones, crear nueva if (estructuraEncontrada == null) { estructuraEncontrada = new EstructuraConceptoReporte() { ConceptoId = concepto.Id, NombreConcepto = nombreconcepto, NivelIndentacion = indentacion, EsAbstracto = concepto.EsAbstracto, Hechos = new EstructuraHechoReporte[columnas.Count], Dimensiones = estructuraDimensionesBuscada }; listaDeEstructurasConceptos.Add(estructuraEncontrada); } int posicion = BuscarIndexColumna(documentoInstanciaXbrlDto, columnas, hecho, agruparPorUnidad); if (posicion != -1) { estructuraEncontrada.Hechos[posicion] = new EstructuraHechoReporte(); estructuraEncontrada.Hechos[posicion].HechoId = hecho.Id; estructuraEncontrada.Hechos[posicion].Valor = hecho.Valor; estructuraEncontrada.Hechos[posicion].ValorNumerico = hecho.ValorNumerico; estructuraEncontrada.Hechos[posicion].ValorRedondeado = hecho.ValorRedondeado; estructuraEncontrada.Hechos[posicion].EsNumerico = hecho.EsNumerico; } } } } else { listaDeEstructurasConceptos.Add(new EstructuraConceptoReporte() { ConceptoId = concepto.Id, NombreConcepto = nombreconcepto, NivelIndentacion = indentacion, EsAbstracto = concepto.EsAbstracto, Hechos = new EstructuraHechoReporte[columnas.Count], Dimensiones = new Dictionary <string, EstructuraDimensionReporte>() }); } return(listaDeEstructurasConceptos); }
private void recorrerArbolLinkbasePresentacion(IList <EstructuraFormatoDto> estructurasDocumento, Dictionary <string, object> estructuraDocumentoPresentacion, int indentacion, TaxonomiaDto taxonomiaDto) { if (estructurasDocumento == null) { return; } foreach (var estructuraDocumento in estructurasDocumento) { Dictionary <string, object> elementoDocumento = new Dictionary <string, object>(); elementoDocumento.Add("IdConcepto", estructuraDocumento.IdConcepto); elementoDocumento.Add("Indentacion", indentacion); if (!estructuraDocumentoPresentacion.ContainsKey(estructuraDocumento.IdConcepto)) { estructuraDocumentoPresentacion.Add(estructuraDocumento.IdConcepto, elementoDocumento); } else { System.Console.WriteLine("Concepto Existe en : " + estructuraDocumento.IdConcepto); } recorrerArbolLinkbasePresentacion(estructuraDocumento.SubEstructuras, estructuraDocumentoPresentacion, indentacion + 1, taxonomiaDto); } }
public Dictionary <string, object> ObtenerInformacionConsultaDocumentos(ConsultaAnalisisDto consiguracionConsulta, List <DocumentoInstanciaXbrlDto> informacionVersionDocumentos, TaxonomiaDto taxonomiaDto) { var informacionConsultaDocumentos = new Dictionary <string, object>(); var documentoInstanciaDocumento = unirDocumentosInstancia(informacionVersionDocumentos); if (documentoInstanciaDocumento != null) { documentoInstanciaDocumento.Taxonomia = taxonomiaDto; informacionConsultaDocumentos.Add("DocumentoInstancia", documentoInstanciaDocumento); foreach (var rolTaxonomia in consiguracionConsulta.ConsultaAnalisisRolTaxonomia) { var informacionRolTaxonomia = new Dictionary <string, object>(); var estructuraDocumento = new Dictionary <string, object>(); informacionRolTaxonomia.Add("NombreRol", rolTaxonomia.DescripcionRol); informacionRolTaxonomia.Add("Uri", rolTaxonomia.Uri); foreach (var rolPresentacion in taxonomiaDto.RolesPresentacion) { if (rolPresentacion.Uri.Equals(rolTaxonomia.Uri)) { int indentacion = 1; recorrerArbolLinkbasePresentacion(rolPresentacion.Estructuras, estructuraDocumento, indentacion, taxonomiaDto); informacionRolTaxonomia.Add("Conceptos", estructuraDocumento); } } informacionConsultaDocumentos.Add(rolTaxonomia.Uri, informacionRolTaxonomia); } } return(informacionConsultaDocumentos); }
public void TestProcesarDistribucionDocumentosXBRL() { LogUtil.LogDirPath = @"..\..\TestOutput\"; LogUtil.Inicializa(); var xpe = XPEServiceImpl.GetInstance(false); var errores = new List <ErrorCargaTaxonomiaDto>(); TaxonomiaDto tax = xpe.CargarTaxonomiaXbrl("http://emisnet.bmv.com.mx/taxonomy/mx-ifrs-2014-12-05/full_ifrs_mc_mx_ics_entry_point_2014-12-05.xsd", errores, false); var factsById = new Dictionary <String, FactJBRL>(); var dimensionMembersByCode = new Dictionary <String, DimensionMemberJBRL>(); var taxFact = new FactJBRL() { conceptId = "TaxonomyCode", value = tax.EspacioNombresPrincipal, factId = Guid.NewGuid().ToString() }; taxFact.dimensionMap = new Dictionary <string, string>(); AddDimensionMember(dimensionMembersByCode, taxFact, "taxonomy", tax.EspacioNombresPrincipal, null); AddDimensionMember(dimensionMembersByCode, taxFact, "taxonomyCategory", "financialInfo", null); taxFact.dimensionMap["taxonomy"] = tax.EspacioNombresPrincipal; taxFact.dimensionMap["taxonomyCategory"] = "financialInfo"; var taxName = new FactJBRL() { conceptId = "TaxonomyName", value = "IFRS BMV 2015 For ICS", factId = Guid.NewGuid().ToString() }; taxName.dimensionMap = new Dictionary <string, string>(); taxName.dimensionMap["taxonomy"] = tax.EspacioNombresPrincipal; taxName.dimensionMap["taxonomyCategory"] = "financialInfo"; var taxDesc = new FactJBRL() { conceptId = "TaxonomyDescription", value = "Mexican Taxonomy for financial information for industrial, commercial and services companies", factId = Guid.NewGuid().ToString() }; taxDesc.dimensionMap = new Dictionary <string, string>(); taxDesc.dimensionMap["taxonomy"] = tax.EspacioNombresPrincipal; taxDesc.dimensionMap["taxonomyCategory"] = "financialInfo"; factsById[taxFact.factId] = taxFact; factsById[taxName.factId] = taxName; factsById[taxDesc.factId] = taxDesc; var conceptsByPresentation = getConceptsByPresentationLinkbase(tax); foreach (var conceptId in conceptsByPresentation.Keys) { var concept = tax.ConceptosPorId[conceptId]; var taxonomyConcept = new FactJBRL() { conceptId = "TaxonomyConcept", value = concept.Id, factId = Guid.NewGuid().ToString() }; foreach (var labelMap in concept.Etiquetas.Values) { foreach (var label in labelMap.Values) { var conceptLabel = new FactJBRL() { conceptId = "ConceptLabel", value = label.Valor, factId = Guid.NewGuid().ToString() }; conceptLabel.dimensionMap = new Dictionary <string, string>(); conceptLabel.dimensionMap["taxonomy"] = tax.EspacioNombresPrincipal; conceptLabel.dimensionMap["taxonomyCategory"] = "financialInfo"; conceptLabel.dimensionMap["concept"] = concept.Id; conceptLabel.dimensionMap["language"] = label.Idioma; conceptLabel.dimensionMap["labelRole"] = label.Rol; factsById[conceptLabel.factId] = conceptLabel; } } taxonomyConcept.dimensionArray = new List <DimensionMemberJBRL>(); taxonomyConcept.dimensionMap = new Dictionary <string, string>(); taxonomyConcept.dimensionArray.Add(new DimensionMemberJBRL() { dimensionId = "taxonomy", member = tax.EspacioNombresPrincipal }); taxonomyConcept.dimensionArray.Add(new DimensionMemberJBRL() { dimensionId = "taxonomyCategory", member = "financialInfo" }); taxonomyConcept.dimensionArray.Add(new DimensionMemberJBRL() { dimensionId = "taxonomyRole", member = conceptsByPresentation[conceptId][0].ToString() }); taxonomyConcept.dimensionArray.Add(new DimensionMemberJBRL() { dimensionId = "roleOrder", member = conceptsByPresentation[conceptId][1].ToString() }); taxonomyConcept.dimensionMap["taxonomy"] = tax.EspacioNombresPrincipal; taxonomyConcept.dimensionMap["taxonomyCategory"] = "financialInfo"; taxonomyConcept.dimensionMap["taxonomyRole"] = conceptsByPresentation[conceptId][0].ToString(); taxonomyConcept.dimensionMap["roleOrder"] = conceptsByPresentation[conceptId][1].ToString(); factsById[taxonomyConcept.factId] = taxonomyConcept; } var jsonFinal = JsonConvert.SerializeObject(factsById, Formatting.Indented); // LogUtil.Info(jsonFinal); File.WriteAllText(@"..\..\TestOutput\taxonomyTest.json", jsonFinal); }
public abstract ResultadoOperacionDto ObtenerPlantillaExcel(string espacioNombresPrincipal, String idioma, TaxonomiaDto taxonomia, IDictionary <string, bool> conceptosDescartar = null, IList <string> hojasDescartar = null);
/// <summary> /// Busca las celdas con contenido del tipo idConcept:{nombre_concepto}[:{nombre_rol}] /// Este tipo de etiquetado indica que la celda lleva el nombre de un concepto y opcionalmente /// con cierto rol de etiqueta y que se debe de poner en el idioma indicado /// </summary> /// <param name="hojaExportar">Hoja a verificar</param> /// <param name="instancia">Documento de instancia actualmente exportado</param> /// <param name="idioma">Idioma deseado para las etiquetas</param> protected void ReemplazarEtiquetasEnHojaExcel(ISheet hojaExportar, ISheet hojaPantilla, TaxonomiaDto taxonomia, String idioma) { var ultimoRenglon = hojaExportar.LastRowNum; for (int iRenglon = hojaExportar.FirstRowNum; iRenglon <= ultimoRenglon; iRenglon++) { var renglon = hojaExportar.GetRow(iRenglon); if (renglon != null) { var ultimaColumna = renglon.LastCellNum; for (int iCol = renglon.FirstCellNum; ultimaColumna >= 0 && iCol <= ultimaColumna; iCol++) { var valorCelda = ExcelUtil.ObtenerValorCelda(renglon, iCol); if (valorCelda == null) { valorCelda = ""; } else { valorCelda = valorCelda.Trim(); } if (!String.IsNullOrEmpty(valorCelda) && valorCelda.StartsWith("idConcepto;")) { var componentesEtiqueta = valorCelda.Split(';'); if (componentesEtiqueta != null) { if (componentesEtiqueta.Length >= 2) { string idConcepto = null; string rol = null; idConcepto = componentesEtiqueta[1]; if (componentesEtiqueta.Length >= 3) { rol = componentesEtiqueta[2]; } var etiquetaFinal = valorCelda; if (taxonomia.ConceptosPorId.ContainsKey(idConcepto)) { var concepto = taxonomia.ConceptosPorId[idConcepto]; etiquetaFinal = concepto.Nombre; if (concepto.Etiquetas.ContainsKey(idioma)) { etiquetaFinal = concepto.Etiquetas[idioma][Etiqueta.RolEtiqueta].Valor; if (rol != null && concepto.Etiquetas[idioma].ContainsKey(rol)) { etiquetaFinal = concepto.Etiquetas[idioma][rol].Valor; } } } renglon.GetCell(iCol).SetCellValue(etiquetaFinal); } } } } } } }
public static Stream evaluaElementosDescartarPlantillaExcel(Stream plantillaBase, IDictionary <string, bool> conceptosDescartar, IList <string> hojasDescartar, TaxonomiaDto taxonomia) { if ((conceptosDescartar == null || conceptosDescartar.Count == 0) && (hojasDescartar == null || hojasDescartar.Count == 0)) { return(plantillaBase); } var conceptoDto = new ConceptoDto(); var plantilla = WorkbookFactory.Create(plantillaBase); foreach (var nombreHoja in hojasDescartar) { var hoja = plantilla.GetSheet(nombreHoja); var indiceHoja = plantilla.GetSheetIndex(nombreHoja); if (indiceHoja != -1) { plantilla.RemoveSheetAt(indiceHoja); } } for (int i = 0; i < plantilla.NumberOfSheets; i++) { var hoja = plantilla.GetSheetAt(i); IList <int> renglonesEliminar = new List <int>(); IList <int> columnasEliminar = new List <int>(); var nombreHoja = plantilla.GetSheetName(i); //var nombreNuevaHoja = nombreHoja + "_New"; //plantilla.CreateSheet(nombreNuevaHoja); var ultimoRenglon = hoja.LastRowNum; for (int iRenglon = hoja.FirstRowNum; iRenglon <= ultimoRenglon; iRenglon++) { var renglon = hoja.GetRow(iRenglon); if (renglon != null) { var ultimaColumna = renglon.LastCellNum; for (int iCol = renglon.FirstCellNum; ultimaColumna >= 0 && iCol <= ultimaColumna; iCol++) { var valorCelda = ExcelUtil.ObtenerIdConceptoDeCelda(hoja, iRenglon, iCol); if (valorCelda == null) { valorCelda = ""; } else { valorCelda = valorCelda.Trim(); } if (!String.IsNullOrEmpty(valorCelda)) { bool contieneConcepto = false; if (conceptosDescartar.TryGetValue(valorCelda, out contieneConcepto) && iCol == 0) { renglonesEliminar.Add(iRenglon); if (taxonomia.ConceptosPorId.TryGetValue(valorCelda, out conceptoDto)) { if (conceptoDto.EsMiembroDimension == null || conceptoDto.EsMiembroDimension.Value) { var valorCeldaSiguiente = ExcelUtil.ObtenerIdConceptoDeCelda(hoja, iRenglon + 1, iCol); if (valorCeldaSiguiente == null || valorCeldaSiguiente.Equals("")) { renglonesEliminar.Add(iRenglon + 1); renglonesEliminar.Add(iRenglon + 2); } } } } if (conceptosDescartar.TryGetValue(valorCelda, out contieneConcepto) && iCol > 0) { columnasEliminar.Add(iCol); hoja.GetRow(iRenglon).GetCell(iCol).SetCellValue(""); } } } } } for (int indexListaEliminar = (renglonesEliminar.Count - 1); indexListaEliminar >= 0; indexListaEliminar--) { var numRenglonEliminar = renglonesEliminar[indexListaEliminar]; if (numRenglonEliminar == hoja.LastRowNum) { hoja.CreateRow(numRenglonEliminar + 1); } if ((numRenglonEliminar) < hoja.LastRowNum) { hoja.ShiftRows(numRenglonEliminar + 1, hoja.LastRowNum, -1); } } //for (int renglonEliminar = renglonesEliminar.Count; renglonEliminar >= 0; renglonEliminar--) { // hoja.ShiftRows(renglonEliminar + 1, hoja.LastRowNum, -1); //} } MemoryStream memoryStream = new MemoryStream(); plantilla.Write(memoryStream); //Workaround de NPOI, de los el flujo de salida de write se encuentra cerrado MemoryStream ms = new MemoryStream(memoryStream.ToArray()); return(ms); }
public abstract ResultadoOperacionDto ExportarDocumentoExcel(DocumentoInstanciaXbrlDto instancia, String idioma, TaxonomiaDto taxonomia, IDictionary <string, bool> conceptosDescartar = null, IList <string> hojasDescartar = null);
/// <summary> /// Agrega las dimensiones default a la lista de dimensiones del concepto , en caso de que no cuenta con esa dimensión /// declarada y el hipercubo declarado en el rol actual cuenta con dimensión default /// </summary> /// <param name="listaDimensionesTotales">Lista actual de dimensiones totales</param> /// <param name="taxonomia">Taxonomía procesada actualmente</param> /// <param name="idConcepto">Identificador del concepto</param> /// <param name="uriRolPresentacion">URI del rol de presentación actualmente procesado</param> private void AgregarDimensionesDefault(List <DimensionInfoDto> listaDimensionesTotales, TaxonomiaDto taxonomia, string idConcepto, string uriRolPresentacion) { //Verificar si las dimensiones default del hipercubo del rol existen if (taxonomia.ListaHipercubos.ContainsKey(uriRolPresentacion)) { var dimDefaultsDeConcepto = new Dictionary <string, string>(); foreach (var hiperC in taxonomia.ListaHipercubos[uriRolPresentacion]) { if (hiperC.ElementosPrimarios.Contains(idConcepto)) { //El concepto es elemento primario de cubo foreach (var dimHiperc in hiperC.Dimensiones) { //Tiene miembro por default y no está declarada en la lista de dimensiones if (taxonomia.DimensionDefaults.ContainsKey(dimHiperc) && !listaDimensionesTotales.Any(x => x.IdDimension.Equals(dimHiperc))) { listaDimensionesTotales.Add(new DimensionInfoDto() { Explicita = true, IdDimension = dimHiperc, IdItemMiembro = taxonomia.DimensionDefaults[dimHiperc] }); } } } } } }
/// <summary> /// Crea una combinación de dimensiones en objeto del tipo EstructuraDimension /// de acuerdo a la lista de dimensiones enviadas como parámtro /// </summary> /// <param name="listaDimensionesTotales">Lista de dimesiones a transformar</param> /// <param name="taxonomia">Objeto de taxonomía utilizado para obtener etiquetas de presentación</param> /// <param name="idioma">Idioma de presentación</param> /// <returns>Combinación de dimensiones</returns> private IDictionary <string, EstructuraDimensionReporte> CrearEstructuraDimensiones(List <DimensionInfoDto> listaDimensionesTotales, TaxonomiaDto taxonomia, String idioma) { var resultado = new Dictionary <string, EstructuraDimensionReporte>(); foreach (var dimensionInfo in listaDimensionesTotales) { if (!resultado.ContainsKey(dimensionInfo.IdDimension)) { resultado.Add(dimensionInfo.IdDimension, new EstructuraDimensionReporte() { IdDimension = dimensionInfo.IdDimension, Explicita = dimensionInfo.Explicita, IdMiembro = dimensionInfo.IdItemMiembro, NombreDimension = UtilAbax.ObtenerEtiqueta(taxonomia, dimensionInfo.IdDimension, Etiqueta.RolEtiqueta, idioma), NombreMiembro = dimensionInfo.Explicita ? UtilAbax.ObtenerEtiqueta(taxonomia, dimensionInfo.IdItemMiembro, Etiqueta.RolEtiqueta, idioma) : dimensionInfo.ElementoMiembroTipificado, ElementoMiembroTipificado = dimensionInfo.ElementoMiembroTipificado }); } } return(resultado); }
public override ResultadoOperacionDto ExportarDocumentoExcel(DocumentoInstanciaXbrlDto instancia, String idioma, TaxonomiaDto taxonomia, IDictionary <string, bool> conceptosDescartar = null, IList <string> hojasDescartar = null) { var res = new ResultadoOperacionDto(); res.InformacionExtra = new Dictionary <string, object>(); var informeErrores = new List <InformeErrorImportacion>(); string entryPointTax = instancia.EspacioNombresPrincipal; var memoryStreamNew = new MemoryStream(); try { //Verificar si existe la plantilla para la taxonomía if (entryPointTax != null) { entryPointTax = entryPointTax.Replace(_puntoXSD, String.Empty).Replace(_guion, _caracterReemplazo).Replace(_dosPuntos, _caracterReemplazo). Replace(_diagonal, _caracterReemplazo).Replace(_punto, _caracterReemplazo); if (ObtenerApplicationContext().ContainsObject(entryPointTax)) { var plantillaDocumento = (IDefinicionPlantillaXbrl)ObtenerApplicationContext().GetObject(entryPointTax); if (plantillaDocumento.ObtenerRutaPlantillaExcel() != null) { plantillaDocumento.Inicializar(instancia); using (var streamPlantilla = Assembly.GetExecutingAssembly().GetManifestResourceStream(plantillaDocumento.ObtenerRutaPlantillaExcel())) { if (streamPlantilla != null) { using (var streamExcelCaptura = Assembly.GetExecutingAssembly().GetManifestResourceStream(plantillaDocumento.ObtenerRutaPlantillaExcel())) { if (streamExcelCaptura != null) { XSSFWorkbook workBookExportar = null; XSSFWorkbook workBookPlantilla = null; if (conceptosDescartar != null && hojasDescartar != null) { Stream streamExcelCapturaDepurado = evaluaElementosDescartarPlantillaExcel(streamPlantilla, conceptosDescartar, hojasDescartar, taxonomia); workBookExportar = new XSSFWorkbook(streamExcelCapturaDepurado); Stream streamPlantillaDepurado = evaluaElementosDescartarPlantillaExcel(streamExcelCaptura, conceptosDescartar, hojasDescartar, taxonomia); workBookPlantilla = new XSSFWorkbook(streamPlantillaDepurado); } else { workBookExportar = new XSSFWorkbook(streamExcelCaptura); workBookPlantilla = new XSSFWorkbook(streamPlantilla); } for (var iItem = 0; iItem < workBookPlantilla.Count; iItem++) { var hojaExportar = workBookExportar.GetSheet(workBookPlantilla.GetSheetAt(iItem).SheetName); if (hojaExportar != null) { ExportarHojaDeCalculo(hojaExportar, workBookPlantilla.GetSheetAt(iItem), instancia, plantillaDocumento, informeErrores, idioma); } } var memoryStreamSalida = new MemoryStream(); var currentCulture = Thread.CurrentThread.CurrentCulture; Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US"); workBookExportar.Write(memoryStreamSalida); Thread.CurrentThread.CurrentCulture = currentCulture; (res.InformacionExtra as Dictionary <string, object>).Add("archivo", memoryStreamSalida.ToArray()); res.Resultado = true; } } } } } else { res.Mensaje = "NA"; } } } } catch (Exception ex) { informeErrores.Add(new InformeErrorImportacion() { Mensaje = "Ocurrió un error al exportar el archivo:" + ex.Message }); res.Resultado = false; res.Mensaje = "Ocurrió un error al exportar el archivo:" + ex.Message; LogUtil.Error(new Dictionary <string, object>() { { "Error", res.Mensaje }, { "Exeption", ex } }); } (res.InformacionExtra as Dictionary <string, object>).Add("errores", informeErrores); return(res); }
public override ResultadoOperacionDto ObtenerPlantillaExcel(string espacioNombresPrincipal, String idioma, TaxonomiaDto taxonomia, IDictionary <string, bool> conceptosDescartar = null, IList <string> hojasDescartar = null) { var resultadoOperacion = new ResultadoOperacionDto(); string entryPointTax = espacioNombresPrincipal; try { if (entryPointTax != null) { entryPointTax = entryPointTax.Replace(_puntoXSD, String.Empty).Replace(_guion, _caracterReemplazo).Replace(_dosPuntos, _caracterReemplazo). Replace(_diagonal, _caracterReemplazo).Replace(_punto, _caracterReemplazo); if (ObtenerApplicationContext().ContainsObject(entryPointTax)) { var plantillaDocumento = (IDefinicionPlantillaXbrl)ObtenerApplicationContext().GetObject(entryPointTax); if (plantillaDocumento.ObtenerRutaPlantillaExcel() != null) { using (var streamPlantilla = Assembly.GetExecutingAssembly().GetManifestResourceStream(plantillaDocumento.ObtenerRutaPlantillaExcel())) { //Preprocesar la plantilla de salida Stream plantillaStream = evaluaElementosDescartarPlantillaExcel(streamPlantilla, conceptosDescartar, hojasDescartar, taxonomia); var plantilla = WorkbookFactory.Create(plantillaStream); for (int iSheet = 0; iSheet < plantilla.NumberOfSheets; iSheet++) { ReemplazarEtiquetasEnHojaExcel(plantilla.GetSheetAt(iSheet), plantilla.GetSheetAt(iSheet), taxonomia, idioma); QuitarPlaceHolderHechoEnHojaExcel(plantilla.GetSheetAt(iSheet)); } MemoryStream memoryStream = new MemoryStream(); plantilla.Write(memoryStream); //Workaround de NPOI, de los el flujo de salida de write se encuentra cerrado MemoryStream ms = new MemoryStream(memoryStream.ToArray()); resultadoOperacion.InformacionExtra = ms; resultadoOperacion.Resultado = true; plantilla = null; } } } } } catch (Exception ex) { resultadoOperacion.Resultado = false; resultadoOperacion.Mensaje = ex.Message; } return(resultadoOperacion); }
/// <summary> /// Verifica si el concepto existe en un hipercubo negado de la taxonmía /// </summary> /// <param name="concepto"></param> /// <param name="dimensiones"></param> /// <returns></returns> public static bool EsConceptoEnHipercuboNegado(ConceptoDto concepto, List <DimensionInfoDto> dimensiones, TaxonomiaDto taxonomia) { if (concepto != null && taxonomia != null && taxonomia.ConceptosHipercubosNegados != null && taxonomia.ConceptosHipercubosNegados.ContainsKey(concepto.Id)) { if (CoincidenDimensiones(taxonomia.ConceptosHipercubosNegados[concepto.Id], dimensiones)) { return(true); } } return(false); }
/// <summary> /// Agrega los elementos primarios de un hipercubo negado junto con las combinaciones de dimensiones donde no es válido al diccionario /// enviado como parámetro /// </summary> /// <param name="conceptosNoHabilitados"></param> /// <param name="hiperCubo"></param> private static void AgregarHipercuboNegado(IDictionary <string, IDictionary <String, IList <String> > > conceptosNoHabilitados, HipercuboDto hiperCubo, TaxonomiaDto taxoDto) { //Obtener las columnas del hipercubo var dimensionesYMiembrosCubo = new Dictionary <String, IList <String> >(); foreach (var idDimension in hiperCubo.Dimensiones) { dimensionesYMiembrosCubo[idDimension] = ObtenerListaMiembros(hiperCubo.EstructuraDimension[idDimension]); } foreach (var idElementoPrimario in hiperCubo.ElementosPrimarios) { if (taxoDto.ConceptosPorId.ContainsKey(idElementoPrimario)) { var conceptoPrimario = taxoDto.ConceptosPorId[idElementoPrimario]; if (!(conceptoPrimario.EsAbstracto ?? false) && !conceptosNoHabilitados.ContainsKey(idElementoPrimario)) { conceptosNoHabilitados[idElementoPrimario] = dimensionesYMiembrosCubo; } } } }
/// <summary> /// Recorre el árbol de estructuras y los agrega a la lista plana de estructuras /// </summary> /// <param name="listaConceptos">Lista a llenar</param> /// <param name="estructura">Estructura a agregar</param> private static void AgregarNodoEstructura(List <ConceptoDto> listaConceptos, EstructuraFormatoDto estructura, TaxonomiaDto taxonomia) { if (estructura.IdConcepto != null && taxonomia.ConceptosPorId.ContainsKey(estructura.IdConcepto)) { if (!listaConceptos.Any(x => x.Id.Equals(estructura.IdConcepto))) { listaConceptos.Add(taxonomia.ConceptosPorId[estructura.IdConcepto]); } } if (estructura.SubEstructuras != null) { foreach (var subEstructura in estructura.SubEstructuras) { AgregarNodoEstructura(listaConceptos, subEstructura, taxonomia); } } }