/// <summary> /// Actualiza el valor de un hecho en el documento de instancia /// </summary> /// <param name="resumenImportacion"></param> /// <param name="hechoActualizar"></param> /// <param name="valorImportar"></param> /// <param name="plantillaDocumento"></param> private void ActualizarValorHecho(Common.Dtos.ResumenProcesoImportacionExcelDto resumenImportacion, HechoDto hechoActualizar, string valorImportar, IDefinicionPlantillaXbrl plantillaDocumento, DocumentoInstanciaXbrlDto instancia, ISheet hojaImportar, int iRenglon, int columna) { var concepto = instancia.Taxonomia.ConceptosPorId[hechoActualizar.IdConcepto]; if (!ActualizarValor(concepto, valorImportar, hechoActualizar, plantillaDocumento)) { resumenImportacion.AgregarErrorFormato( UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, concepto.Id), hojaImportar.SheetName, iRenglon.ToString(), "0", valorImportar); } else { resumenImportacion.TotalHechosImportados++; var hechoImportado = new AbaxXBRLCore.Common.Dtos.InformacionHechoImportadoExcelDto() { IdConcepto = hechoActualizar.IdConcepto, IdHecho = hechoActualizar.Id, ValorImportado = valorImportar, HojaExcel = hojaImportar.SheetName, Renglon = iRenglon, Columna = columna }; resumenImportacion.AgregarHechoImportado(hechoImportado, UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, hechoActualizar.Id)); } }
/// <summary> /// Valida que los hechos de los roles y conceptos que requieran reportarse al acumulado actual tengan las fechas deseadas /// </summary> /// <param name="instancia">Documento de instancia a validar</param> /// <param name="parametros">Parametros de validación</param> /// <param name="fechaTrimestreParam">Fecha de trimestre que se reporta</param> /// <param name="resultadoValidacion">Objeto de resultado de la validación</param> /// <returns></returns> private bool ValidarHechosReportadosAlAcumulado(DocumentoInstanciaXbrlDto instancia, IDictionary <string, string> parametros, DateTime fechaTrimestreParam, ResultadoValidacionDocumentoXBRLDto resultadoValidacion) { var listaConceptosAValidar = new List <string>(); foreach (var rol in ROL_URI_CONCEPTOS_REPORTADOS_AL_ACUMULADO) { var listaConceptosRol = UtilAbax.ObtenerListaConceptosDeRolPresentacion(instancia.Taxonomia, rol); foreach (var concepto in listaConceptosRol) { listaConceptosAValidar.Add(concepto.Id); } } listaConceptosAValidar.AddRange(ID_CONCEPTOS_ACUMULADOS); DateTime fechaInicioEjercicio = new DateTime(fechaTrimestreParam.Year, 1, 1); foreach (var idConcepto in listaConceptosAValidar) { //Si se encuentran hechos, al menos uno debe estar reportado en el acumulado actual if (!ValidarAlMenosunHechoEnPeriodo(idConcepto, instancia, fechaInicioEjercicio, fechaTrimestreParam)) { AgregarError(resultadoValidacion, null, null, String.Format(M_ERROR_RV012, idConcepto), true); return(false); } } return(true); }
public IHttpActionResult AddUsuario() { string jsonString = getFormKeyValue("json"); Usuario usuario = new Usuario(); ResultadoOperacionDto resultado = new ResultadoOperacionDto(); resultado.Resultado = true; JsonConvert.PopulateObject(jsonString, usuario); var correoEnvioNotificacion = usuario.CorreoElectronico; var esLoginActiveDirectory = bool.Parse(ConfigurationManager.AppSettings.Get("LoginActiveDirectory")); if (esLoginActiveDirectory) { if (activeDirectoryConnection == null) { var tipoLoginLDAP = ConfigurationManager.AppSettings.Get("TipoLoginLDAP"); activeDirectoryConnection = (IActiveDirectoryConnection)ServiceLocator.ObtenerFabricaSpring().GetObject(tipoLoginLDAP); } resultado = activeDirectoryConnection.ObtenerUsuario(usuario.CorreoElectronico); correoEnvioNotificacion = null; if (resultado.Resultado && resultado.InformacionExtra != null) { correoEnvioNotificacion = ((UsuarioDto)resultado.InformacionExtra).CorreoElectronico; } else if (UtilAbax.esCorreoValido(usuario.CorreoElectronico)) { correoEnvioNotificacion = usuario.CorreoElectronico; } } //if (resultado.Resultado) { resultado = ValidateUsuario(usuario); if (string.IsNullOrEmpty(resultado.Mensaje)) { var urlHref = getFormKeyValue("urlHref"); if (String.IsNullOrWhiteSpace(urlHref) || urlHref.Contains("localhost") || urlHref.Contains("127.0.0.1")) { urlHref = GetUrlContext(); } resultado = UsuarioService.GuardarUsuario(usuario, IdUsuarioExec, urlHref, correoEnvioNotificacion); var usuarioEmpresa = new UsuarioEmpresa(); usuarioEmpresa.IdUsuario = Convert.ToInt64(resultado.InformacionExtra.ToString()); usuarioEmpresa.IdEmpresa = IdEmpresa; resultado = UsuarioService.GuardarUsuarioEmpresa(usuarioEmpresa, IdUsuarioExec); resultado.Mensaje = resultado.Resultado ? AbaxXbrl.UsuarioGuardado : AbaxXbrl.ErrorUsuarioGuardado; } return(Ok(resultado)); }
public String CreaHashInstitucion(MapaPersonasResponsables elemento) { var builder = new StringBuilder(); builder.Append(elemento.Fecha.ToString()); builder.Append(elemento.Entidad); builder.Append(elemento.IdTipoPersonaResponsable); builder.Append(elemento.IdSecuenciaInstitucion); return(UtilAbax.CalcularHash(builder.ToString())); }
/// <summary> /// Metodo recursivo que procesa los conceptos del rol actual y genera un listado de conceptos con sus hechos y dimensiones /// </summary> /// <param name="documentoInstanciaXbrlDto">Modelo DTO</param> /// <param name="uriRolPresentacion">uri del rol a procesar</param> /// <param name="listaConceptos">lista que contiene los conceptos procesados</param> /// <param name="estructura">contiene el concepto a procesar</param> /// <param name="taxonomia">Objeto de taxonomía utilizado para obtener etiquetas de presentación</param> /// <param name="idioma">Idioma de presentación</param> /// <param name="indentacion">Nivel del concepto</param> /// <param name="columnas">lista de columnas que tiene el reporte</param> /// <param name="listaDeConceptosEnHiperCubos">lista de conceptos que el rol a procesar tiene en hipercubos</param> private void AgregarNodoEstructura(DocumentoInstanciaXbrlDto documentoInstanciaXbrlDto, string uriRolPresentacion, List <EstructuraConceptoReporte> listaConceptos, EstructuraFormatoDto estructura, TaxonomiaDto taxonomia, string idioma, int indentacion, List <EstructuraColumnaReporte> columnas, IEnumerable <string> listaDeConceptosEnHiperCubos, bool agruparPorUnidad, IEnumerable <string> conceptosIdPermitidos) { if (!conceptosIdPermitidos.Contains(estructura.IdConcepto)) { return; } string nombreconcepto = string.Empty; var concepto = taxonomia.ConceptosPorId[estructura.IdConcepto]; if (string.IsNullOrEmpty(estructura.RolEtiquetaPreferido)) { nombreconcepto = UtilAbax.ObtenerEtiqueta(taxonomia, estructura.IdConcepto, Etiqueta.RolEtiqueta, idioma); } else { nombreconcepto = UtilAbax.ObtenerEtiqueta(taxonomia, estructura.IdConcepto, estructura.RolEtiquetaPreferido, idioma); } if (listaDeConceptosEnHiperCubos.Contains(estructura.IdConcepto)) { IList <EstructuraConceptoReporte> conceptosConDimension = BuscarConceptosConDimensiones(taxonomia, documentoInstanciaXbrlDto, concepto, uriRolPresentacion, idioma, columnas, nombreconcepto, indentacion, agruparPorUnidad); if (conceptosConDimension.Any()) { listaConceptos.AddRange(conceptosConDimension); } } else { var hechoSinDimension = ObtenerPrimerHechoSinDimension(documentoInstanciaXbrlDto, concepto, uriRolPresentacion, idioma, columnas, agruparPorUnidad); listaConceptos.Add(new EstructuraConceptoReporte() { ConceptoId = concepto.Id, NombreConcepto = nombreconcepto, NivelIndentacion = indentacion, EsAbstracto = concepto.EsAbstracto, Hechos = hechoSinDimension, Dimensiones = new Dictionary <string, EstructuraDimensionReporte>() }); } if (estructura.SubEstructuras != null) { indentacion++; foreach (var subEstructura in estructura.SubEstructuras) { AgregarNodoEstructura(documentoInstanciaXbrlDto, uriRolPresentacion, listaConceptos, subEstructura, taxonomia, idioma, indentacion, columnas, listaDeConceptosEnHiperCubos, agruparPorUnidad, conceptosIdPermitidos); } indentacion--; } }
/// <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> /// 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)); } } }
public IHttpActionResult UpdateUsuario() { var jsonString = getFormKeyValue("json"); var usuario = new Usuario(); var correoNotificacion = ""; JsonConvert.PopulateObject(jsonString, usuario); ResultadoOperacionDto resultado = ValidateUsuario(usuario); if (string.IsNullOrEmpty(resultado.Mensaje)) { var user = UsuarioService.ObtenerUsuarioPorId(usuario.IdUsuario).InformacionExtra as Usuario; user.Nombre = usuario.Nombre; user.ApellidoPaterno = usuario.ApellidoPaterno; user.ApellidoMaterno = usuario.ApellidoMaterno; user.CorreoElectronico = usuario.CorreoElectronico; user.Puesto = usuario.Puesto; correoNotificacion = user.CorreoElectronico; var esLoginActiveDirectory = bool.Parse(ConfigurationManager.AppSettings.Get("LoginActiveDirectory")); if (esLoginActiveDirectory) { if (activeDirectoryConnection == null) { var tipoLoginLDAP = ConfigurationManager.AppSettings.Get("TipoLoginLDAP"); activeDirectoryConnection = (IActiveDirectoryConnection)ServiceLocator.ObtenerFabricaSpring().GetObject(tipoLoginLDAP); } resultado = activeDirectoryConnection.ObtenerUsuario(usuario.CorreoElectronico); correoNotificacion = null; if (resultado.Resultado && resultado.InformacionExtra != null) { correoNotificacion = ((UsuarioDto)resultado.InformacionExtra).CorreoElectronico; } else if (UtilAbax.esCorreoValido(usuario.CorreoElectronico)) { correoNotificacion = usuario.CorreoElectronico; } } resultado = UsuarioService.GuardarUsuario(user, IdUsuarioExec, GetUrlContext(), correoNotificacion); resultado.Mensaje = resultado.Resultado ? AbaxXbrl.UsuarioGuardado : AbaxXbrl.ErrorUsuarioGuardado; } return(Ok(resultado)); }
public void CargarInformacionFinancieraComprimidaEnMongoDB() { var conectionServer = new ConnectionServer { //connectionString = "mongodb://*****:*****@ds048878.mongolab.com:48878/abaxxbrl", miBaseDatos = "abaxxbrl" }; conectionServer.init(); var conexion = new Conexion(conectionServer); var blockStore = new BlockStoreDocumentoInstancia(conexion); var BlockStoreHechoService = new BlockStoreHechoService { BlockStoreDocumentoInstancia = blockStore, Collection = "InfFinanXbrl" }; var streamReader = new StreamReader("d:/InformacionFinancieraJSON1.zip"); var stream = streamReader.BaseStream; using (var zipFile = ZipFile.Read(stream)) { var tmpDir = UtilAbax.ObtenerDirectorioTemporal(); zipFile.ExtractAll("d:/TemporalesJson1", ExtractExistingFileAction.OverwriteSilently); foreach (var archivoInterno in zipFile) { if (!archivoInterno.IsDirectory) { var json = ""; using (var streamReaderFile = new StreamReader("d:/TemporalesJson1" + Path.DirectorySeparatorChar + archivoInterno.FileName)) json = streamReaderFile.ReadToEnd(); var settings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }; var documentoInstanciXbrlDto = JsonConvert.DeserializeObject <DocumentoInstanciaXbrlDto>(json, settings); var resultadoOperacion = BlockStoreHechoService.registrarHechosDocumentoInstancia(documentoInstanciXbrlDto, 1, 1); } } } }
/// <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); }
/// <summary> /// Proceso que transforma una cadena (serializada JSON) en un identificador único. /// </summary> /// <param name="json">Cadena con objeto JSON</param> /// <returns>Hash generado del objeto json.</returns> public string GeneraHash(string json) { return(UtilAbax.CalcularHash(json)); }
public void ConsultaPersonasResponsables() { var AbaxXBRLCellStoreMongo = new AbaxXBRLCellStoreMongo(); AbaxXBRLCellStoreMongo.ConnectionString = ConectionString; AbaxXBRLCellStoreMongo.DataBaseName = DatabaseName; AbaxXBRLCellStoreMongo.JSONOutDirectory = JsonErrorDirectory; AbaxXBRLCellStoreMongo.Init(); var listaElementos = AbaxXBRLCellStoreMongo.ConsultaElementos <MapaPersonasResponsables>("PersonasResponsablesReducido", "{}"); var diccionarioElementosInstitucion = new Dictionary <String, IList <MapaPersonasResponsables> >(); var diccionarioInstituciones = new Dictionary <String, MapaPersonasResponsables>(); var diccionarioPorPersona = new Dictionary <String, PersonaResponsable>(); foreach (var elemento in listaElementos) { elemento.HashInstitucion = CreaHashInstitucion(elemento); if (elemento.IdConcepto.Equals("ar_pros_ResponsiblePersonInstitution")) { if (!diccionarioInstituciones.ContainsKey(elemento.HashInstitucion)) { diccionarioInstituciones.Add(elemento.HashInstitucion, elemento); } } else if (!String.IsNullOrEmpty(elemento.IdSecuenciaPersona)) { elemento.HashPersona = UtilAbax.CalcularHash(elemento.HashInstitucion + elemento.IdSecuenciaPersona); IList <MapaPersonasResponsables> listaPersonasMap; if (!diccionarioElementosInstitucion.TryGetValue(elemento.HashInstitucion, out listaPersonasMap)) { listaPersonasMap = new List <MapaPersonasResponsables>(); diccionarioElementosInstitucion.Add(elemento.HashInstitucion, listaPersonasMap); } listaPersonasMap.Add(elemento); } } foreach (var hashInstitucion in diccionarioElementosInstitucion.Keys) { MapaPersonasResponsables elementoInstitucion; IList <MapaPersonasResponsables> listaElementosIterar; if (!diccionarioInstituciones.TryGetValue(hashInstitucion, out elementoInstitucion) || !diccionarioElementosInstitucion.TryGetValue(hashInstitucion, out listaElementosIterar)) { continue; } foreach (var elemento in listaElementosIterar) { PersonaResponsable personaResponsable; if (!diccionarioPorPersona.TryGetValue(elemento.HashPersona, out personaResponsable)) { personaResponsable = new PersonaResponsable(); personaResponsable.Entidad = elementoInstitucion.Entidad; personaResponsable.Fecha = elementoInstitucion.Fecha; personaResponsable.TipoPersonaResponsable = elementoInstitucion.TipoPersonaResponsable; personaResponsable.Institucion = elementoInstitucion.Valor; personaResponsable.IdTipoPersonaResponsable = elementoInstitucion.IdTipoPersonaResponsable; diccionarioPorPersona.Add(elemento.HashPersona, personaResponsable); if (String.IsNullOrEmpty(personaResponsable.TipoPersonaResponsable)) { personaResponsable.TipoPersonaResponsable = DeterminaEtiquetaTipoPersonaResponsable(elementoInstitucion.IdTipoPersonaResponsable); } } if (elemento.IdConcepto.Equals("ar_pros_ResponsiblePersonPosition")) { personaResponsable.Cargo = elemento.Valor; } else if (elemento.IdConcepto.Equals("ar_pros_ResponsiblePersonName")) { personaResponsable.Nombre = elemento.Valor; } } } //if (File.Exists(PathArchivoPersonasResponsables)) //{ // File.Delete(PathArchivoPersonasResponsables); //} //File.Create(PathArchivoPersonasResponsables); using (StreamWriter w = File.AppendText(PathArchivoPersonasResponsables)) { foreach (var hashPersona in diccionarioPorPersona.Keys) { var persona = diccionarioPorPersona[hashPersona]; var linea = CreaLineaPersonaResponsable(persona); w.Write(linea); //File.AppendAllText(PathArchivoPersonasResponsables, "text content" + Environment.NewLine); } w.Close(); } }
/// <summary> /// Genera las columnas para el reporte y un listado de los conceptos procesados con o sin dimension /// </summary> /// <param name="documentoInstanciaXbrlDto">Modelo DTO</param> /// <param name="rolActual">rol a procesar</param> /// <param name="listaDeConceptosEnHiperCubos">lista de conceptos que el rol a procesar tiene en hipercubos</param> /// <param name="idioma">Idioma de presentación</param> /// <returns></returns> private EstructuraRolReporte listaDeConceptosPorRol(DocumentoInstanciaXbrlDto documentoInstanciaXbrlDto, RolDto <EstructuraFormatoDto> rolActual, IEnumerable <string> listaDeConceptosEnHiperCubos, string idioma, bool agruparPorUnidad) { int indentacion = 0; var listaDeConceptos = new List <EstructuraConceptoReporte>(); var estructuraReporteGenericoPorRol = new EstructuraRolReporte(); estructuraReporteGenericoPorRol.RolUri = rolActual.Uri; estructuraReporteGenericoPorRol.Rol = rolActual.Nombre; // llenar columnas del reporte estructuraReporteGenericoPorRol.ColumnasDelReporte = new List <EstructuraColumnaReporte>(); var conceptosIdPermitidos = UtilAbax.ObtenerListaConceptosDeRolPresentacion(documentoInstanciaXbrlDto.Taxonomia, rolActual.Uri) .Where(x => !((x.EsDimension != null?x.EsDimension.Value:false) || x.EsHipercubo || (x.EsMiembroDimension != null?x.EsMiembroDimension.Value:false))) .Select(x => x.Id); foreach (var conceptoId in conceptosIdPermitidos) { if (documentoInstanciaXbrlDto.HechosPorIdConcepto.ContainsKey(conceptoId)) { foreach (var idHecho in documentoInstanciaXbrlDto.HechosPorIdConcepto[conceptoId]) { var hecho = documentoInstanciaXbrlDto.HechosPorId[idHecho]; if (hecho.IdContexto != null) { var contexto = documentoInstanciaXbrlDto.ContextosPorId[hecho.IdContexto]; //Verificar si este hecho cabe en alguna de las columnas var columnaYaExiste = false; foreach (var columna in estructuraReporteGenericoPorRol.ColumnasDelReporte) { if (HechoPerteneceAColumna(hecho, documentoInstanciaXbrlDto, columna, agruparPorUnidad)) { columnaYaExiste = true; break; } } if (!columnaYaExiste) { estructuraReporteGenericoPorRol.ColumnasDelReporte.Add(CrearColumnaEncabezado(hecho, documentoInstanciaXbrlDto, agruparPorUnidad)); } } } } } if (estructuraReporteGenericoPorRol.ColumnasDelReporte.Count > 1) { estructuraReporteGenericoPorRol.ColumnasDelReporte = OrdenarFechaDeColumnas(estructuraReporteGenericoPorRol.ColumnasDelReporte); } Debug.WriteLine(estructuraReporteGenericoPorRol.Rol); foreach (var col in estructuraReporteGenericoPorRol.ColumnasDelReporte) { Debug.WriteLine(col.Entidad + "," + DateUtil.ToStandarString(col.FechaInicio) + " - " + DateUtil.ToStandarString(col.FechaFin) + " - " + DateUtil.ToStandarString(col.FechaInstante) + "," + col.Moneda ); } if (documentoInstanciaXbrlDto.Taxonomia != null && documentoInstanciaXbrlDto.Taxonomia.RolesPresentacion != null) { foreach (var estructura in rolActual.Estructuras) { AgregarNodoEstructura(documentoInstanciaXbrlDto, rolActual.Uri, listaDeConceptos, estructura, documentoInstanciaXbrlDto.Taxonomia, idioma, indentacion, estructuraReporteGenericoPorRol.ColumnasDelReporte, listaDeConceptosEnHiperCubos, agruparPorUnidad, conceptosIdPermitidos); } } estructuraReporteGenericoPorRol.Conceptos = listaDeConceptos; return(estructuraReporteGenericoPorRol); }
private void ActualizarValorHecho(ConceptoDto concepto, string valorCelda, List <DimensionInfoDto> dimensiones, DateTime fechaInicio, DateTime fechaFin, string qNameEntidad, DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantillaDocumento, AbaxXBRLCore.Common.Dtos.ResumenProcesoImportacionExcelDto resumenImportacion, ISheet hojaImportar, int iRenglon, int columna) { if (String.IsNullOrEmpty(valorCelda)) { return; } var fechaDefault = plantillaDocumento.ObtenerVariablePorId("fecha_2015_01_01"); List <HechoDto> hechosAActualizar = new List <HechoDto>(); var hechos = instancia.BuscarHechos(concepto.Id, null, null, fechaInicio, fechaFin, dimensiones); if (hechos.Count > 0) { hechosAActualizar.AddRange(hechos); } else { var qNameCompleto = XmlUtil.ParsearQName(qNameEntidad); ContextoDto contextoDestino = null; var tipoPeriodo = concepto.TipoPeriodo.Equals(EtiquetasXBRLConstantes.Instant) ? Period.Instante : Period.Duracion; var contextos = instancia.BuscarContexto(qNameEntidad, tipoPeriodo, fechaInicio, fechaFin, dimensiones); if (contextos == null || contextos.Count == 0) { contextoDestino = new ContextoDto() { Entidad = new EntidadDto() { ContieneInformacionDimensional = false, EsquemaId = qNameCompleto.Namespace, Id = qNameCompleto.Name }, ContieneInformacionDimensional = dimensiones.Count > 0, ValoresDimension = dimensiones, Periodo = new PeriodoDto() { Tipo = tipoPeriodo, FechaInicio = fechaInicio, FechaFin = fechaFin, FechaInstante = fechaFin }, Id = "C" + Guid.NewGuid().ToString() }; plantillaDocumento.InyectarContextoADocumentoInstancia(contextoDestino); } else { contextoDestino = contextos[0]; } UnidadDto unidadDestino = null; if (concepto.EsTipoDatoNumerico) { var listaMedidas = new List <MedidaDto>() { new MedidaDto() { EspacioNombres = plantillaDocumento.ObtenerVariablePorId("medida_http___www_xbrl_org_2003_iso4217"), Nombre = plantillaDocumento.ObtenerVariablePorId("medida_MXN") } }; var unidades = instancia.BuscarUnidades(Unit.Medida, listaMedidas, null); if (unidades == null || unidades.Count == 0) { unidadDestino = new UnidadDto() { Id = "U" + Guid.NewGuid().ToString(), Tipo = Unit.Medida, Medidas = listaMedidas }; instancia.UnidadesPorId.Add(unidadDestino.Id, unidadDestino); } else { unidadDestino = unidades[0]; } } var hechoNuevo = instancia.CrearHecho(concepto.Id, unidadDestino != null ? unidadDestino.Id : null, contextoDestino.Id, "A" + Guid.NewGuid().ToString()); if (concepto.EsTipoDatoNumerico) { hechoNuevo.Valor = "0"; hechoNuevo.Decimales = _valorDecimalesHechos; } hechosAActualizar.Add(hechoNuevo); plantillaDocumento.InyectaHechoADocumentoInstancia(hechoNuevo); } foreach (var hechoActualizar in hechosAActualizar) { var conceptoImportar = instancia.Taxonomia.ConceptosPorId[hechoActualizar.IdConcepto]; if (!UtilAbax.ActualizarValorHecho(conceptoImportar, hechoActualizar, valorCelda, fechaDefault)) { resumenImportacion.AgregarErrorFormato( UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, conceptoImportar.Id), hojaImportar.SheetName, iRenglon.ToString(), columna.ToString(), valorCelda); } else { resumenImportacion.TotalHechosImportados++; var hechoImportado = new AbaxXBRLCore.Common.Dtos.InformacionHechoImportadoExcelDto() { IdConcepto = hechoActualizar.IdConcepto, IdHecho = hechoActualizar.Id, ValorImportado = valorCelda, HojaExcel = hojaImportar.SheetName, Renglon = iRenglon, Columna = columna }; 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 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 crearExistenceAssertionNumericos() { StringBuilder builder = new StringBuilder(); //Unir las existence al EA set var eaSetPadre = "Assertion_Set_EA_ElementosNumericos"; var fvFechaCierre = "factVariable_DateOfEndOfReportingPeriod2013"; var filtroPeriodInstant = "periodInstant_FechaCierre_Filter"; var filtroOr = "orFilter_3"; var etiquetaEA = ""; var etiquetaFV = ""; var etiquetaConceptName = ""; var etiquetaMensaje = ""; var taxonomia = new TaxonomiaXBRL(); taxonomia.ManejadorErrores = new ManejadorErroresCargaTaxonomia(); taxonomia.ProcesarDefinicionDeEsquema("file:///TaxonomiasXBRL/mx-bmv-fideicomisos-2015/trac/full_ifrs_trac_entry_point_2015-06-30.xsd"); taxonomia.CrearArbolDeRelaciones(); var viewService = new XbrlViewerService(); var taxoDTO = viewService.CrearTaxonomiaAPartirDeDefinicionXbrl(taxonomia); builder.AppendLine("<!-- Inicio Validaciones EA SET Numericas -->"); foreach (var concepto in taxoDTO.ConceptosPorId.Values) { var EsAbstracto = concepto.EsAbstracto != null ? concepto.EsAbstracto.Value : false; if (concepto.EsTipoDatoNumerico && !EsAbstracto) { //Crear existence assertion etiquetaEA = "EA_" + concepto.Nombre; etiquetaFV = "factVariable_ea_" + concepto.Nombre; etiquetaConceptName = "conceptName_ea_" + concepto.Nombre; etiquetaMensaje = "mensaje_ea_" + concepto.Nombre; builder.AppendLine(String.Format(EA_template, etiquetaEA)); builder.AppendLine(String.Format(EA_TO_AS_template, new Object[] { eaSetPadre, etiquetaEA })); builder.AppendLine(String.Format(Fact_Variable_template, etiquetaFV)); //FV del concepto builder.AppendLine(String.Format(Concept_Name_template, etiquetaConceptName, taxonomia.ObtenerPrefijoDeEspacioNombres(concepto.EspacioNombres), concepto.Nombre)); builder.AppendLine(String.Format(Variable_filter_arc_template, new Object[] { etiquetaFV, etiquetaConceptName })); builder.AppendLine(String.Format(Variable_arc_template, new Object[] { etiquetaEA, etiquetaFV, concepto.Nombre })); builder.AppendLine(String.Format(Message_template, new Object[] { etiquetaMensaje, UtilAbax.ObtenerEtiqueta(taxoDTO, concepto.Id) })); builder.AppendLine(String.Format(Message_Assertion_Arc_Template, new Object[] { etiquetaEA, etiquetaMensaje })); builder.AppendLine(""); builder.AppendLine(""); } } builder.AppendLine("<!-- Fin Validaciones EA SET Numericas -->"); Debug.WriteLine(builder.ToString()); }
/// <summary> /// Crea los hechos en base a la configuración. /// </summary> /// <param name="fila">Fila donde se obtendrán los datos para genarar los hechos.</param> /// <param name="contexto">Contexto al que pertenecen los nuevos hechos.</param> /// <param name="configuracion">Configuración con la información general para la generación de los hechos.</param> private void GeneraHechos(IRow fila, ConceptoDto conceptoMiembroActual, ConfiguracionReporteExcel427000 configuracion) { var fechaDefault = configuracion.FechaDefault; Dto.ContextoDto contextoActual = null; var registroGenerado = false; foreach (var indexColumna in configuracion.DiccionarioConceptosPorColumna.Keys) { var celda = fila.GetCell(indexColumna); String valorHecho = null; if (celda != null && !celda.CellType.Equals(CellType.Blank)) { valorHecho = ExcelUtil.ObtenerValorCelda(celda.CellType, celda); } if (String.IsNullOrEmpty(valorHecho)) { if (!registroGenerado) { return; } else { //valorHecho = String.Empty; continue; } } ConceptoDto concepto; if (configuracion.DiccionarioConceptosPorColumna.TryGetValue(indexColumna, out concepto)) { if (contextoActual == null) { contextoActual = GeneraContextoMiembro(conceptoMiembroActual, configuracion); } configuracion.InicializaImportacion(); String idUnidad = null; String decimales = null; var idConcepto = concepto.Id; UnidadDto unidad; if (configuracion.DiccionarioUnidadesPorIdConcepto.TryGetValue(idConcepto, out unidad)) { idUnidad = unidad.Id; configuracion.DiccionarioDecimalesPorIdConcepto.TryGetValue(idConcepto, out decimales); } var idHecho = "A" + Guid.NewGuid().ToString(); var hechoNuevo = configuracion.Instancia.CrearHecho(concepto.Id, idUnidad, contextoActual.Id, idHecho); hechoNuevo.Decimales = decimales; if (!UtilAbax.ActualizarValorHecho(concepto, hechoNuevo, valorHecho, fechaDefault)) { configuracion.ResumenImportacion.AgregarErrorFormato( UtilAbax.ObtenerEtiqueta(configuracion.Instancia.Taxonomia, concepto.Id), configuracion.NombreHoja, fila.RowNum.ToString(), indexColumna.ToString(), valorHecho); } else { configuracion.ResumenImportacion.TotalHechosImportados++; var hechoImportado = new AbaxXBRLCore.Common.Dtos.InformacionHechoImportadoExcelDto() { IdConcepto = hechoNuevo.IdConcepto, IdHecho = hechoNuevo.Id, ValorImportado = valorHecho, HojaExcel = configuracion.NombreHoja, Renglon = fila.RowNum, Columna = indexColumna }; configuracion.ResumenImportacion.AgregarHechoImportado(hechoImportado, UtilAbax.ObtenerEtiqueta(configuracion.Instancia.Taxonomia, hechoNuevo.Id)); } configuracion.PlantillaDocumento.InyectaHechoADocumentoInstancia(hechoNuevo); registroGenerado = true; } } }
/// <inheritdoc/> public ResultadoOperacionDto ProcesarXbrlSobre(string rutaArchivo, string cvePizarra) { ResultadoOperacionDto resultadoOperacionDto = new ResultadoOperacionDto { Resultado = false }; ResultadoRecepcionSobreXBRLDTO resultadoRecepcionSobreXBRLDTO = new ResultadoRecepcionSobreXBRLDTO(); var pathXbrlAdjunto = ""; var parametros = new Dictionary <string, string>(); parametros.Add("cvePizarra", cvePizarra); //Se obtiene el objeto ResultadoRecepcionSobreXBRLDTO de la ubicación especificada. resultadoOperacionDto = ObtenerSobreXbrl(rutaArchivo); if (resultadoOperacionDto.Resultado) { resultadoRecepcionSobreXBRLDTO = (ResultadoRecepcionSobreXBRLDTO)resultadoOperacionDto.InformacionExtra; } if (resultadoRecepcionSobreXBRLDTO != null) { //Llamamos al servicio para obtener el xbrl adjunto. resultadoOperacionDto = AlmacenarDocumentoInstanciaService.ObtenerPathTemporalXBRLAdjunto(resultadoRecepcionSobreXBRLDTO); pathXbrlAdjunto = (String)resultadoOperacionDto.InformacionExtra; } if (resultadoOperacionDto.Resultado) { resultadoOperacionDto = EmpresaService.ValidarTickersXbrlSobre(cvePizarra, resultadoRecepcionSobreXBRLDTO.claveCotizacion); if (resultadoOperacionDto.Resultado) { parametros.Add("cveFideicomitente", resultadoRecepcionSobreXBRLDTO.claveCotizacion); ResultadoOperacionDto resultadoOperacionObtenerPeriodicidadDto = new ResultadoOperacionDto(); resultadoOperacionObtenerPeriodicidadDto = DocumentoInstanciaService.ObtenerPeriodicidadReportePorEspacioNombresPrincipal(resultadoRecepcionSobreXBRLDTO.espacioNombresArchivoAdjunto); //Revisar que periodicidad es la taxonomia para asignar valorPeroiodo o fechaTrimestre según sea el caso. if (resultadoOperacionDto.Resultado) { PeriodicidadReporte periodicidadReporte = (PeriodicidadReporte)resultadoOperacionObtenerPeriodicidadDto.InformacionExtra; switch (periodicidadReporte.Nombre) { case "Anual": //para anual el validador solo verifica que sea un año. parametros.Add("valorPeroiodo", resultadoRecepcionSobreXBRLDTO.anioReportado.ToString()); break; case "Mensual": //para anexto T solo se verifica que el periodo sea de un año y mes válido. if (resultadoRecepcionSobreXBRLDTO.mesReportado != null && resultadoRecepcionSobreXBRLDTO.mesReportado.ToString().Count() > 0) { string mesReportado = resultadoRecepcionSobreXBRLDTO.mesReportado.ToString().Count() == 1 ? "0" + resultadoRecepcionSobreXBRLDTO.mesReportado.ToString() : resultadoRecepcionSobreXBRLDTO.mesReportado.ToString(); parametros.Add("valorPeroiodo", resultadoRecepcionSobreXBRLDTO.anioReportado.ToString() + "-" + mesReportado + "-01"); } break; case "Trimestral": //para trimestrales se válida la fecha fin de periodo. parametros.Add("fechaTrimestre", UtilAbax.obtenerFechaTrimestre(resultadoRecepcionSobreXBRLDTO.anioReportado.Value, resultadoRecepcionSobreXBRLDTO.trimestreReportado)); break; default: break; } } if (!pathXbrlAdjunto.Equals("")) { resultadoOperacionDto = ValidarDocumentoInstanciaService.ValidarDocumentoInstanciaXBRL(null, pathXbrlAdjunto, resultadoRecepcionSobreXBRLDTO.nombreArchivoAdjunto, parametros); if (resultadoOperacionDto.Resultado) { resultadoOperacionDto = AlmacenarDocumentoInstanciaService.GuardarDocumentoInstanciaXBRL(null, pathXbrlAdjunto, resultadoRecepcionSobreXBRLDTO.nombreArchivoAdjunto, parametros); //Se mandan los mensajes de distribucion a la cola. /*if (resultado.Resultado) * { * var identificadorDocNuevo = resultado.InformacionExtra as long[]; * * var idDocmentoInstancia = identificadorDocNuevo[0]; * var idVersionDocumento = identificadorDocNuevo[1]; * if (USAR_QUEUE) * { * var envioMensajes = (ProcesarDocumentoXBRLEmsGateway)ServiceLocator.ObtenerFabricaSpring().GetObject("ProcesarDocumentoXBRLGateway"); * envioMensajes.EnviarSolicitudProcesarXBRL(idDocmentoInstancia, idVersionDocumento); * } * }*/ } } } } return(resultadoOperacionDto); }
public ResultadoOperacionDto GuardarUsuario(Usuario usuario, long idUsuarioExec, String url, String correoElectronico) { var esLoginActiveDirectory = bool.Parse(ConfigurationManager.AppSettings.Get("LoginActiveDirectory")); var resultado = new ResultadoOperacionDto(); try { bool envio = false; var pass = String.Empty; if (usuario.IdUsuario == 0) { usuario.Activo = true; if (esLoginActiveDirectory) { usuario.VigenciaPassword = DateTime.Now.AddYears(50); } else { usuario.VigenciaPassword = DateTime.Now.AddDays(-1); } usuario.Bloqueado = false; usuario.HistoricoPassword = String.Empty; usuario.IntentosErroneosLogin = 0; pass = UtilAbax.GenerarCodigo(); usuario.Password = pass; var salt = usuario.Password.Substring(usuario.Password.Length - PasswordHashGenerator.TAMANIO_B64_NUMERO_SALT); usuario.Password = PasswordHashGenerator.CreatePasswordHash(usuario.Password, salt); envio = true; } var param = new List <object>() { usuario.CorreoElectronico }; var informacionAuditoria = new InformacionAuditoriaDto(idUsuarioExec, usuario.IdUsuario == 0 ? ConstantsAccionAuditable.Insertar : ConstantsAccionAuditable.Actualizar, ConstantsModulo.Usuarios, usuario.IdUsuario == 0 ? MensajesServicios.InsertarUsuario : MensajesServicios.Actualizarusuario, param); resultado = Repository.GuardarUsuario(usuario); resultado.InformacionAuditoria = informacionAuditoria; if (resultado.Resultado && envio && (!esLoginActiveDirectory || UtilAbax.esCorreoValido(usuario.CorreoElectronico))) { Repository.EnvioCorreoRegistro(usuario, pass, url); } else if (resultado.Resultado && envio && esLoginActiveDirectory && correoElectronico != null) { Repository.EnvioCorreoRegistroLDAP(usuario, url, correoElectronico); } } catch (Exception exception) { resultado.Resultado = false; resultado.Mensaje = exception.Message; resultado.InformacionExtra = exception; } return(resultado); }
/// <summary> /// Actualiza el valor de un hecho en base a su tipo y valor /// </summary> /// <param name="concepto"></param> /// <param name="valorCelda"></param> /// <param name="hechoNuevo"></param> private Boolean ActualizarValor(ConceptoDto concepto, string valorCelda, AbaxXBRLCore.Viewer.Application.Dto.HechoDto hechoNuevo, IDefinicionPlantillaXbrl plantilla) { var fechaDefault = plantilla.ObtenerVariablePorId("fecha_2014_12_31"); return(UtilAbax.ActualizarValorHecho(concepto, hechoNuevo, valorCelda, fechaDefault)); }
/// <summary> /// Realiza el armado del repositorio de información XBRL /// </summary> /// <param name="listEntEstructuraInstancia">Estructura de los hechos que se van a registrar en el repositorio de informacion</param> /// <returns></returns> public List <EntBlockStoreDocumentosyFiltros> armarBlockStoreHashConsulta(List <EntEstructuraInstancia> listEntEstructuraInstancia) { var listadoDocumentos = new List <EntBlockStoreDocumentosyFiltros>(); foreach (var itemEstructuraInstancia in listEntEstructuraInstancia) { var blockStoreDocumentosyFiltros = new EntBlockStoreDocumentosyFiltros { registroBlockStore = new BsonDocument(), filtrosBlockStore = new BsonDocument(), EsValorChunks = false }; var estructuraClone = (EntEstructuraInstancia)itemEstructuraInstancia.Clone(); estructuraClone.Valor = null; estructuraClone.ValorRedondeado = 0; itemEstructuraInstancia.codigoHashRegistro = UtilAbax.CalcularHash(estructuraClone.ToJson()); var elemento = ConstEstandar.AperturaLlave; elemento += string.Format(ConstBlockStoreHechos.CodigoHashRegistro, itemEstructuraInstancia.codigoHashRegistro); blockStoreDocumentosyFiltros.CodigoHashRegistro = itemEstructuraInstancia.codigoHashRegistro; //elemento += string.Format(ConstBlockStoreHechos.Trimestre, itemEstructuraInstancia.Trimestre); //elemento += string.Format(ConstBlockStoreHechos.Ejercicio, itemEstructuraInstancia.Ejercicio); elemento += string.Format(ConstBlockStoreHechos.Taxonomia, itemEstructuraInstancia.EspacioNombresPrincipal); elemento += string.Format(ConstBlockStoreHechos.Entidad, itemEstructuraInstancia.Entidad.miId, itemEstructuraInstancia.Entidad.miEspaciodeNombresEntidad); elemento += !string.IsNullOrEmpty(itemEstructuraInstancia.Rol) ? string.Format(ConstBlockStoreHechos.Roll, itemEstructuraInstancia.Rol) : string.Empty; elemento += string.Format(ConstBlockStoreHechos.Concepto, itemEstructuraInstancia.Concepto.Id, itemEstructuraInstancia.Concepto.Nombre, itemEstructuraInstancia.EspacioNombresPrincipal, itemEstructuraInstancia.Concepto.EspacioNombres); if (itemEstructuraInstancia.Concepto.etiqueta != null && itemEstructuraInstancia.Concepto.etiqueta.Count > 0) { string valorEtiqueta = ""; foreach (var etiqueta in itemEstructuraInstancia.Concepto.etiqueta) { if (etiqueta.roll.Equals("http://www.xbrl.org/2003/role/label")) { valorEtiqueta += string.Format(ConstBlockStoreHechos.EstructuraEtiqueta, etiqueta.lenguaje, etiqueta.valor.Replace(ConstEstandar.ComillaSimple, string.Empty), etiqueta.roll.Replace(ConstEstandar.ComillaSimple, string.Empty)); valorEtiqueta += ConstEstandar.SeparadorComa; } } var etiquetas = string.Format(ConstBlockStoreHechos.ConceptoEtiqueta, valorEtiqueta.Substring(0, valorEtiqueta.Length + ConstEstandar.MenosTres)); elemento += etiquetas; } elemento += !string.IsNullOrEmpty(itemEstructuraInstancia.TipoBalance) ? string.Format(ConstBlockStoreHechos.Balance, itemEstructuraInstancia.TipoBalance) : string.Empty; elemento += string.Format(ConstBlockStoreHechos.ValorDocumentoTipoDato, itemEstructuraInstancia.IdTipoDato, itemEstructuraInstancia.EsTipoDatoNumerico.ToString().ToLower()); if (itemEstructuraInstancia.EsTipoDatoNumerico) { elemento += !string.IsNullOrEmpty(itemEstructuraInstancia.Valor) ? string.Format(ConstBlockStoreHechos.ValorDocumentoTipoDatoNumericoValorRedondeado, itemEstructuraInstancia.Valor, itemEstructuraInstancia.ValorRedondeado) : string.Empty; elemento += !string.IsNullOrEmpty(itemEstructuraInstancia.Precision) ? string.Format(ConstBlockStoreHechos.ValorDocumentoTipoDatoNumericoPrecision, itemEstructuraInstancia.Precision) : string.Empty; elemento += !string.IsNullOrEmpty(itemEstructuraInstancia.Decimales) ? string.Format(ConstBlockStoreHechos.ValorDocumentoTipoDatoNumericoDecimales, itemEstructuraInstancia.Decimales) : string.Empty; elemento += string.Format(ConstBlockStoreHechos.ValorDocumentoTipoDatoNumericoFraccion, itemEstructuraInstancia.EsTipoDatoFraccion.ToString().ToLower()); } else { if (!String.IsNullOrWhiteSpace(itemEstructuraInstancia.Valor) && itemEstructuraInstancia.Valor.Length > ConstBlockStoreHechos.MAX_STRING_VALUE_LENGTH) { blockStoreDocumentosyFiltros.EsValorChunks = true; blockStoreDocumentosyFiltros.ValorHecho = itemEstructuraInstancia.Valor; elemento += string.Format(ConstBlockStoreHechos.EsValorChunks, "true"); } else { elemento += !string.IsNullOrEmpty(itemEstructuraInstancia.Valor) ? string.Format(ConstBlockStoreHechos.ValorDocumentoTipoDatoNumericoValor, WebUtility.HtmlEncode(itemEstructuraInstancia.Valor.Replace("\\", "/"))) : string.Empty; } } elemento += string.Format(ConstBlockStoreHechos.ValorDocumentoTipoDatoValorNil, itemEstructuraInstancia.EsValorNil.ToString().ToLower()); if (!itemEstructuraInstancia.Periodo.EsTipoInstante) { elemento += string.Format(ConstBlockStoreHechos.PeriodoDuracion, itemEstructuraInstancia.Periodo.Tipo, string.Empty + BsonDateTime.Create(itemEstructuraInstancia.Periodo.FechaInicio).ToJson(), string.Empty + BsonDateTime.Create(itemEstructuraInstancia.Periodo.FechaFin).ToJson()); } else { elemento += string.Format(ConstBlockStoreHechos.PeriodoInstante, itemEstructuraInstancia.Periodo.Tipo, string.Empty + BsonDateTime.Create(itemEstructuraInstancia.Periodo.FechaInstante).ToJson()); } var tipoMedidaNumerador = string.Empty; if (itemEstructuraInstancia.Medida != null) { elemento += string.Format(ConstBlockStoreHechos.Medida, itemEstructuraInstancia.Medida.EsDivisoria.ToString().ToLower()); var tipoMedida = ConstBlockStoreHechos.TipoMedida; foreach (var unidad in itemEstructuraInstancia.Medida.Medidas) { tipoMedida += string.Format(ConstBlockStoreHechos.TipoMedidaArray, unidad.Nombre, unidad.EspacioNombres); } tipoMedida = string.Format(ConstEstandar.AnidamientoDos, tipoMedida.Substring(ConstEstandar.NumeroCero, tipoMedida.Length + ConstEstandar.MenosUno), ConstEstandar.CierreCorchete); if (itemEstructuraInstancia.Medida.EsDivisoria) { tipoMedidaNumerador = ConstBlockStoreHechos.TipoMedidaNumerador; foreach (var unidad in itemEstructuraInstancia.Medida.MedidasNumerador) { tipoMedidaNumerador = tipoMedidaNumerador + string.Format(ConstBlockStoreHechos.TipoMedidaArray, unidad.Nombre, unidad.EspacioNombres); } tipoMedidaNumerador = string.Format(ConstEstandar.AnidamientoTres, tipoMedidaNumerador.Substring(ConstEstandar.NumeroCero, tipoMedidaNumerador.Length + ConstEstandar.MenosUno), ConstEstandar.CierreCorchete, ConstEstandar.CierreLlave); } else { tipoMedida += ConstEstandar.CierreLlave; } elemento += string.Format(ConstEstandar.AnidamientoDos, tipoMedida, tipoMedidaNumerador); } if (itemEstructuraInstancia.Dimension != null) { var tipoDimension = ConstBlockStoreHechos.Dimension; foreach (var dimension in itemEstructuraInstancia.Dimension) { tipoDimension += string.Format(ConstBlockStoreHechos.DimensionAtributos, dimension.Explicita.ToString().ToLower(), dimension.QNameDimension, dimension.IdDimension); if (dimension.QNameItemMiembro != null) { tipoDimension += string.Format(ConstBlockStoreHechos.DimensionAtributosNombreElementoMiembro, dimension.QNameItemMiembro, dimension.IdItemMiembro.Replace("\n", "").Replace("'", "").Replace("\"", "")); } if (dimension.ElementoMiembroTipificado != null) { tipoDimension += string.Format(ConstBlockStoreHechos.DimensionMiembroTipificado, string.IsNullOrEmpty(dimension.ElementoMiembroTipificado) ? WebUtility.HtmlEncode(dimension.ElementoMiembroTipificado) : string.Empty); } if (dimension.etiquetasDimension != null) { var estructuraEtiqueta = dimension.etiquetasDimension.Aggregate(string.Empty, (current, itemEtiqueta) => string.Format(ConstEstandar.AnidamientoTres, current, string.Format(ConstBlockStoreHechos.EstructuraEtiqueta, itemEtiqueta.lenguaje, itemEtiqueta.valor.Replace(ConstEstandar.ComillaSimple, string.Empty), itemEtiqueta.roll.Replace(ConstEstandar.ComillaSimple, string.Empty)), ConstEstandar.SeparadorComa)); var etiquetas = string.Format(ConstBlockStoreHechos.ConceptoEtiquetaDimension, estructuraEtiqueta.Substring(0, estructuraEtiqueta.Length + ConstEstandar.MenosTres)); tipoDimension += etiquetas; } if (dimension.etiquetasMiembro != null) { var estructuraEtiqueta = dimension.etiquetasMiembro.Aggregate(string.Empty, (current, itemEtiqueta) => string.Format(ConstEstandar.AnidamientoTres, current, string.Format(ConstBlockStoreHechos.EstructuraEtiqueta, itemEtiqueta.lenguaje, itemEtiqueta.valor.Replace(ConstEstandar.ComillaSimple, string.Empty), itemEtiqueta.roll.Replace(ConstEstandar.ComillaSimple, string.Empty)), ConstEstandar.SeparadorComa)); var etiquetas = string.Format(ConstBlockStoreHechos.ConceptoEtiquetaMiembroDimension, estructuraEtiqueta.Substring(0, estructuraEtiqueta.Length + ConstEstandar.MenosTres)); tipoDimension += etiquetas; } tipoDimension += ConstBlockStore.miCierreLlaveComa; } tipoDimension = string.Format(ConstEstandar.AnidamientoDos, tipoDimension.Substring(0, tipoDimension.Length + ConstEstandar.MenosUno), ConstEstandar.CierreCorchete); elemento += tipoDimension; } elemento += ConstEstandar.CierreLlave; blockStoreDocumentosyFiltros.registroBlockStore.Add(BsonDocument.Parse(elemento)); blockStoreDocumentosyFiltros.filtrosBlockStore.Add(BsonDocument.Parse("{'codigoHashRegistro':'" + itemEstructuraInstancia.codigoHashRegistro + "'}")); listadoDocumentos.Add(blockStoreDocumentosyFiltros); } return(listadoDocumentos); }