/// <summary>
/// Carga los datos de una hoja de cálculo y aplica los valores encontrados al documento de instancia
/// </summary>
/// <param name="hojaImportar">Hoja de cálculo a importar</param>
/// <param name="hojaPlantilla">Hoja de cálculo de la plantilla</param>
/// <param name="instancia">Documento de instancia destino</param>
/// <param name="informeErrores">Lista de de informe de errores</param>
/// <param name="plantillaDocumento"></param>
private void ImportarHojaDeCalculo(ISheet hojaImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia,
ResumenProcesoImportacionExcelDto resumenImportacion,
IDefinicionPlantillaXbrl plantillaDocumento)
{
var rolUri = plantillaDocumento.ObtenerRolDeAlias(hojaPlantilla.SheetName);
if (rolUri != null)
{
try
{
//Si el rol tiene implementación específica utilizarla, si no, utilizar el importador genérico de plantilla
var idSpringImportador = plantillaDocumento.ObtenerIdSpringDefinicionElementosPlantillaDeRol(rolUri);
if (ObtenerApplicationContext().ContainsObject("importador_" + idSpringImportador))
{
var importadorRol = (IImportadorExportadorRolDocumento)ObtenerApplicationContext().GetObject("importador_" + idSpringImportador);
importadorRol.ImportarDatosDeHojaExcel(hojaImportar, hojaPlantilla, instancia, rolUri, resumenImportacion, plantillaDocumento);
}
else
{
ImportadorRolPlantillaGenerico.ImportarDatosDeHojaExcel(hojaImportar, hojaPlantilla, instancia, rolUri, resumenImportacion, plantillaDocumento);
}
}
catch (Exception ex)
{
LogUtil.Error(ex);
resumenImportacion.InformeErrores.Add(new InformeErrorImportacion()
{
IdRol = rolUri,
Mensaje = "Ocurrió un error al importar el rol : " + rolUri + " : " + ex.Message
});
}
}
}
/// <summary>
/// Genera los contextos de la serie.
/// </summary>
/// <param name="idDimension">Identificador de la idmensión evaluada.</param>
/// <param name="rowImportar">Fila a iterar.</param>
/// <param name="indiceColumnaInicio">Columna donde inicia la iteración.</param>
/// <param name="hipercuboUtil">Utilería con la información del hipercubo.</param>
/// <param name="resumenImportacion">Resumen de la importación para agregar errores en caso de presentarse.</param>
/// <param name="nombreHoja">Nombre de la hoja.</param>
/// <param name="instancia">Documento de instancia.</param>
/// <param name="plantillaDocumento">Plantilla del documento.</param>
/// <param name="claveIdioma"></param>
/// <returns>Diccionario con los identificadores de contexto por columna.</returns>
private IDictionary <int, Dto.ContextoDto> GeneraContextosSeries(
String idDimension,
IRow rowImportar,
int indiceColumnaInicio,
EvaluadorHipercuboUtil hipercuboUtil,
ResumenProcesoImportacionExcelDto resumenImportacion,
String nombreHoja,
DocumentoInstanciaXbrlDto instancia,
IDefinicionPlantillaXbrl plantillaDocumento,
string claveIdioma)
{
var nombreConcepto = ObtenEtiquetaConcepto(idDimension, instancia.Taxonomia, claveIdioma);
var contextosColumna = new Dictionary <int, Dto.ContextoDto>();
PlantillaDimensionInfoDto plantillaDimension = null;
if (!hipercuboUtil.configuracion.PlantillaDimensiones.TryGetValue(idDimension, out plantillaDimension))
{
LogUtil.Error("No existe una definición de plantilla con el identificador \"" + idDimension + "\".");
return(contextosColumna);
}
PlantillaContextoDto plantillaContexto = hipercuboUtil.configuracion.PlantillasContextos.Values.First();
var seriesEvaluadas = new Dictionary <String, int>();
for (var indexSerie = indiceColumnaInicio; indexSerie <= rowImportar.LastCellNum; indexSerie++)
{
var celdaSerie = rowImportar.GetCell(indexSerie);
if (celdaSerie != null && !celdaSerie.CellType.Equals(CellType.Blank))
{
var nombreSerie = ExcelUtil.ObtenerValorCelda(celdaSerie.CellType, celdaSerie);
if (String.IsNullOrWhiteSpace(nombreSerie))
{
continue;
}
if (seriesEvaluadas.ContainsKey(nombreSerie))
{
resumenImportacion.InformeErrores.Add(new InformeErrorImportacion()
{
Mensaje = "No fue posible agregar la serie \"" + nombreSerie +
"\", de la hoja \"" + nombreHoja +
"\" renglon \"" + rowImportar.RowNum.ToString() + "\" columna \"" + celdaSerie.ColumnIndex.ToString() +
"\", debido a que este nombre de serie ya fué indicado previamente en la columna \"" + seriesEvaluadas[nombreSerie] + "\".",
});
continue;
}
var miembroDimensionSerie = plantillaDimension.CreaMiembroDimension(nombreSerie);
var listaDimensiones = new List <DimensionInfoDto>()
{
miembroDimensionSerie
};
var contexto = plantillaContexto.GeneraContexto(instancia, plantillaDocumento, listaDimensiones);
plantillaDocumento.InyectarContextoADocumentoInstancia(contexto);
contextosColumna.Add(celdaSerie.ColumnIndex, contexto);
seriesEvaluadas.Add(nombreSerie, celdaSerie.ColumnIndex);
}
}
return(contextosColumna);
}
/// <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);
}
if (String.IsNullOrEmpty(valorHecho))
{
continue;
}
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>
/// Constructor de la clase.
/// </summary>
/// <param name="instancia">Documento de instancia.</param>
/// <param name="plantillaDocumento">Plantilla de definición.</param>
public ConfiguracionReporteExcel427000(DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantillaDocumento, ResumenProcesoImportacionExcelDto resumenImportacion)
{
Instancia = instancia;
PlantillaDocumento = plantillaDocumento;
ListaConceptosMiembro = new List <ConceptoDto>();
DiccionarioConceptosPorColumna = new Dictionary <int, ConceptoDto>();
NombreHoja = String.Empty;
ResumenImportacion = resumenImportacion;
DiccionarioUnidadesPorIdConcepto = new Dictionary <String, UnidadDto>();
DiccionarioDecimalesPorIdConcepto = new Dictionary <String, String>();
}
/// <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);
}
public void ImportarDatosDeHojaExcel(ISheet hojaAImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia,
string rol, ResumenProcesoImportacionExcelDto resumenImportacion, IDefinicionPlantillaXbrl plantillaDocumento)
{
var maxRow = hojaPlantilla.LastRowNum;
var fechaDefault = plantillaDocumento.ObtenerVariablePorId("fecha_2015_01_01");
var idiomaDefault = instancia.Taxonomia != null && instancia.Taxonomia.IdiomasTaxonomia != null && instancia.Taxonomia.IdiomasTaxonomia.Keys.Count > 0 ?
instancia.Taxonomia.IdiomasTaxonomia.Keys.First() : String.Empty;
for (var iRenglon = 0; iRenglon <= maxRow; iRenglon++)
{
var renglon = hojaPlantilla.GetRow(iRenglon);
if (renglon != null)
{
var maxCol = renglon.LastCellNum;
for (var iCol = 0; iCol <= maxCol; iCol++)
{
var valorHechoPlantilla = ExcelUtil.ObtenerValorCelda(renglon, iCol);
if (!String.IsNullOrEmpty(valorHechoPlantilla) && valorHechoPlantilla.StartsWith(PREFIJO_CELDA_HECHO_PLANTILLA) &&
valorHechoPlantilla.Length > PREFIJO_CELDA_HECHO_PLANTILLA.Length)
{
var idHechoPlantilla = valorHechoPlantilla.Substring(PREFIJO_CELDA_HECHO_PLANTILLA.Length);
var valorCeldaImportar = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRenglon, iCol);
if (!String.IsNullOrEmpty(valorCeldaImportar))
{
//Buscar el hecho de plantilla en el documento de instancia
var hechoInstancia =
plantillaDocumento.BuscarHechoPlantillaEnHechosDocumentoInstancia(
idHechoPlantilla);
//Si el hecho no existe crearlo en base a la plantilla
if (hechoInstancia == null)
{
hechoInstancia =
plantillaDocumento.CrearHechoAPartirDeIdDefinicionPlantilla(
idHechoPlantilla);
if (hechoInstancia != null)
{
hechoInstancia.NotasAlPie = ExcelUtil.ObtenerComentariosCelda(renglon, iCol, idiomaDefault);
plantillaDocumento.InyectaHechoADocumentoInstancia(hechoInstancia);
}
}
if (hechoInstancia != null)
{
var conceptoImportar = instancia.Taxonomia.ConceptosPorId[hechoInstancia.IdConcepto];
if (!UtilAbax.ActualizarValorHecho(conceptoImportar, hechoInstancia, valorCeldaImportar, fechaDefault))
{
resumenImportacion.AgregarErrorFormato(
UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, conceptoImportar.Id),
hojaAImportar.SheetName,
iRenglon.ToString(),
iCol.ToString(),
valorCeldaImportar);
}
else
{
resumenImportacion.TotalHechosImportados++;
var hechoImportado = new InformacionHechoImportadoExcelDto()
{
IdConcepto = hechoInstancia.IdConcepto,
IdHecho = hechoInstancia.Id,
ValorImportado = valorCeldaImportar,
HojaExcel = hojaAImportar.SheetName,
Renglon = iRenglon,
Columna = iCol
};
resumenImportacion.AgregarHechoImportado(hechoImportado, UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, conceptoImportar.Id));
}
}
}
}
}
}
}
}
public void ImportarDatosDeHojaExcel(ISheet hojaAImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, string rol, ResumenProcesoImportacionExcelDto resumenImportacion, IDefinicionPlantillaXbrl plantillaDocumento)
{
var nombreHoja = hojaPlantilla.SheetName;
String idConceptoHipercubo;
IDictionary <int, Dto.ContextoDto> diccionarioContextosSeries = null;
IDictionary <int, Dto.ContextoDto> diccionarioContextosCalificaciones = null;
if (ConceptosHipercuboPorHoja.TryGetValue(nombreHoja, out idConceptoHipercubo))
{
HipercuboReporteDTO hiperCubo = ObtenConfiguracionHipercubo(idConceptoHipercubo, instancia, plantillaDocumento);
HipercuboReporteDTO hiperCuboCalificaciones = null;
var miembroCalificadora = String.Empty;
for (var indexRow = hojaPlantilla.FirstRowNum; indexRow <= hojaPlantilla.LastRowNum; indexRow++)
{
var rowPlantilla = hojaPlantilla.GetRow(indexRow);
var rowImportar = hojaAImportar.GetRow(indexRow);
var celdaConcepto = rowPlantilla.GetCell(rowPlantilla.FirstCellNum);
if (celdaConcepto == null ||
!celdaConcepto.CellType.Equals(CellType.String) ||
String.IsNullOrWhiteSpace(celdaConcepto.StringCellValue) ||
!celdaConcepto.StringCellValue.Contains("idConcepto"))
{
continue;
}
var elementosCelda = celdaConcepto.StringCellValue.Split(';');
var idConcepto = elementosCelda[1];
ConceptoDto concepto;
var indiceColumnaImprimir = celdaConcepto.ColumnIndex + 1;
if (instancia.Taxonomia.ConceptosPorId.TryGetValue(idConcepto, out concepto))
{
if (concepto.EsDimension ?? false)
{
diccionarioContextosSeries =
GeneraContextosSeries(
concepto.Id,
rowImportar,
indiceColumnaImprimir,
hiperCubo.Utileria,
resumenImportacion,
hojaAImportar.SheetName,
instancia,
plantillaDocumento, "es");
if (diccionarioContextosSeries.Count > 0)
{
EliminarHechos(hojaPlantilla, instancia);
}
}
else if (concepto.EsMiembroDimension ?? false)
{
if (hiperCuboCalificaciones == null)
{
hiperCuboCalificaciones = ObtenConfiguracionHipercubo("ar_pros_SecuritiesRatingTable", instancia, plantillaDocumento);
}
diccionarioContextosCalificaciones = GeneraContextosCalificaciones(
concepto,
diccionarioContextosSeries,
hiperCuboCalificaciones.Utileria,
instancia,
plantillaDocumento);
}
else if (!concepto.EsAbstracto ?? false && !concepto.EsHipercubo)
{
var diccionarioContextos = diccionarioContextosSeries;
if (ConceptosCalificaciones.Contains(concepto.Id))
{
if (hiperCuboCalificaciones != null && diccionarioContextosCalificaciones != null)
{
diccionarioContextos = diccionarioContextosCalificaciones;
}
}
GeneraHechos(rowImportar, concepto, diccionarioContextos, instancia, plantillaDocumento, resumenImportacion, hojaAImportar.SheetName);
}
}
}
}
}
/// <summary>
/// Procesa un renglón de la tabla de personas responsables importando su contenido
/// </summary>
/// <returns></returns>
private int ImportarRenglonFigura(int numRow, string idMiembroFiguraActual, ISheet hojaAImportar, DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantillaDocumento, ResumenProcesoImportacionExcelDto resumenImportacion)
{
var institucionesActuales = new Dictionary <string, int>();
DateTime fechaInicio = DateTime.MinValue;
DateTime fechaFin = DateTime.MinValue;
if (XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2014_12_31"), out fechaFin)
&&
XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2014_12_31"), out fechaInicio))
{
//Si inicia un tipo de figura
int lastRowNum = hojaAImportar.LastRowNum;
//Mientras no se termine el documento o no se encuentre el inicio de otra figura
while (numRow <= lastRowNum)
{
var valorCelda = ExcelUtil.ObtenerValorCelda(hojaAImportar, numRow, COL_CONCEPTO_FIGURA);
if (valorCelda != null && _mapeoMiembrosDimension.ContainsKey(valorCelda.Trim()))
{
break;
}
var valorInstitucion = ExcelUtil.ObtenerValorCelda(hojaAImportar, numRow, COL_CONCEPTO_INSTITUCION);
var valorLeyenda = ExcelUtil.ObtenerValorCelda(hojaAImportar, numRow, COL_CONCEPTO_LEYENDA);
var valorNombre = ExcelUtil.ObtenerValorCelda(hojaAImportar, numRow, COL_CONCEPTO_NOMBRE);
var valorCargo = ExcelUtil.ObtenerValorCelda(hojaAImportar, numRow, COL_CONCEPTO_CARGO);
if (!String.IsNullOrEmpty(valorInstitucion) && !String.IsNullOrEmpty(valorNombre) && !String.IsNullOrEmpty(valorCargo))
{
if (!valoresAnterioresBorrados)
{
ReporteXBRLUtil.EliminarHechosConceptos(ID_CONCEPTO_PERSONAS, instancia);
ReporteXBRLUtil.EliminarHechosConceptos(ID_CONCEPTO_INSTITUCION, instancia);
valoresAnterioresBorrados = true;
}
var dimensionFigura = new DimensionInfoDto()
{
Explicita = true,
IdDimension = ID_DIMENSION_FIGURA,
QNameDimension = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[ID_DIMENSION_FIGURA]),
IdItemMiembro = idMiembroFiguraActual,
QNameItemMiembro = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[idMiembroFiguraActual])
};
var dimensionInstitucion = new DimensionInfoDto()
{
Explicita = false,
IdDimension = ID_DIMENSION_TYPED_INSTITUCION,
QNameDimension = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[ID_DIMENSION_TYPED_INSTITUCION])
};
var dimensionPersona = new DimensionInfoDto()
{
Explicita = false,
IdDimension = ID_DIMENSION_TYPED_PERSONA,
QNameDimension = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[ID_DIMENSION_TYPED_PERSONA])
};
if (!institucionesActuales.ContainsKey(valorInstitucion))
{
//Agregar hechos de institución y leyenda
dimensionInstitucion.ElementoMiembroTipificado = String.Format(_templateTypedMemeberInstitucion, secuenciaInstitucion);
institucionesActuales[valorInstitucion] = secuenciaInstitucion;
secuenciaInstitucion++;
ActualizarValorHecho(instancia.Taxonomia.ConceptosPorId[ID_CONCEPTO_INSTITUCION[0]],
valorInstitucion,
new List <DimensionInfoDto>()
{
dimensionFigura, dimensionInstitucion
},
fechaInicio, fechaFin,
plantillaDocumento.ObtenerVariablePorId("esquemaEntidad") + ":" + plantillaDocumento.ObtenerVariablePorId("nombreEntidad"),
instancia, plantillaDocumento, resumenImportacion, hojaAImportar, numRow, COL_CONCEPTO_INSTITUCION);
ActualizarValorHecho(instancia.Taxonomia.ConceptosPorId[ID_CONCEPTO_INSTITUCION[1]],
valorLeyenda,
new List <DimensionInfoDto>()
{
dimensionFigura, dimensionInstitucion
},
fechaInicio, fechaFin,
plantillaDocumento.ObtenerVariablePorId("esquemaEntidad") + ":" + plantillaDocumento.ObtenerVariablePorId("nombreEntidad"),
instancia, plantillaDocumento, resumenImportacion, hojaAImportar, numRow, COL_CONCEPTO_LEYENDA);
}
else
{
dimensionInstitucion.ElementoMiembroTipificado = String.Format(_templateTypedMemeberInstitucion, institucionesActuales[valorInstitucion]);
}
//Agregar hechos de nombre y cargo
dimensionPersona.ElementoMiembroTipificado = String.Format(_templateTypedMemeberPerson, secuenciaPersona++);
ActualizarValorHecho(instancia.Taxonomia.ConceptosPorId[ID_CONCEPTO_PERSONAS[0]],
valorNombre,
new List <DimensionInfoDto>()
{
dimensionFigura, dimensionInstitucion, dimensionPersona
},
fechaInicio, fechaFin,
plantillaDocumento.ObtenerVariablePorId("esquemaEntidad") + ":" + plantillaDocumento.ObtenerVariablePorId("nombreEntidad"),
instancia, plantillaDocumento, resumenImportacion, hojaAImportar, numRow, COL_CONCEPTO_NOMBRE);
ActualizarValorHecho(instancia.Taxonomia.ConceptosPorId[ID_CONCEPTO_PERSONAS[1]],
valorCargo,
new List <DimensionInfoDto>()
{
dimensionFigura, dimensionInstitucion, dimensionPersona
},
fechaInicio, fechaFin,
plantillaDocumento.ObtenerVariablePorId("esquemaEntidad") + ":" + plantillaDocumento.ObtenerVariablePorId("nombreEntidad"),
instancia, plantillaDocumento, resumenImportacion, hojaAImportar, numRow, COL_CONCEPTO_CARGO);
}
numRow++;
}
}
return(numRow);
}
public void ImportarDatosDeHojaExcel(ISheet hojaAImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, string rol, ResumenProcesoImportacionExcelDto resumenImportacion, IDefinicionPlantillaXbrl plantillaDocumento)
{
this.Inicializar(instancia, plantillaDocumento, rol);
String idMiembroFiguraActual = null;
int iRow = 0;
int lastRowNum = hojaAImportar.LastRowNum;
while (iRow <= lastRowNum)
{
//Si inicia un tipo de figura
var valorCelda = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRow, COL_CONCEPTO_FIGURA);
if (!String.IsNullOrEmpty(valorCelda) && _mapeoMiembrosDimension.ContainsKey(valorCelda.Trim()))
{
idMiembroFiguraActual = _mapeoMiembrosDimension[valorCelda.Trim()];
if (idMiembroFiguraActual != null)
{
iRow = ImportarRenglonFigura(iRow + 1, idMiembroFiguraActual, hojaAImportar, instancia, plantillaDocumento, resumenImportacion);
}
}
else
{
iRow++;
}
}
}
/// <summary>
/// Obtiene la configuración para procesar los elementos de la hoja actual.
/// </summary>
/// <param name="hojaPlantilla">Hoja de plantilla que se pertende procesar.</param>
/// <param name="instancia">Documento de instancia que se procesa.</param>
/// <param name="plantillaDocumento">Plantilla de la taxonomía que se procesa.</param>
/// <param name="resumenImportacion">Detalle de la importación.</param>
/// <returns>Configuración del documento a procesar.</returns>
private ConfiguracionReporteExcel427000 GeneraConfiguracionReporte(ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantillaDocumento, ResumenProcesoImportacionExcelDto resumenImportacion = null)
{
var configuracion = new ConfiguracionReporteExcel427000(instancia, plantillaDocumento, resumenImportacion);
configuracion.NombreHoja = hojaPlantilla.SheetName;
for (var indexRow = 0; indexRow < hojaPlantilla.LastRowNum; indexRow++)
{
var row = hojaPlantilla.GetRow(indexRow);
var currentColumn = row.FirstCellNum;
var cell = row.GetCell(currentColumn);
if (cell != null && cell.CellType.Equals(CellType.String))
{
var valorCelda = cell.StringCellValue;
if (valorCelda.Contains("idConcepto"))
{
var splitCell = valorCelda.Split(';');
var idConcepto = splitCell[1];
Dto.ConceptoDto concepto;
if (instancia.Taxonomia.ConceptosPorId.TryGetValue(idConcepto, out concepto))
{
if (concepto.EsHipercubo)
{
configuracion.HipercuboReporte = ObtenConfiguracionHipercubo(concepto.Id, instancia, plantillaDocumento);
}
else if (concepto.EsMiembroDimension ?? false)
{
configuracion.ListaConceptosMiembro.Add(concepto);
}
else if (!(concepto.EsDimension ?? false) && !(concepto.EsAbstracto ?? false))
{
for (var indexColumn = currentColumn; indexColumn < row.LastCellNum; indexColumn++)
{
var celdaConceptoItem = row.GetCell(indexColumn);
if (celdaConceptoItem != null && celdaConceptoItem.CellType.Equals(CellType.String))
{
var valorCeldaItem = celdaConceptoItem.StringCellValue;
if (valorCeldaItem.Contains("idConcepto"))
{
var splitItems = valorCeldaItem.Split(';');
var idConceptoItem = splitItems[1];
ConceptoDto conceptoItem;
if (instancia.Taxonomia.ConceptosPorId.TryGetValue(idConceptoItem, out conceptoItem))
{
configuracion.DiccionarioConceptosPorColumna[indexColumn] = conceptoItem;
}
}
}
}
}
}
}
}
}
return(configuracion);
}
public void ImportarDatosDeHojaExcel(ISheet hojaAImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, string rol, ResumenProcesoImportacionExcelDto resumenImportacion, IDefinicionPlantillaXbrl plantillaDocumento)
{
var configuracion = GeneraConfiguracionReporte(hojaPlantilla, instancia, plantillaDocumento, resumenImportacion);
var diccionarioEtiquetasMiembro = configuracion.ObtenDiccionarioEtiquetasMiembros(rol);
ConceptoDto conceptoMiembroActual = null;
for (var indexRow = hojaAImportar.FirstRowNum; indexRow < hojaAImportar.LastRowNum; indexRow++)
{
var fila = hojaAImportar.GetRow(indexRow);
if (fila != null)
{
var celda = fila.GetCell(fila.FirstCellNum);
if (celda != null)
{
var valor = ExcelUtil.ObtenerValorCelda(celda.CellType, celda).Trim();
ConceptoDto conceptoMiembro;
if (diccionarioEtiquetasMiembro.TryGetValue(valor, out conceptoMiembro))
{
conceptoMiembroActual = conceptoMiembro;
}
else if (conceptoMiembroActual != null)
{
GeneraHechos(fila, conceptoMiembroActual, configuracion);
}
}
}
}
}
public override ResultadoOperacionDto ImportarDatosExcel(Stream archivoEntrada, DocumentoInstanciaXbrlDto instancia, IDictionary <string, bool> conceptosDescartar = null, IList <string> hojasDescartar = null)
{
var res = new ResultadoOperacionDto();
var resumenProceso = new ResumenProcesoImportacionExcelDto()
{
HechosImportados = new Dictionary <string, List <InformacionHechoImportadoExcelDto> >(),
HechosSobreescritos = new List <InformacionHechoSobreescritoDto>(),
InformeErrores = new List <InformeErrorImportacion>(),
TotalHechosImportados = 0
};
res.Resultado = true;
string entryPointTax = instancia.EspacioNombresPrincipal;
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);
plantillaDocumento.Inicializar(instancia);
if (plantillaDocumento.ObtenerRutaPlantillaExcel() != null)
{
using (
var streamPlantilla =
Assembly.GetExecutingAssembly()
.GetManifestResourceStream(plantillaDocumento.ObtenerRutaPlantillaExcel()))
{
if (streamPlantilla != null)
{
Stream streamPlantillaEvaluada = evaluaElementosDescartarPlantillaExcel(streamPlantilla, conceptosDescartar, hojasDescartar, instancia.Taxonomia);
var workBookImportar = WorkbookFactory.Create(archivoEntrada);
var workBookPlantilla = WorkbookFactory.Create(streamPlantillaEvaluada);
if (plantillaDocumento.ValidarPlantillaExcelImportacion(workBookImportar, resumenProceso))
{
for (var iItem = 0; iItem < workBookPlantilla.NumberOfSheets; iItem++)
{
var hojaImportar =
workBookImportar.GetSheet(workBookPlantilla.GetSheetAt(iItem).SheetName);
if (hojaImportar != null)
{
ImportarHojaDeCalculo(hojaImportar, workBookPlantilla.GetSheetAt(iItem), instancia, resumenProceso, plantillaDocumento);
}
}
}
}
}
}
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.StackTrace);
resumenProceso.InformeErrores.Add(new InformeErrorImportacion()
{
Mensaje = "Ocurrió un error al importar el archivo:" + ex.Message
});
res.Resultado = false;
}
res.InformacionExtra = resumenProceso;
return(res);
}
