/// <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);
}
}
}
