/// <summary>
        /// Metodo que realiza la agrupacion de periodos de tipo instante en los de duración en el caso que se cumplan
        /// los filtros necesarios para integrar el valor
        /// </summary>
        /// <param name="estructuraReporteGenerico">Valores de columnas y hechos a valorar</param>
        /// <param name="filtros">Filtros de consulta que se realizo para la consulta generica</param>
        /// <returns>Estructura generica para presentar en el reporte</returns>
        public EstructuraReporteGenerico AgruparHechosPorPeriodo(EntFiltroConsultaHecho filtros, EstructuraReporteGenerico estructuraReporteGenerico)
        {
            //Obtenemos los periodos de tipoInstante
            if (estructuraReporteGenerico != null && estructuraReporteGenerico.ReporteGenericoPorRol != null)
            {
                foreach (var reporteGenericoRol in estructuraReporteGenerico.ReporteGenericoPorRol)
                {
                    for (var indiceColumna = 0; indiceColumna < reporteGenericoRol.ColumnasDelReporte.Count; indiceColumna++)
                    {
                        var columnaReporte = reporteGenericoRol.ColumnasDelReporte[indiceColumna];
                        if (columnaReporte.TipoDePeriodo == Period.Instante)
                        {
                            foreach (var periodosFiltro in filtros.filtros.periodos)
                            {
                                if (periodosFiltro.FechaFin.Value.Date.Equals(columnaReporte.FechaInstante.Date))
                                {
                                    columnaReporte.FechaInicio = periodosFiltro.FechaInicio.Value;
                                    columnaReporte.FechaFin    = periodosFiltro.FechaFin.Value;
                                    break;
                                }
                            }

                            for (var indiceColumnaDuracion = 0; indiceColumnaDuracion < reporteGenericoRol.ColumnasDelReporte.Count; indiceColumnaDuracion++)
                            {
                                var columnaReporteDuracion = reporteGenericoRol.ColumnasDelReporte[indiceColumnaDuracion];
                                if (columnaReporteDuracion.TipoDePeriodo == Period.Duracion && validarIgualdad(columnaReporteDuracion, columnaReporte))
                                {
                                    foreach (var concepto in reporteGenericoRol.Conceptos)
                                    {
                                        if (concepto.Hechos[indiceColumnaDuracion] == null && concepto.Hechos[indiceColumna] != null)
                                        {
                                            concepto.Hechos[indiceColumnaDuracion] = concepto.Hechos[indiceColumna];
                                        }
                                    }

                                    reporteGenericoRol.ColumnasDelReporte[indiceColumna].OcultarColumna = true;
                                    break;
                                }
                            }
                        }
                    }
                }
            }


            return(estructuraReporteGenerico);
        }
        public EstructuraReporteGenerico CrearEstructuraGenerica(EntFiltroConsultaHecho filtros, ResultadoOperacionDto listaDeHechos, bool agruparPorUnidad, string nombreRol = "", string rolUri = "")
        {
            if (filtros.conceptos != null && filtros.conceptos.Count() > 0 && listaDeHechos.InformacionExtra != null && ((EntHecho[])listaDeHechos.InformacionExtra).Count() > 0)
            {
                EstructuraReporteGenerico estructuraReporteGenerico = new EstructuraReporteGenerico();
                EstructuraRolReporte      estructuraRolReporte      = new EstructuraRolReporte();
                estructuraRolReporte.ColumnasDelReporte = new List <EstructuraColumnaReporte>();
                estructuraRolReporte.Conceptos          = new List <EstructuraConceptoReporte>();
                estructuraRolReporte.Rol                = nombreRol;
                estructuraRolReporte.RolUri             = rolUri;
                estructuraRolReporte.ColumnasDelReporte = new List <EstructuraColumnaReporte>();

                if (filtros.conceptos != null)
                {
                    foreach (var detalleConcepto in filtros.conceptos.OrderBy(x => x.orden))
                    {
                        foreach (var hecho in ((EntHecho[])listaDeHechos.InformacionExtra).Where(x => x.concepto.Id.Equals(detalleConcepto.Id)))
                        {
                            //Verificar si este hecho cabe en alguna de las columnas
                            var columnaYaExiste = false;
                            foreach (var columna in estructuraRolReporte.ColumnasDelReporte)
                            {
                                if (HechoPerteneceAColumna(hecho, columna, agruparPorUnidad))
                                {
                                    columnaYaExiste = true;
                                    break;
                                }
                            }
                            if (!columnaYaExiste)
                            {
                                estructuraRolReporte.ColumnasDelReporte.Add(CrearColumnaEncabezado(hecho, agruparPorUnidad));
                            }
                        }
                    }
                }

                // Ordenar las columnas
                if (estructuraRolReporte.ColumnasDelReporte.Count > 1)
                {
                    estructuraRolReporte.ColumnasDelReporte = OrdenarFechaDeColumnas(estructuraRolReporte.ColumnasDelReporte);
                }

                Debug.WriteLine(estructuraRolReporte.Rol);
                foreach (var col in estructuraRolReporte.ColumnasDelReporte)
                {
                    Debug.WriteLine(col.Entidad + "," + DateUtil.ToStandarString(col.FechaInicio) + " - " + DateUtil.ToStandarString(col.FechaFin) + " - " + DateUtil.ToStandarString(col.FechaInstante) + "," +
                                    col.Moneda
                                    );
                }

                List <EstructuraConceptoReporte> listaDeConceptos = new List <EstructuraConceptoReporte>();
                CrearEstructuraConceptosConHechos(listaDeConceptos, listaDeHechos, filtros.conceptos, estructuraRolReporte.ColumnasDelReporte, filtros.idioma, agruparPorUnidad);
                estructuraRolReporte.Conceptos = listaDeConceptos;

                estructuraReporteGenerico.ReporteGenericoPorRol = new List <EstructuraRolReporte>();
                estructuraReporteGenerico.ReporteGenericoPorRol.Add(estructuraRolReporte);
                estructuraReporteGenerico.Idioma           = filtros.idioma;
                estructuraReporteGenerico.AgruparPorUnidad = agruparPorUnidad;

                return(estructuraReporteGenerico);
            }

            return((EstructuraReporteGenerico)null);
        }
Esempio n. 3
0
        /// <summary>
        /// Arma el BsonDocument que se trata de la consulta al repositorio de informacion
        /// </summary>
        /// <param name="filtrosConsulta">Filtros de consulta a realizar en el respositorio de informacion</param>
        /// <returns>Documento con la consulta a realizar en el repositorio de informacion</returns>
        public static BsonDocument ArmarConsultaRepositorio(EntFiltroConsultaHecho filtrosConsulta)
        {
            var documentoConsulta = new StringBuilder();

            documentoConsulta.Append("{");

            if (filtrosConsulta.EsValorChunks.Value)
            {
                documentoConsulta.Append("'EsValorChunks' : true, ");
            }
            else
            {
                documentoConsulta.Append("'EsValorChunks' : { $nin : [ true ] }, ");
            }

            //Se agrega las emisoras
            documentoConsulta.Append("'Entidad.Nombre' : { $in : [");
            for (var indice = 0; indice < filtrosConsulta.filtros.entidadesId.Length; indice++)
            {
                var entidad = filtrosConsulta.filtros.entidadesId[indice];
                documentoConsulta.Append("'").Append(entidad).Append("'");
                if (indice != (filtrosConsulta.filtros.entidadesId.Length - 1))
                {
                    documentoConsulta.Append(",");
                }
            }
            documentoConsulta.Append("] }, ");

            //Se agrega las unidades

            documentoConsulta.Append("$or : [ {");
            documentoConsulta.Append("'Unidad.Medidas.Nombre' : {");
            documentoConsulta.Append("$exists : false");
            documentoConsulta.Append("} }");

            if (filtrosConsulta.filtros.unidades.Length > 0)
            {
                documentoConsulta.Append(", { 'Unidad.Medidas.Nombre' : { $in : [");
                for (var indice = 0; indice < filtrosConsulta.filtros.unidades.Length; indice++)
                {
                    var unidad = filtrosConsulta.filtros.unidades[indice];
                    documentoConsulta.Append("'").Append(unidad).Append("'");
                    if (indice != (filtrosConsulta.filtros.unidades.Length - 1))
                    {
                        documentoConsulta.Append(",");
                    }
                }
                documentoConsulta.Append("] } ");
                documentoConsulta.Append("}");
            }

            documentoConsulta.Append("],");

            //Se agregan los periodos
            documentoConsulta.Append("$and : [ { $or : [");

            for (var indice = 0; indice < filtrosConsulta.filtros.periodos.Length; indice++)
            {
                EntPeriodo periodoFiltro = filtrosConsulta.filtros.periodos[indice];
                var        fechaFinal    = periodoFiltro.FechaFin.Value;
                var        fechaInicial  = periodoFiltro.FechaInicio.Value;

                documentoConsulta.Append("{ $and : [ { 'Periodo.FechaInicio' : ISODate('").Append(fechaInicial.ToString("yyyy-MM-dd"))
                .Append("T00:00:00Z') }, { 'Periodo.FechaFin' : ISODate('").Append(fechaFinal.ToString("yyyy-MM-dd")).Append("T00:00:00Z') } ] }");
                documentoConsulta.Append(", { 'Periodo.FechaInstante': ISODate('").Append(fechaFinal.ToString("yyyy-MM-dd")).Append("T00:00:00Z') }");

                if (indice != (filtrosConsulta.filtros.periodos.Length - 1))
                {
                    documentoConsulta.Append(",");
                }
            }

            documentoConsulta.Append("] }");

            //Se agregan los conceptos

            if (filtrosConsulta.conceptos != null && filtrosConsulta.conceptos.Length > 0)
            {
                documentoConsulta.Append(", { $or : [");

                for (var indice = 0; indice < filtrosConsulta.conceptos.Length; indice++)
                {
                    var concepto = filtrosConsulta.conceptos[indice];
                    documentoConsulta.Append("{ $and : [");

                    documentoConsulta.Append("{'Concepto.IdConcepto': '" + concepto.Id + "'},");
                    documentoConsulta.Append("{'Taxonomia': '" + concepto.EspacioNombresTaxonomia + "'}");

                    //En el caso que al concepto se tengan dimensiones
                    if (concepto.InformacionDimensional != null && concepto.InformacionDimensional.Length > 0)
                    {
                        documentoConsulta.Append(", { $or : [");

                        for (var indiceDimension = 0; indiceDimension < concepto.InformacionDimensional.Length; indiceDimension++)
                        {
                            documentoConsulta.Append("{ $and : [");

                            var dimension = concepto.InformacionDimensional[indiceDimension];
                            documentoConsulta.Append("{'MiembrosDimensionales.Explicita': " + dimension.Explicita.ToString().ToLower() + "},");

                            documentoConsulta.Append(dimension.QNameDimension != null && dimension.QNameDimension.Length > 0 ? "{'MiembrosDimensionales.QNameDimension' : '" + dimension.QNameDimension + "'}," : "");
                            documentoConsulta.Append(dimension.IdDimension != null && dimension.IdDimension.Length > 0 ? "{'MiembrosDimensionales.IdDimension' : '" + dimension.IdDimension + "'}" : "");

                            documentoConsulta.Append(dimension.QNameItemMiembro != null && dimension.QNameItemMiembro.Length > 0 ? ", {'MiembrosDimensionales.QNameItemMiembro' : '" + dimension.QNameItemMiembro + "'}" : "");
                            documentoConsulta.Append(dimension.IdItemMiembro != null && dimension.IdItemMiembro.Length > 0 ? ",{'MiembrosDimensionales.IdItemMiembro' : '" + dimension.IdItemMiembro + "'}" : "");

                            documentoConsulta.Append(dimension.Filtro != null && dimension.Filtro.Length > 0 ? ", {'MiembrosDimensionales.MiembroTipificado' : /" + dimension.Filtro + "/}" : "");


                            documentoConsulta.Append("]  }");

                            if ((indiceDimension + 1) < concepto.InformacionDimensional.Length)
                            {
                                documentoConsulta.Append(",");
                            }
                        }
                        documentoConsulta.Append("] }");
                    }

                    documentoConsulta.Append("] }");

                    if (indice != (filtrosConsulta.conceptos.Length - 1))
                    {
                        documentoConsulta.Append(",");
                    }
                }
                documentoConsulta.Append("] }");
            }
            documentoConsulta.Append("] }");

            //BsonDocument FiltroConsulta = MongoDB.Bson.Serialization.BsonSerializer.Deserialize<BsonDocument>("{'idEntidad': {		$in: ['DAIMLER1', 'DAIMLER']},'medida.tipoMedida.nombre': {$in: ['MXN']},$and: [{$or: [{'periodo.fecha': ISODate('2014-12-31T00:00:00Z')},{$and: [{'periodo.fechaInicial': ISODate('2014-12-31T00:00:00Z')}, {'periodo.fecha': ISODate('2014-12-31T00:00:00Z')}]}]}]}");
            BsonDocument FiltroConsulta = BsonSerializer.Deserialize <BsonDocument>(documentoConsulta.ToString());

            return(FiltroConsulta);
        }
        public void ConsultarRepositorioInformacion()
        {
            var conectionServer = new ConnectionServer
            {
                miConnectionString = "mongodb://*****:*****@ds035185-a0.mongolab.com:35185,ds035185-a1.mongolab.com:35185/repositorioabaxxbrl?replicaSet=rs-ds035185",
                //miConnectionString = "mongodb://*****:*****@172.16.235.123:27017/repositorioAbaxXbrl",
                //miBaseDatos = "repositorioAbaxXbrl"
                miBaseDatos = "repositorioabaxxbrl"
            };

            conectionServer.init();

            var conexion            = new Conexion(conectionServer);
            var blockStoreDocIns    = new BlockStoreDocumentoInstancia(conexion);
            var blockStoreConsulta  = new BlockStoreConsulta(conexion);
            var GrupoEmpresaService = new GrupoEmpresaService
            {
                EmpresaRepository           = new EmpresaRepository(),
                GrupoEmpresaRepository      = new GrupoEmpresaRepository(),
                RegistroAuditoriaRepository = new RegistroAuditoriaRepository()
            };

            var BlockStoreHechoService = new BlockStoreHechoService
            {
                BlockStoreDocumentoInstancia = blockStoreDocIns,
                BlockStoreConsulta           = blockStoreConsulta,
                Collection          = "BlockStoreHecho",
                CollectionDimension = "BlockStoreDimension",
                CollectionEmpresas  = "BlockStoreEmpresa",
                CollectionUnidades  = "BlockStoreUnidad",
                CollectionConcepto  = "BlockStoreConcepto",
                GrupoEmpresaService = GrupoEmpresaService
            };

            var filtroConsulta = new EntFiltroConsultaHecho();

            filtroConsulta.filtros = new EntFiltrosAdicionales();

            filtroConsulta.filtros.entidadesId    = new string[2];
            filtroConsulta.filtros.entidadesId[0] = "DAIMLER";
            filtroConsulta.filtros.entidadesId[1] = "AEROMEX";

            filtroConsulta.filtros.unidades    = new string[2];
            filtroConsulta.filtros.unidades[0] = "MXN";
            filtroConsulta.filtros.unidades[1] = "USD";

            filtroConsulta.filtros.periodos = new EntPeriodo[3];

            filtroConsulta.filtros.periodos[0] = new EntPeriodo();
            filtroConsulta.filtros.periodos[1] = new EntPeriodo();
            filtroConsulta.filtros.periodos[2] = new EntPeriodo();

            filtroConsulta.filtros.periodos[0].FechaInicio = new DateTime(2015, 1, 1);
            filtroConsulta.filtros.periodos[0].FechaFin    = new DateTime(2015, 6, 30);

            filtroConsulta.filtros.periodos[1].FechaInicio = new DateTime(2015, 4, 1);
            filtroConsulta.filtros.periodos[1].FechaFin    = new DateTime(2015, 6, 30);

            filtroConsulta.filtros.periodos[2].FechaInicio = new DateTime(2014, 4, 1);
            filtroConsulta.filtros.periodos[2].FechaFin    = new DateTime(2014, 12, 31);


            filtroConsulta.idioma       = "es";
            filtroConsulta.conceptos    = new EntConcepto[6];
            filtroConsulta.conceptos[0] = new EntConcepto();
            filtroConsulta.conceptos[1] = new EntConcepto();
            filtroConsulta.conceptos[2] = new EntConcepto();
            filtroConsulta.conceptos[3] = new EntConcepto();
            filtroConsulta.conceptos[4] = new EntConcepto();
            filtroConsulta.conceptos[5] = new EntConcepto();


            filtroConsulta.conceptos[0].Id                      = "ifrs-full_AdministrativeExpense";
            filtroConsulta.conceptos[0].EsAbstracto             = false;
            filtroConsulta.conceptos[0].EspacioNombresTaxonomia = "http://www.bmv.com.mx/taxonomy/ifrs_mx/full_ifrs_mc_mx_ics_entry_point_2014-12-05";
            filtroConsulta.conceptos[0].Indentacion             = 1;
            filtroConsulta.conceptos[0].orden                   = 1;



            filtroConsulta.conceptos[1].Id                      = "ifrs-full_DistributionCosts";
            filtroConsulta.conceptos[1].EsAbstracto             = false;
            filtroConsulta.conceptos[1].EspacioNombresTaxonomia = "http://www.bmv.com.mx/taxonomy/ifrs_mx/full_ifrs_mc_mx_ics_entry_point_2014-12-05";
            filtroConsulta.conceptos[1].Indentacion             = 1;
            filtroConsulta.conceptos[1].orden                   = 2;

            filtroConsulta.conceptos[2].Id                      = "ifrs-full_Inventories";
            filtroConsulta.conceptos[2].EsAbstracto             = false;
            filtroConsulta.conceptos[2].EspacioNombresTaxonomia = "http://www.bmv.com.mx/taxonomy/ifrs_mx/full_ifrs_mc_mx_ics_entry_point_2014-12-05";
            filtroConsulta.conceptos[2].Indentacion             = 1;
            filtroConsulta.conceptos[2].orden                   = 2;

            filtroConsulta.conceptos[3].Id                                         = "ifrs-full_Equity";
            filtroConsulta.conceptos[3].EsAbstracto                                = false;
            filtroConsulta.conceptos[3].EspacioNombresTaxonomia                    = "http://www.bmv.com.mx/taxonomy/ifrs_mx/full_ifrs_mc_mx_ics_entry_point_2014-12-05";
            filtroConsulta.conceptos[3].Indentacion                                = 2;
            filtroConsulta.conceptos[3].orden                                      = 2;
            filtroConsulta.conceptos[3].InformacionDimensional                     = new EntInformacionDimensional[1];
            filtroConsulta.conceptos[3].InformacionDimensional[0]                  = new EntInformacionDimensional();
            filtroConsulta.conceptos[3].InformacionDimensional[0].Explicita        = true;
            filtroConsulta.conceptos[3].InformacionDimensional[0].IdDimension      = "ifrs-full_ComponentsOfEquityAxis";
            filtroConsulta.conceptos[3].InformacionDimensional[0].IdItemMiembro    = "ifrs-full_OtherReservesMember";
            filtroConsulta.conceptos[3].InformacionDimensional[0].QNameDimension   = "http://xbrl.ifrs.org/taxonomy/2014-03-05/ifrs-full:ComponentsOfEquityAxis";
            filtroConsulta.conceptos[3].InformacionDimensional[0].QNameItemMiembro = "http://xbrl.ifrs.org/taxonomy/2014-03-05/ifrs-full:OtherReservesMember";



            filtroConsulta.conceptos[4].Id                                       = "ifrs_mx-cor_20141205_ComercioExteriorBancarios";
            filtroConsulta.conceptos[4].EsAbstracto                              = false;
            filtroConsulta.conceptos[4].EspacioNombresTaxonomia                  = "http://www.bmv.com.mx/taxonomy/ifrs_mx/full_ifrs_mc_mx_ics_entry_point_2014-12-05";
            filtroConsulta.conceptos[4].Indentacion                              = 2;
            filtroConsulta.conceptos[4].orden                                    = 5;
            filtroConsulta.conceptos[4].InformacionDimensional                   = new EntInformacionDimensional[1];
            filtroConsulta.conceptos[4].InformacionDimensional[0]                = new EntInformacionDimensional();
            filtroConsulta.conceptos[4].InformacionDimensional[0].Explicita      = false;
            filtroConsulta.conceptos[4].InformacionDimensional[0].IdDimension    = "ifrs_mx-cor_20141205_InstitucionEje";
            filtroConsulta.conceptos[4].InformacionDimensional[0].QNameDimension = "http://bmv.com.mx/ifrs_mx-cor_20141205/full_ifrs_mx-cor_2014-12-05:InstitucionEje";
            filtroConsulta.conceptos[4].InformacionDimensional[0].Filtro         = "TOTAL";


            filtroConsulta.conceptos[5].Id                      = "ifrs-mc_DisclosureOfResultsOfOperationsAndProspectsExplanatory";
            filtroConsulta.conceptos[5].EsAbstracto             = false;
            filtroConsulta.conceptos[5].EspacioNombresTaxonomia = "http://www.bmv.com.mx/taxonomy/ifrs_mx/full_ifrs_mc_mx_ics_entry_point_2014-12-05";
            filtroConsulta.conceptos[5].Indentacion             = 3;
            filtroConsulta.conceptos[5].orden                   = 6;



            var filtroJson = JsonConvert.SerializeObject(filtroConsulta);



            var resultado = BlockStoreHechoService.ConsultarRepositorio(filtroConsulta, 1, 100);

            Debug.WriteLine(resultado.ToString());
        }
Esempio n. 5
0
        /// <summary>
        /// Arma la consulta que se trata de la consulta al repositorio de informacion
        /// </summary>
        /// <param name="filtrosConsulta">Filtros de consulta a realizar en el respositorio de informacion</param>
        /// <returns>Documento con la consulta a realizar en el repositorio de informacion</returns>
        public static IMongoQuery GenerarConsultaHecho(EntFiltroConsultaHecho filtrosConsulta)
        {
            var documentoConsulta = new StringBuilder();

            documentoConsulta.Append("{");

            // Se agregan los identificadores de envio
            IMongoQuery queryIdEnvios = GenerarConsultaIncluirOExcluir("IdEnvio", filtrosConsulta.idEnvios);

            IMongoQuery queryEsValorChunks = null;

            if (filtrosConsulta.EsValorChunks.HasValue)
            {
                if (filtrosConsulta.EsValorChunks.Value)
                {
                    queryEsValorChunks = Query.EQ("EsValorChunks", true);
                }
                else
                {
                    queryEsValorChunks = Query.NotIn("EsValorChunks", new BsonValue[] { true });
                }
            }
            else
            {
                queryEsValorChunks = Query.In("EsValorChunks", new BsonValue[] { true, false });
            }

            // Se agregan las entidades
            IMongoQuery queryEntidades = GenerarConsultaIncluirOExcluir("Entidad.Nombre", filtrosConsulta.filtros.entidadesId);

            // Se agregan las unidades
            IMongoQuery queryNoExistenUnidades = Query.NotExists("Unidad.Medidas.Nombre");
            IMongoQuery queryRangoUnidades     = GenerarConsultaIncluirOExcluir("Unidad.Medidas.Nombre", filtrosConsulta.filtros.unidades);

            IMongoQuery queryUnidades = Query.Or(
                queryNoExistenUnidades,
                queryRangoUnidades
                );

            // Se agregan los periodos
            IMongoQuery queryFechas = null;

            if (filtrosConsulta.filtros.periodos != null && filtrosConsulta.filtros.periodos.Length > 0)
            {
                List <IMongoQuery> queryTotalFechas = new List <IMongoQuery>();

                foreach (var periodoFiltro in filtrosConsulta.filtros.periodos)
                {
                    var fechaInicial = periodoFiltro.FechaInicio.Value;
                    var fechaFinal   = periodoFiltro.FechaFin.Value;

                    IMongoQuery queryFechaInicio   = Query.EQ("Periodo.FechaInicio", fechaInicial);
                    IMongoQuery queryFechaFin      = Query.EQ("Periodo.FechaFin", fechaFinal);
                    IMongoQuery queryFechaInstante = Query.EQ("Periodo.FechaInstante", fechaFinal);

                    IMongoQuery queryGrupoFechas =
                        Query.Or(
                            Query.And(
                                queryFechaInicio,
                                queryFechaFin
                                ),
                            queryFechaInstante
                            );

                    queryTotalFechas.Add(queryGrupoFechas);
                }

                queryFechas = Query.Or(queryTotalFechas);
            }
            else
            {
                IMongoQuery queryFechasFin      = GenerarConsultaIncluirOExcluir("Periodo.FechaFin", filtrosConsulta.filtros.fechasReporte);
                IMongoQuery queryFechasInstante = GenerarConsultaIncluirOExcluir("Periodo.FechaInstante", filtrosConsulta.filtros.fechasReporte);

                queryFechas = Query.Or(
                    queryFechasFin,
                    queryFechasInstante
                    );
            }

            //Se agregan los conceptos
            IMongoQuery queryConceptos = null;

            if (filtrosConsulta.conceptos != null && filtrosConsulta.conceptos.Length > 0)
            {
                List <IMongoQuery> queryTotalConceptos = new List <IMongoQuery>();

                foreach (var concepto in filtrosConsulta.conceptos)
                {
                    IMongoQuery queryIdConcepto = Query.EQ("Concepto.IdConcepto", concepto.Id);
                    IMongoQuery queryTaxonomia  = Query.EQ("Taxonomia", concepto.EspacioNombresTaxonomia ?? "");

                    IMongoQuery queryConcepto = Query.And(
                        queryIdConcepto,
                        queryTaxonomia
                        );

                    queryTotalConceptos.Add(queryConcepto);
                }

                queryConceptos = Query.Or(queryTotalConceptos);
            }

            /*
             *
             *
             *  //Se agregan los conceptos
             *
             *  if (filtrosConsulta.conceptos != null && filtrosConsulta.conceptos.Length > 0)
             * {
             *  documentoConsulta.Append(", { $or : [");
             *
             *  for (var indice = 0; indice < filtrosConsulta.conceptos.Length; indice++)
             *  {
             *      var concepto = filtrosConsulta.conceptos[indice];
             *      documentoConsulta.Append("{ $and : [");
             *
             *      documentoConsulta.Append("{'Concepto.IdConcepto': '" + concepto.Id + "'},");
             *      documentoConsulta.Append("{'Taxonomia': '" + concepto.EspacioNombresTaxonomia + "'}");
             *
             *      //En el caso que al concepto se tengan dimensiones
             *      if (concepto.InformacionDimensional != null && concepto.InformacionDimensional.Length > 0)
             *      {
             *          documentoConsulta.Append(", { $or : [");
             *
             *          for (var indiceDimension = 0; indiceDimension < concepto.InformacionDimensional.Length; indiceDimension++)
             *          {
             *              documentoConsulta.Append("{ $and : [");
             *
             *              var dimension = concepto.InformacionDimensional[indiceDimension];
             *              documentoConsulta.Append("{'MiembrosDimensionales.Explicita': " + dimension.Explicita.ToString().ToLower() + "},");
             *
             *              documentoConsulta.Append(dimension.QNameDimension != null && dimension.QNameDimension.Length > 0 ? "{'MiembrosDimensionales.QNameDimension' : '" + dimension.QNameDimension + "'}," : "");
             *              documentoConsulta.Append(dimension.IdDimension != null && dimension.IdDimension.Length > 0 ? "{'MiembrosDimensionales.IdDimension' : '" + dimension.IdDimension + "'}" : "");
             *
             *              documentoConsulta.Append(dimension.QNameItemMiembro != null && dimension.QNameItemMiembro.Length > 0 ? ", {'MiembrosDimensionales.QNameItemMiembro' : '" + dimension.QNameItemMiembro + "'}" : "");
             *              documentoConsulta.Append(dimension.IdItemMiembro != null && dimension.IdItemMiembro.Length > 0 ? ",{'MiembrosDimensionales.IdItemMiembro' : '" + dimension.IdItemMiembro + "'}" : "");
             *
             *              documentoConsulta.Append(dimension.Filtro != null && dimension.Filtro.Length > 0 ? ", {'MiembrosDimensionales.MiembroTipificado' : /" + dimension.Filtro + "/}" : "");
             *
             *
             *              documentoConsulta.Append("]  }");
             *
             *              if ((indiceDimension + 1) < concepto.InformacionDimensional.Length)
             *                  documentoConsulta.Append(",");
             *          }
             *          documentoConsulta.Append("] }");
             *      }
             *
             *      documentoConsulta.Append("] }");
             *
             *      if (indice != (filtrosConsulta.conceptos.Length - 1))
             *          documentoConsulta.Append(",");
             *  }
             *  documentoConsulta.Append("] }");
             * }
             * documentoConsulta.Append("] }");
             *
             * //BsonDocument FiltroConsulta = MongoDB.Bson.Serialization.BsonSerializer.Deserialize<BsonDocument>("{'idEntidad': {		$in: ['DAIMLER1', 'DAIMLER']},'medida.tipoMedida.nombre': {$in: ['MXN']},$and: [{$or: [{'periodo.fecha': ISODate('2014-12-31T00:00:00Z')},{$and: [{'periodo.fechaInicial': ISODate('2014-12-31T00:00:00Z')}, {'periodo.fecha': ISODate('2014-12-31T00:00:00Z')}]}]}]}");
             * BsonDocument FiltroConsulta = BsonSerializer.Deserialize<BsonDocument>(documentoConsulta.ToString());
             */
            IMongoQuery queryFinal = Query.And(
                queryIdEnvios,
                queryEsValorChunks,
                queryEntidades,
                queryUnidades,
                queryFechas,
                queryConceptos
                );

            return(queryFinal);
        }