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