/// <summary>
/// Crea un hecho y lo inyecta al documento de instancia y a la tupla padre
/// </summary>
/// <param name="hechoEnTupla"></param>
/// <param name="idConcepto"></param>
/// <param name="instancia"></param>
/// <returns></returns>
private AbaxXBRLCore.Viewer.Application.Dto.HechoDto CrearHechoEnTupla(AbaxXBRLCore.Viewer.Application.Dto.HechoDto tupla, string idConcepto, DocumentoInstanciaXbrlDto instancia,
Model.IDefinicionPlantillaXbrl plantillaDocumento, string idContextoGeneral)
{
var idHecho = "INV_H_" + Guid.NewGuid().ToString();
var concepto = instancia.Taxonomia.ConceptosPorId[idConcepto];
List <MedidaDto> listaMedidas = null;
string idUnidad = null;
var decimales = "";
if (concepto.TipoDatoXbrl.Contains(TiposDatoXBRL.MonetaryItemType))
{
idUnidad = "moneda_reporte";
decimales = "2";
}
else if (concepto.EsTipoDatoNumerico)
{
idUnidad = "pure";
decimales = "2";
}
var hechoNuevo = instancia.CrearHecho(idConcepto, idUnidad, idContextoGeneral, idHecho);
hechoNuevo.Decimales = decimales;
plantillaDocumento.InyectaHechoADocumentoInstancia(hechoNuevo);
tupla.Hechos.Add(hechoNuevo.Id);
return(hechoNuevo);
}
/// <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 void ActualizarValor(ConceptoDto concepto, string valorCelda, AbaxXBRLCore.Viewer.Application.Dto.HechoDto hechoNuevo)
{
if (concepto.EsTipoDatoNumerico)
{
double valorNumerico = 0;
if (Double.TryParse(valorCelda, System.Globalization.NumberStyles.Any, CultureInfo.InvariantCulture, out valorNumerico))
{
hechoNuevo.Valor = valorCelda;
}
}
else
{
hechoNuevo.Valor = valorCelda;
}
}
/// <summary>
/// Verifica si existe informacion del formato en alguno de los periodos
/// </summary>
/// <param name="instancia">Documento de instancia donde se buscan los hechos</param>
/// <param name="idConceptoBuscado">Identificador del concepto buscado</param>
/// <param name="fechaInicio">Fecha de inicio buscada</param>
/// <param name="fechaFin">Fecha de fin o fecha instante buscada</param>
/// <param name="infoDimensional">Información extra opcional dimensional a filtrar</param>
/// <returns>True si existe el hecho buscado en esas fechas y dimensiones, false en otro caso</returns>
protected bool ExisteInformacionEnPeriodo(DocumentoInstanciaXbrlDto instancia, String idConceptoBuscado, DateTime fechaInicio, DateTime fechaFin, IList <DimensionInfoDto> infoDimensional)
{
AbaxXBRLCore.Viewer.Application.Dto.HechoDto hecho = null;
AbaxXBRLCore.Viewer.Application.Dto.ContextoDto ctx = null;
if (instancia.HechosPorIdConcepto.ContainsKey(idConceptoBuscado))
{
var idHechos = instancia.HechosPorIdConcepto[idConceptoBuscado];
foreach (var idHecho in idHechos)
{
if (instancia.HechosPorId.ContainsKey(idHecho))
{
hecho = instancia.HechosPorId[idHecho];
if (hecho.IdContexto != null && instancia.ContextosPorId.ContainsKey(hecho.IdContexto))
{
ctx = instancia.ContextosPorId[hecho.IdContexto];
if (ctx != null)
{
bool dimensionOk = infoDimensional == null;
if (infoDimensional != null)
{
dimensionOk = ctx.SonDimensionesEquivalentes(infoDimensional);
}
if (dimensionOk)
{
if (ctx.Periodo.Tipo == PeriodoDto.Instante)
{
if (fechaFin.Equals(ctx.Periodo.FechaInstante))
{
return(true);
}
}
else if (ctx.Periodo.Tipo == PeriodoDto.Duracion)
{
if (fechaInicio.Equals(ctx.Periodo.FechaInicio) && fechaFin.Equals(ctx.Periodo.FechaFin))
{
return(true);
}
}
}
}
}
}
}
}
return(false);
}
/// <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>
/// Determina si una tupla está duplicada con otra.
/// </summary>
/// <param name="tupla">la tupla que se tomará como referencia.</param>
/// <param name="tuplaComparar">la tupla que se compara contra la referencia.</param>
/// <returns>true si la tupla está duplicada con la de referencia. false en cualquier otro caso.</returns>
bool EsTuplaDuplicada(HechoDto tupla, HechoDto tuplaComparar)
{
bool resultado = true;
if (!tupla.IdConcepto.Equals(tuplaComparar.IdConcepto))
{
resultado = false;
}
else if (tupla.Hechos.Count != tuplaComparar.Hechos.Count)
{
resultado = false;
}
else if (tupla.TuplaPadre != null && tuplaComparar.TuplaPadre != null && !tupla.TuplaPadre.Id.Equals(tuplaComparar.TuplaPadre.Id))
{
resultado = false;
}
else
{
foreach (var hecho in tupla.Hechos)
{
if (HechosPorId.ContainsKey(hecho))
{
var hechoDto = HechosPorId[hecho];
bool hechoEquivalenteEncontrado = false;
foreach (var hechoComparar in tuplaComparar.Hechos)
{
var hechoCompararDto = HechosPorId[hechoComparar];
if (hechoDto.Tipo == Concept.Tuple && hechoCompararDto.Tipo == Concept.Tuple)
{
if (this.EsTuplaDuplicada(hechoDto, hechoCompararDto))
{
hechoEquivalenteEncontrado = true;
break;
}
}
else if (hechoDto.Tipo == Concept.Item && hechoCompararDto.Tipo == Concept.Item)
{
if (hechoDto.IdConcepto.Equals(hechoCompararDto.IdConcepto))
{
if (hechoDto.IdContexto.Equals(hechoCompararDto.IdContexto) || this.ContextosPorId[hechoDto.IdContexto].EstructuralmenteIgual(this.ContextosPorId[hechoCompararDto.IdContexto]))
{
if (hechoDto.EsNumerico)
{
if (hechoDto.ValorRedondeado == hechoCompararDto.ValorRedondeado)
{
hechoEquivalenteEncontrado = true;
break;
}
}
else
{
if (hechoDto.Valor.Equals(hechoCompararDto.Valor))
{
hechoEquivalenteEncontrado = true;
break;
}
}
}
}
break;
}
}
if (!hechoEquivalenteEncontrado)
{
resultado = false;
break;
}
}
}
}
return(resultado);
}
/// <summary>
/// Importa los datos de un hecho de otro documento de instancia.
/// Busca unidad o contexto que sea equivalente, de otra forma crea unidades y contextos asociados
/// </summary>
/// <param name="hechoImportar">Hecho a importar</param>
/// <param name="instancia">Documento de instancia orgien del hecho</param>
/// <returns>ID del hecho importado en le documento de instancia</returns>
public String ImportarHecho(HechoDto hechoImportar, DocumentoInstanciaXbrlDto instancia)
{
String nuevoId = null;
if (this.Taxonomia.ConceptosPorId.ContainsKey(hechoImportar.IdConcepto))
{
nuevoId = "I" + Guid.NewGuid().ToString();
String idContexto = null;
String idUnidad = null;
if (hechoImportar.IdUnidad != null)
{
UnidadDto unidadOrigen = instancia.UnidadesPorId[hechoImportar.IdUnidad];
var uniadesNuevoHecho = BuscarUnidades(unidadOrigen.Tipo, Unit.Medida == unidadOrigen.Tipo ?unidadOrigen.Medidas :unidadOrigen.MedidasNumerador, unidadOrigen.MedidasDenominador);
if (uniadesNuevoHecho != null && uniadesNuevoHecho.Count > 0)
{
idUnidad = uniadesNuevoHecho[0].Id;
}
else
{
var unidadDestino = new UnidadDto()
{
Id = "UI" + Guid.NewGuid().ToString(),
Tipo = unidadOrigen.Tipo,
Medidas = unidadOrigen.Medidas,
MedidasNumerador = unidadOrigen.MedidasNumerador,
MedidasDenominador = unidadOrigen.MedidasDenominador
};
UnidadesPorId.Add(unidadDestino.Id, unidadDestino);
idUnidad = unidadDestino.Id;
}
}
if (hechoImportar.IdContexto != null)
{
ContextoDto contextoOrigen = instancia.ContextosPorId[hechoImportar.IdContexto];
var valoresDim = new List <DimensionInfoDto>();
if (contextoOrigen.Entidad.ValoresDimension != null)
{
valoresDim.AddRange(contextoOrigen.Entidad.ValoresDimension);
}
if (contextoOrigen.ValoresDimension != null)
{
valoresDim.AddRange(contextoOrigen.ValoresDimension);
}
var contextos = BuscarContexto(contextoOrigen.Entidad.EsquemaId + ":" + contextoOrigen.Entidad.Id, contextoOrigen.Periodo.Tipo,
contextoOrigen.Periodo.Tipo == Period.Instante? contextoOrigen.Periodo.FechaInstante:contextoOrigen.Periodo.FechaInicio,
contextoOrigen.Periodo.Tipo == Period.Instante? contextoOrigen.Periodo.FechaInstante:contextoOrigen.Periodo.FechaFin,
valoresDim
);
if (contextos != null && contextos.Count > 0)
{
idContexto = contextos[0].Id;
//LogUtil.Info("{contextoOrigen.Entidad.Id: [" + contextoOrigen.Entidad.Id + "], contextoDocumento.Entidad.Id:[" + contextos[0].Entidad.Id + "]}");
}
else
{
var contextoDestino = new ContextoDto()
{
Entidad = new EntidadDto()
{
ContieneInformacionDimensional = contextoOrigen.Entidad.ContieneInformacionDimensional,
EsquemaId = contextoOrigen.Entidad.EsquemaId,
Id = contextoOrigen.Entidad.Id
},
ContieneInformacionDimensional = contextoOrigen.ContieneInformacionDimensional,
Periodo = new PeriodoDto()
{
Tipo = contextoOrigen.Periodo.Tipo,
FechaInicio = contextoOrigen.Periodo.FechaInicio,
FechaFin = contextoOrigen.Periodo.FechaFin,
FechaInstante = contextoOrigen.Periodo.FechaInstante
},
ValoresDimension = contextoOrigen.ValoresDimension,
Id = "CI" + Guid.NewGuid().ToString()
};
ContextosPorId[contextoDestino.Id] = contextoDestino;
idContexto = contextoDestino.Id;
}
}
var hechoNuevo = CrearHecho(hechoImportar.IdConcepto, idUnidad, idContexto, nuevoId);
hechoNuevo.Valor = hechoImportar.Valor;
hechoNuevo.ValorNumerico = hechoImportar.ValorNumerico;
HechosPorId[nuevoId] = hechoNuevo;
if (!HechosPorIdConcepto.ContainsKey(hechoNuevo.IdConcepto))
{
HechosPorIdConcepto[hechoNuevo.IdConcepto] = new List <String>();
}
HechosPorIdConcepto[hechoNuevo.IdConcepto].Add(nuevoId);
}
return(nuevoId);
}
/// <summary>
/// Verifica y agrega los elementos con los que este elemento se duplica a su lista interna de duplicados
/// </summary>
/// <param name="hecho">el elemento a verificar</param>
public void VerificarDuplicidad(HechoDto hecho)
{
bool esDuplicado = true;
if (hecho.Tipo == Concept.Item)
{
if (this.HechosPorIdConcepto.ContainsKey(hecho.IdConcepto))
{
foreach (var idHechoComparar in this.HechosPorIdConcepto[hecho.IdConcepto])
{
var hechoComparar = this.HechosPorId[idHechoComparar];
var contextoEquivalente = false;
var unidadEquivalente = false;
var mismaTupla = false;
if (hecho.IdContexto.Equals(hechoComparar.IdContexto))
{
contextoEquivalente = true;
}
else
{
if (this.ContextosPorId.ContainsKey(hecho.IdContexto) && this.ContextosPorId.ContainsKey(hechoComparar.IdContexto) && this.ContextosPorId[hecho.IdContexto].EstructuralmenteIgual(this.ContextosPorId[hechoComparar.IdContexto]))
{
contextoEquivalente = true;
}
}
if (hecho.EsNumerico)
{
if (hecho.IdUnidad.Equals(hechoComparar.IdUnidad))
{
unidadEquivalente = true;
}
else
{
var miUnidad = this.UnidadesPorId[hecho.IdUnidad];
var otraUnidad = this.UnidadesPorId[hechoComparar.IdUnidad];
if (miUnidad != null && otraUnidad != null && miUnidad.EsEquivalente(otraUnidad))
{
unidadEquivalente = true;
}
}
}
else
{
unidadEquivalente = true;
}
if ((hecho.TuplaPadre != null && hechoComparar.TuplaPadre == null) || (hechoComparar.TuplaPadre != null && hecho.TuplaPadre == null))
{
mismaTupla = false;
}
else
{
if (hecho.TuplaPadre != null && hecho.TuplaPadre != null)
{
if (hecho.TuplaPadre.Id.Equals(hechoComparar.TuplaPadre.Id))
{
mismaTupla = true;
}
}
else
{
mismaTupla = true;
}
}
if (contextoEquivalente && unidadEquivalente && mismaTupla)
{
if (hecho.DuplicadoCon == null)
{
hecho.DuplicadoCon = new List <string>();
}
if (hechoComparar.DuplicadoCon == null)
{
hechoComparar.DuplicadoCon = new List <string>();
}
if (!hecho.DuplicadoCon.Contains(hechoComparar.Id))
{
hecho.DuplicadoCon.Add(hechoComparar.Id);
}
if (!hechoComparar.DuplicadoCon.Contains(hecho.Id))
{
hechoComparar.DuplicadoCon.Add(hecho.Id);
}
}
}
}
else if (hecho.Tipo == Concept.Tuple)
{
if (this.HechosPorIdConcepto.ContainsKey(hecho.IdConcepto))
{
foreach (var idHechoComparar in this.HechosPorIdConcepto[hecho.IdConcepto])
{
var hechoComparar = this.HechosPorId[idHechoComparar];
if (this.EsTuplaDuplicada(hecho, hechoComparar))
{
if (hecho.DuplicadoCon == null)
{
hecho.DuplicadoCon = new List <string>();
}
if (hechoComparar.DuplicadoCon == null)
{
hechoComparar.DuplicadoCon = new List <string>();
}
if (!hecho.DuplicadoCon.Contains(hechoComparar.Id))
{
hecho.DuplicadoCon.Add(hechoComparar.Id);
}
if (!hechoComparar.DuplicadoCon.Contains(hecho.Id))
{
hechoComparar.DuplicadoCon.Add(hecho.Id);
}
}
}
}
}
}
}
/// <summary>
/// Crea un nuevo hecho para el concepto enviado, asociándolo al contexto y unidad enviados como parámetro, el
/// contexto y la unidad son opcionales, también asigna el ID de hecho enviado como parámetro.
/// Agrega el hecho a los distintos índices del documento
/// </summary>
/// <param name="idConcepto">Identificador del concepto para el hecho a crear</param>
/// <param name="idUnidad">Identificador opcional de la unidad del concepto, obligatorio para datos numéricos</param>
/// <param name="idContexto">Contexto del hecho, no necesario para tuplas</param>
/// <param name="idHecho">Identificador opcional del hecho</param>
/// <returns>El hecho creado</returns>
public HechoDto CrearHecho(string idConcepto, string idUnidad, string idContexto, string idHecho)
{
HechoDto hechoNuevo = null;
if (String.IsNullOrEmpty(idConcepto) || Taxonomia == null || !Taxonomia.ConceptosPorId.ContainsKey(idConcepto))
{
return(null);
}
var concepto = Taxonomia.ConceptosPorId[idConcepto];
var EsAbstracto = concepto.EsAbstracto != null ? concepto.EsAbstracto.Value : false;
if (!EsAbstracto)
{
if ((concepto.Tipo == Concept.Item && !ContextosPorId.ContainsKey(idContexto)) ||
(concepto.EsTipoDatoNumerico && !UnidadesPorId.ContainsKey(idUnidad)))
{
return(null);
}
if (idHecho != null && HechosPorId.ContainsKey(idHecho))
{
return(null);
}
hechoNuevo = new HechoDto()
{
IdConcepto = idConcepto,
NombreConcepto = concepto.Nombre,
EspacioNombres = concepto.EspacioNombres,
Tipo = concepto.Tipo,
Id = idHecho,
CambioValorComparador = false,
};
if (concepto.Tipo == Concept.Item)
{
hechoNuevo.EsTupla = false;
hechoNuevo.TipoDato = concepto.TipoDato;
hechoNuevo.TipoDatoXbrl = concepto.TipoDatoXbrl;
if (concepto.EsTipoDatoNumerico)
{
hechoNuevo.EsNumerico = true;
hechoNuevo.IdContexto = idContexto;
hechoNuevo.Valor = null;
hechoNuevo.IdUnidad = idUnidad;
hechoNuevo.Decimales = "0";
}
else
{
hechoNuevo.NoEsNumerico = true;
hechoNuevo.IdContexto = idContexto;
hechoNuevo.Valor = null;
}
}
else if (concepto.Tipo == Concept.Tuple)
{
hechoNuevo.EsTupla = true;
hechoNuevo.NoEsNumerico = true;
}
}
return(hechoNuevo);
}
private IDictionary <string, object> CrearDefinicionHecho(bool esRolDimensional, DocumentoInstanciaXbrlDto documentoInstancia,
IDictionary <string, object> hechosRol, IDictionary <string, object> contextosRol, IDictionary <string, object> unidadesRol,
IList <string> nombresVariablesPlantilla, AbaxXBRLCore.Viewer.Application.Dto.HechoDto hecho)
{
IDictionary <string, object> definicionHecho = null;
if (!hechosRol.ContainsKey(hecho.Id))
{
if (hecho.Tipo == Concept.Item)
{
IDictionary <string, object> definicionContexto = null;
if (contextosRol.ContainsKey(hecho.IdContexto))
{
definicionContexto = (IDictionary <string, object>)contextosRol[hecho.IdContexto];
}
else
{
if (documentoInstancia.ContextosPorId.ContainsKey(hecho.IdContexto))
{
var contexto = documentoInstancia.ContextosPorId[hecho.IdContexto];
if (esRolDimensional || (!contexto.ContieneInformacionDimensional && !contexto.Entidad.ContieneInformacionDimensional))
{
definicionContexto = new Dictionary <string, object>();
definicionContexto.Add("Id", contexto.Id);
var definicionPeriodo = new Dictionary <string, object>();
definicionPeriodo.Add("Tipo", contexto.Periodo.Tipo);
if (contexto.Periodo.Tipo == Period.Instante)
{
var nombreVariableFecha = "fecha_" + contexto.Periodo.FechaInstante.ToString("yyyy_MM_dd");
if (!nombresVariablesPlantilla.Contains(nombreVariableFecha))
{
nombresVariablesPlantilla.Add(nombreVariableFecha);
}
definicionPeriodo.Add("FechaInstante", "#" + nombreVariableFecha);
definicionPeriodo.Add("FechaInicio", "");
definicionPeriodo.Add("FechaFin", "");
}
else
{
var nombreVariableFecha = "fecha_" + contexto.Periodo.FechaInicio.ToString("yyyy_MM_dd");
if (!nombresVariablesPlantilla.Contains(nombreVariableFecha))
{
nombresVariablesPlantilla.Add(nombreVariableFecha);
}
definicionPeriodo.Add("FechaInicio", "#" + nombreVariableFecha);
nombreVariableFecha = "fecha_" + contexto.Periodo.FechaFin.ToString("yyyy_MM_dd");
if (!nombresVariablesPlantilla.Contains(nombreVariableFecha))
{
nombresVariablesPlantilla.Add(nombreVariableFecha);
}
definicionPeriodo.Add("FechaFin", "#" + nombreVariableFecha);
definicionPeriodo.Add("FechaInstante", "");
}
definicionContexto.Add("Periodo", definicionPeriodo);
var definicionEntidad = new Dictionary <string, object>();
if (!nombresVariablesPlantilla.Contains("nombreEntidad"))
{
nombresVariablesPlantilla.Add("nombreEntidad");
}
definicionEntidad.Add("Id", "#nombreEntidad");
if (!nombresVariablesPlantilla.Contains("esquemaEntidad"))
{
nombresVariablesPlantilla.Add("esquemaEntidad");
}
definicionEntidad.Add("EsquemaId", "#esquemaEntidad");
definicionEntidad.Add("ContieneInformacionDimensional", contexto.Entidad.ContieneInformacionDimensional);
if (contexto.Entidad.ContieneInformacionDimensional)
{
definicionEntidad.Add("Segmento", contexto.Entidad.Segmento);
var definicionValoresDimension = new List <Dictionary <string, object> >();
foreach (var valorDimension in contexto.Entidad.ValoresDimension)
{
var definicionValorDimension = new Dictionary <string, object>();
definicionValorDimension.Add("Explicita", valorDimension.Explicita);
if (valorDimension.Explicita)
{
definicionValorDimension.Add("IdDimension", valorDimension.IdDimension);
definicionValorDimension.Add("IdItemMiembro", valorDimension.IdItemMiembro);
definicionValorDimension.Add("QNameDimension", valorDimension.QNameDimension);
definicionValorDimension.Add("QNameItemMiembro", valorDimension.QNameItemMiembro);
definicionValorDimension.Add("ElementoMiembroTipificado", null);
}
else
{
definicionValorDimension.Add("IdDimension", valorDimension.IdDimension);
definicionValorDimension.Add("IdItemMiembro", null);
definicionValorDimension.Add("QNameDimension", valorDimension.QNameDimension);
definicionValorDimension.Add("QNameItemMiembro", null);
definicionValorDimension.Add("ElementoMiembroTipificado", valorDimension.ElementoMiembroTipificado);
}
definicionValoresDimension.Add(definicionValorDimension);
}
definicionEntidad.Add("ValoresDimension", definicionValoresDimension.ToArray());
}
else
{
definicionEntidad.Add("Segmento", null);
definicionEntidad.Add("ValoresDimension", new object[0]);
}
definicionContexto.Add("Entidad", definicionEntidad);
definicionContexto.Add("ContieneInformacionDimensional", contexto.ContieneInformacionDimensional);
if (contexto.ContieneInformacionDimensional)
{
definicionContexto.Add("Escenario", contexto.Escenario);
var definicionValoresDimension = new List <Dictionary <string, object> >();
foreach (var valorDimension in contexto.ValoresDimension)
{
var definicionValorDimension = new Dictionary <string, object>();
definicionValorDimension.Add("Explicita", valorDimension.Explicita);
if (valorDimension.Explicita)
{
definicionValorDimension.Add("IdDimension", valorDimension.IdDimension);
definicionValorDimension.Add("IdItemMiembro", valorDimension.IdItemMiembro);
definicionValorDimension.Add("QNameDimension", valorDimension.QNameDimension);
definicionValorDimension.Add("QNameItemMiembro", valorDimension.QNameItemMiembro);
definicionValorDimension.Add("ElementoMiembroTipificado", null);
}
else
{
definicionValorDimension.Add("IdDimension", valorDimension.IdDimension);
definicionValorDimension.Add("IdItemMiembro", null);
definicionValorDimension.Add("QNameDimension", valorDimension.QNameDimension);
definicionValorDimension.Add("QNameItemMiembro", null);
definicionValorDimension.Add("ElementoMiembroTipificado", valorDimension.ElementoMiembroTipificado);
}
definicionValoresDimension.Add(definicionValorDimension);
}
definicionContexto.Add("ValoresDimension", definicionValoresDimension.ToArray());
}
else
{
definicionContexto.Add("Escenario", null);
definicionContexto.Add("ValoresDimension", new object[0]);
}
contextosRol.Add(contexto.Id, definicionContexto);
}
}
}
if (definicionContexto != null)
{
definicionHecho = new Dictionary <string, object>();
definicionHecho.Add("Id", hecho.Id);
definicionHecho.Add("IdConcepto", hecho.IdConcepto);
definicionHecho.Add("IdContextoPlantilla", definicionContexto["Id"]);
definicionHecho.Add("Hechos", new object[0]);
var concepto = documentoInstancia.Taxonomia.ConceptosPorId[hecho.IdConcepto];
if (hecho.EsNumerico)
{
IDictionary <string, object> definicionUnidad = null;
if (unidadesRol.ContainsKey(hecho.IdUnidad))
{
definicionUnidad = (IDictionary <string, object>)unidadesRol[hecho.IdUnidad];
}
else
{
if (documentoInstancia.UnidadesPorId.ContainsKey(hecho.IdUnidad))
{
var unidad = documentoInstancia.UnidadesPorId[hecho.IdUnidad];
definicionUnidad = new Dictionary <string, object>();
definicionUnidad.Add("Id", unidad.Id);
definicionUnidad.Add("Tipo", unidad.Tipo);
if (unidad.Tipo == Unit.Medida)
{
var definicionMedidas = new List <IDictionary <string, object> >();
foreach (var medida in unidad.Medidas)
{
var definicionMedida = new Dictionary <string, object>();
var nombreVariableMedidaNombre = "medida_" + medida.Nombre;
if (!nombresVariablesPlantilla.Contains(nombreVariableMedidaNombre))
{
nombresVariablesPlantilla.Add(nombreVariableMedidaNombre);
}
definicionMedida.Add("Nombre", "#" + nombreVariableMedidaNombre);
var nombreVariableMedidaEspacioNombres = "medida_" + medida.EspacioNombres.Replace(":", "_").Replace(".", "_").Replace("/", "_").Replace("-", "_");
if (!nombresVariablesPlantilla.Contains(nombreVariableMedidaEspacioNombres))
{
nombresVariablesPlantilla.Add(nombreVariableMedidaEspacioNombres);
}
definicionMedida.Add("EspacioNombres", "#" + nombreVariableMedidaEspacioNombres);
definicionMedidas.Add(definicionMedida);
}
definicionUnidad.Add("Medidas", definicionMedidas);
definicionUnidad.Add("MedidasDenominador", new object[0]);
definicionUnidad.Add("MedidasNumerador", new object[0]);
}
else
{
var definicionMedidas = new List <IDictionary <string, object> >();
foreach (var medida in unidad.MedidasDenominador)
{
var definicionMedida = new Dictionary <string, object>();
var nombreVariableMedidaNombre = "medida_" + medida.Nombre;
if (!nombresVariablesPlantilla.Contains(nombreVariableMedidaNombre))
{
nombresVariablesPlantilla.Add(nombreVariableMedidaNombre);
}
definicionMedida.Add("Nombre", "#" + nombreVariableMedidaNombre);
var nombreVariableMedidaEspacioNombres = "medida_" + medida.EspacioNombres.Replace(":", "_").Replace(".", "_").Replace("/", "_").Replace("-", "_");
if (!nombresVariablesPlantilla.Contains(nombreVariableMedidaEspacioNombres))
{
nombresVariablesPlantilla.Add(nombreVariableMedidaEspacioNombres);
}
definicionMedida.Add("EspacioNombres", "#" + nombreVariableMedidaEspacioNombres);
definicionMedidas.Add(definicionMedida);
}
definicionUnidad.Add("MedidasDenominador", definicionMedidas);
definicionMedidas = new List <IDictionary <string, object> >();
foreach (var medida in unidad.MedidasNumerador)
{
var definicionMedida = new Dictionary <string, object>();
var nombreVariableMedidaNombre = "medida_" + medida.Nombre;
if (!nombresVariablesPlantilla.Contains(nombreVariableMedidaNombre))
{
nombresVariablesPlantilla.Add(nombreVariableMedidaNombre);
}
definicionMedida.Add("Nombre", "#" + nombreVariableMedidaNombre);
var nombreVariableMedidaEspacioNombres = "medida_" + medida.EspacioNombres.Replace(":", "_").Replace(".", "_").Replace("/", "_").Replace("-", "_");
if (!nombresVariablesPlantilla.Contains(nombreVariableMedidaEspacioNombres))
{
nombresVariablesPlantilla.Add(nombreVariableMedidaEspacioNombres);
}
definicionMedida.Add("EspacioNombres", "#" + nombreVariableMedidaEspacioNombres);
definicionMedidas.Add(definicionMedida);
}
definicionUnidad.Add("MedidasNumerador", definicionMedidas);
definicionUnidad.Add("Medidas", new object[0]);
}
unidadesRol.Add(unidad.Id, definicionUnidad);
}
}
if (definicionUnidad == null)
{
//return;
}
definicionHecho.Add("IdUnidadPlantilla", definicionUnidad["Id"]);
if (!StringUtils.IsNullOrEmpty(hecho.Decimales))
{
definicionHecho.Add("Decimales", hecho.Decimales);
definicionHecho.Add("Precision", null);
}
if (!StringUtils.IsNullOrEmpty(hecho.Precision))
{
definicionHecho.Add("Precision", hecho.Precision);
definicionHecho.Add("Decimales", null);
}
if (!concepto.TipoDatoXbrl.Equals("http://www.xbrl.org/2003/instance:fractionItemType"))
{
if (generarVariableValorDefaultNumerico)
{
definicionHecho.Add("Valor", "#valorDefaultNumerico");
if (!nombresVariablesPlantilla.Contains("valorDefaultNumerico"))
{
nombresVariablesPlantilla.Add("valorDefaultNumerico");
}
definicionHecho.Add("ValorNumerador", null);
definicionHecho.Add("ValorDenominador", null);
}
}
else
{
if (generarVariableValorDefaultNumerico)
{
definicionHecho.Add("Valor", null);
definicionHecho.Add("ValorDenominador", "#valorDefaultNumerico");
if (!nombresVariablesPlantilla.Contains("valorDefaultNumerico"))
{
nombresVariablesPlantilla.Add("valorDefaultNumerico");
}
definicionHecho.Add("ValorNumerador", "#valorDefaultNumerico");
if (!nombresVariablesPlantilla.Contains("valorDefaultNumerico"))
{
nombresVariablesPlantilla.Add("valorDefaultNumerico");
}
}
}
}
else
{
definicionHecho.Add("IdUnidadPlantilla", null);
definicionHecho.Add("ValorNumerador", null);
definicionHecho.Add("ValorDenominador", null);
definicionHecho.Add("Precision", null);
definicionHecho.Add("Decimales", null);
if (generarVariableValorDefaultNoNumerico)
{
definicionHecho.Add("Valor", "#valorDefaultNoNumerico");
if (!nombresVariablesPlantilla.Contains("valorDefaultNoNumerico"))
{
nombresVariablesPlantilla.Add("valorDefaultNoNumerico");
}
}
}
}
}
else
{
definicionHecho = new Dictionary <string, object>();
definicionHecho.Add("Id", hecho.Id);
definicionHecho.Add("IdConcepto", hecho.IdConcepto);
var definicionHechos = new List <IDictionary <string, object> >();
foreach (var hechoHijo in hecho.Hechos)
{
var hechoDto = documentoInstancia.HechosPorId[hechoHijo];
var definicionHechoHijo = CrearDefinicionHecho(esRolDimensional, documentoInstancia, hechosRol, contextosRol, unidadesRol, nombresVariablesPlantilla, hechoDto);
if (definicionHechoHijo != null)
{
definicionHechos.Add(definicionHechoHijo);
}
}
definicionHecho.Add("Hechos", definicionHechos.ToArray());
definicionHecho.Add("Valor", null);
definicionHecho.Add("ValorDenominador", null);
definicionHecho.Add("ValorNumerador", null);
definicionHecho.Add("Precision", null);
definicionHecho.Add("Decimales", null);
definicionHecho.Add("IdUnidadPlantilla", null);
definicionHecho.Add("IdContextoPlantilla", null);
}
}
return(definicionHecho);
}
public void TestActualizarModeloVistaDocumentoInstancia()
{
var service = new DocumentoInstanciaService
{
DocumentoInstanciaRepository = new DocumentoInstanciaRepository(),
UsuarioDocumentoInstanciaRepository = new UsuarioDocumentoInstanciaRepository(),
VersionDocumentoInstanciaRepository = new VersionDocumentoInstanciaRepository(),
EmpresaRepository = new EmpresaRepository(),
UsuarioRepository = new UsuarioRepository(),
UnidadRepository = new UnidadRepository(),
ContextoRepository = new ContextoRepository(),
DtsDocumentoInstanciaRepository = new DtsDocumentoInstanciaRepository(),
HechoRepository = new HechoRepository()
};
var instancia = new DocumentoInstanciaXbrlDto {
IdDocumentoInstancia = 160, EsCorrecto = true, IdEmpresa = 1, NombreArchivo = "Titulo1", Titulo = "Titulo1", UnidadesPorId = new Dictionary <string, UnidadDto>()
};
var unidad = new UnidadDto
{
Id = "MXN",
Tipo = Unit.Medida,
Medidas =
new List <MedidaDto>
{
new MedidaDto
{
EspacioNombres = "http://www.xbrl.org/2003/iso4217", Nombre = "MXN"
}
}
};
instancia.UnidadesPorId.Add(unidad.Id, unidad);
//Contextos
var contexto = new AbaxXBRLCore.Viewer.Application.Dto.ContextoDto()
{
ContieneInformacionDimensional = false,
Escenario = null,
Id = "ctx1",
Entidad = new EntidadDto
{
EsquemaId = "http://2hsoftware.com",
Id = "e1",
Segmento = null
},
Periodo = new PeriodoDto
{
Tipo = Period.Instante,
FechaInstante = AbaxXBRLCore.Common.Util.DateUtil.ParseStandarDate("01/03/2014")
}
};
instancia.ContextosPorId = new Dictionary <string, AbaxXBRLCore.Viewer.Application.Dto.ContextoDto>();
instancia.ContextosPorId.Add(contexto.Id, contexto);
instancia.DtsDocumentoInstancia = new List <DtsDocumentoInstanciaDto>();
instancia.DtsDocumentoInstancia.Add(new DtsDocumentoInstanciaDto
{
Tipo = DtsDocumentoInstanciaDto.SCHEMA_REF,
HRef = "ifrsxbrl2014.xsd"
});
var hecho = new AbaxXBRLCore.Viewer.Application.Dto.HechoDto
{
IdConcepto = "http://xbrl.ifrs.org/taxonomy/2011-03-25/ifrs:NameOfReportingEntityOrOtherMeansOfIdentification",
EsFraccion = false,
EsNumerico = false,
NoEsNumerico = true,
EsTupla = false,
IdContexto = "ctx1",
IdUnidad = "MXN",
Tipo = Concept.Item,
EsValorNil = false,
Valor = "ALCON",
TipoDato = "stringItemType"
};
instancia.HechosPorIdConcepto = new Dictionary <string, IList <string> >();
instancia.HechosPorId = new Dictionary <string, AbaxXBRLCore.Viewer.Application.Dto.HechoDto>();
instancia.HechosPorIdConcepto[hecho.IdConcepto] = new List <string>();
instancia.HechosPorIdConcepto[hecho.IdConcepto].Add(hecho.Id);
instancia.HechosPorId.Add(hecho.Id, hecho);
instancia.DtsDocumentoInstancia = new List <DtsDocumentoInstanciaDto>();
instancia.DtsDocumentoInstancia.Add(new DtsDocumentoInstanciaDto {
Tipo = DtsDocumentoInstanciaDto.SCHEMA_REF,
HRef = "http://emisnet.bmv.com.mx/taxonomy/mx-ifrs-ics-2012-04-01/All/ifrs-mx-ics-entryPoint-all-2012-04-01.xsd"
});
var viewService = new XbrlViewerService();
}
/// <summary>
/// Intenta realizar la asignación del valor enviado como parámetro al hecho, si
/// el valor no es válido respecto al tipo de dato del concepto, el valor no es asignado
/// </summary>
/// <param name="conceptoImportar">Concepto que se está importando</param>
/// <param name="hechoInstancia">Hecho en el documento de instancia</param>
/// <param name="valorImportar">Valor a importar</param>
/// <param name="fechaDefault">Fecha por default para un hecho del tipo fecha</param>
/// <returns>True si se pudo asignar el valor, false en otro caso</returns>
public static Boolean ActualizarValorHecho(ConceptoDto conceptoImportar, AbaxXBRLCore.Viewer.Application.Dto.HechoDto hechoInstancia, String valorImportar, String fechaDefault)
{
var valorAsignado = false;
if (conceptoImportar.EsTipoDatoNumerico)
{
double resultado = 0;
hechoInstancia.Valor = "0";
if (Double.TryParse(valorImportar, NumberStyles.Any, CultureInfo.InvariantCulture, out resultado))
{
if (conceptoImportar.TipoDatoXbrl.Contains(TiposDatoXBRL.MonetaryItemType) ||
conceptoImportar.TipoDatoXbrl.Contains(TiposDatoXBRL.DoubleItemType) ||
conceptoImportar.TipoDatoXbrl.Contains(TiposDatoXBRL.FloatItemType))
{
//hechoInstancia.Valor = resultado.ToString("###################################0.##############################", CultureInfo.InvariantCulture);
hechoInstancia.Valor = new Decimal(resultado).ToString();
valorAsignado = true;
}
else if (conceptoImportar.TipoDatoXbrl.Contains(TiposDatoXBRL.IntegerItemType) ||
conceptoImportar.TipoDatoXbrl.Contains(TiposDatoXBRL.IntItemType) ||
conceptoImportar.TipoDatoXbrl.Contains(TiposDatoXBRL.LongItemType) ||
conceptoImportar.TipoDatoXbrl.Contains(TiposDatoXBRL.SharesItemType) ||
conceptoImportar.TipoDatoXbrl.Contains(TiposDatoXBRL.ShortItemType)
)
{
hechoInstancia.Valor = ((long)resultado).ToString();
valorAsignado = true;
}
else if (conceptoImportar.TipoDatoXbrl.Contains(TiposDatoXBRL.NonNegativeIntegerItemType))
{
if (resultado >= 0)
{
hechoInstancia.Valor = ((long)resultado).ToString();;
valorAsignado = true;
}
}
else if (conceptoImportar.TipoDatoXbrl.Contains(TiposDatoXBRL.NonPositiveIntegerItemType))
{
if (resultado < 0)
{
hechoInstancia.Valor = ((long)resultado).ToString();
valorAsignado = true;
}
}
else
{
//hechoInstancia.Valor = resultado.ToString("###################################0.##############################",CultureInfo.InvariantCulture);
hechoInstancia.Valor = new Decimal(resultado).ToString();;
valorAsignado = true;
}
}
}
else if (conceptoImportar.TipoDatoXbrl.Contains(TiposDatoXBRL.BooleanItemType))
{
if (valorImportar != null && CommonConstants.CADENAS_VERDADERAS.Any(x => x.ToLower().Equals(valorImportar.ToLower())))
{
hechoInstancia.Valor = Boolean.TrueString.ToLower();
}
else
{
hechoInstancia.Valor = Boolean.FalseString.ToLower();
}
valorAsignado = true;
}
else if (conceptoImportar.TipoDatoXbrl.Contains(TiposDatoXBRL.DateItemType))
{
string valorFecha = AbaxXBRLCore.Common.Util.DateUtil.ParseDateMultipleFormats(valorImportar);
if (!String.IsNullOrEmpty(valorFecha))
{
hechoInstancia.Valor = valorFecha;
valorAsignado = true;
}
else
{
//Colocar fecha de inicio del ejercicio
hechoInstancia.Valor = fechaDefault;
}
}
else if (conceptoImportar.EsTipoDatoToken)
{
if (conceptoImportar.ListaValoresToken != null && conceptoImportar.ListaValoresToken.Count > 0)
{
if (valorImportar != null && conceptoImportar.ListaValoresToken.Contains(valorImportar))
{
hechoInstancia.Valor = valorImportar;
valorAsignado = true;
}
else
{
var asingando = false;
if (!String.IsNullOrWhiteSpace(valorImportar))
{
foreach (var valorToken in conceptoImportar.ListaValoresToken)
{
if (valorToken.ToUpper().Equals(valorImportar.Trim().ToUpper()))
{
hechoInstancia.Valor = valorToken;
asingando = true;
break;
}
}
}
if (!asingando)
{
hechoInstancia.Valor = conceptoImportar.ListaValoresToken[0];
}
}
}
}
else
{
hechoInstancia.Valor = valorImportar;
valorAsignado = true;
}
return(valorAsignado);
}