private byte[] GenerarStockValorizadoReporte(ReporteStockValorizadoFiltrosModel model, out ReporteFactory reporteFactory)
        {
            reporteFactory = new ReporteFactory();
            IQueryable<object> dataset;

            var rubro = Uow.Rubros.Obtener(r => r.RubroId == model.RubroId);
            var rubroDescripcion = rubro != null ? rubro.Descripcion : TodosText;

            if (model.MostrarTotalGeneral)
            {
                dataset = Uow.Reportes.StockValorizadoGeneral(model.RubroId);
                reporteFactory
                    .SetParametro("RubroDescripcion", rubroDescripcion)
                    .SetPathCompleto(Server.MapPath("~/Reportes/StockValorizadoGeneral.rdl"))
                    .SetDataSource("dataset", dataset);
            }
            else
            {
                var maxikiosco = Uow.MaxiKioscos.Obtener(m => m.MaxiKioscoId == model.MaxiKioscoId);
                var maxikioscoNombre = maxikiosco != null ? maxikiosco.Nombre : TodosText;

                dataset = Uow.Reportes.StockValorizado(model.RubroId, model.MaxiKioscoId);
                reporteFactory
                    .SetParametro("RubroDescripcion", rubroDescripcion)
                    .SetParametro("MaxikioscoNombre", maxikioscoNombre)
                    .SetPathCompleto(Server.MapPath("~/Reportes/StockValorizado.rdl"))
                    .SetDataSource("dataset", dataset);
            }

            return reporteFactory.Renderizar(model.ReporteTipo);
        }
        public ActionResult GenerarVentasPorMaxikiosco(ReporteVentasFiltrosModel reporteVentasFiltrosModel)
        {
            try
            {
                DateTime? hasta = reporteVentasFiltrosModel.Hasta == null
                                    ? (DateTime?)null
                                    : reporteVentasFiltrosModel.Hasta.GetValueOrDefault().AddDays(1);

                var ventasPorMaxikiosoDataSource =
                    Uow.Reportes.VentasPorMaxikiosco(reporteVentasFiltrosModel.Desde,
                        hasta,
                        UsuarioActual.CuentaId);

                var reporteFactory = new ReporteFactory();

                reporteFactory
                    .SetParametro("Desde", reporteVentasFiltrosModel.Desde.ToShortDateString())
                    .SetParametro("Hasta", reporteVentasFiltrosModel.Hasta.ToShortDateString())
                    .SetPathCompleto(Server.MapPath("~/Reportes/VentasPorMaxikiosco.rdl"))
                    .SetDataSource("VentasPorMaxikioscoDataSet", ventasPorMaxikiosoDataSource);

                byte[] archivo = reporteFactory.Renderizar(reporteVentasFiltrosModel.ReporteTipo);

                return File(archivo, reporteFactory.MimeType);
            }
            catch (Exception ex)
            {
                EventLogger.Log(ex);
                return null;
            }
        }
        public ActionResult GenerarVentasPorProducto(ReporteVentasFiltrosModel reporteVentasFiltrosModel)
        {
            DateTime? hasta = reporteVentasFiltrosModel.Hasta == null
                ? (DateTime?)null
                : reporteVentasFiltrosModel.Hasta.GetValueOrDefault().AddDays(1);

            var reporteFactory = new ReporteFactory();

            var rubro = Uow.Rubros.Obtener(r => r.RubroId == reporteVentasFiltrosModel.RubroId);
            var rubroDescripcion = rubro != null ? rubro.Descripcion : TodosText;

            var rubroId = reporteVentasFiltrosModel.RubroId.HasValue
                ? reporteVentasFiltrosModel.RubroId.Value.ToString()
                : null;

            reporteFactory
                .SetParametro("Desde", reporteVentasFiltrosModel.Desde.ToShortDateString(null))
                .SetParametro("Hasta", reporteVentasFiltrosModel.Hasta.ToShortDateString(null))
                .SetParametro("CuentaId", UsuarioActual.CuentaId.ToString())
                .SetParametro("RubroId", rubroId)
                .SetParametro("RubroDescripcion", rubroDescripcion);

            if (reporteVentasFiltrosModel.MostrarTotalGeneral)
            {
                var ventasPorProductoTotalGeneralDataSource =
                    Uow.Reportes.VentasPorProductoTotalGeneral(reporteVentasFiltrosModel.Desde,
                        hasta,
                        reporteVentasFiltrosModel.RubroId,
                        UsuarioActual.CuentaId);

                reporteFactory.SetPathCompleto(Server.MapPath("~/Reportes/VentasPorProductoTotalGeneral.rdl"))
                    .SetDataSource("VentasPorProductoTotalGeneralDataSet", ventasPorProductoTotalGeneralDataSource);
            }
            else
            {
                var ventasPorProductoDataSource = Uow.Reportes.VentasPorProducto(reporteVentasFiltrosModel.Desde,
                    hasta,
                    reporteVentasFiltrosModel.RubroId,
                    reporteVentasFiltrosModel.MaxiKioscoId,
                    UsuarioActual.CuentaId);

                var maxikiosco = Uow.MaxiKioscos.Obtener(m => m.MaxiKioscoId == reporteVentasFiltrosModel.MaxiKioscoId);
                var maxikioscoNombre = maxikiosco != null ? maxikiosco.Nombre : TodosText;

                reporteFactory
                    .SetParametro("MaxikioscoId", reporteVentasFiltrosModel.MaxiKioscoId.HasValue ? reporteVentasFiltrosModel.MaxiKioscoId.Value.ToString() : null)
                    .SetParametro("MaxikioscoNombre", maxikioscoNombre);

                reporteFactory.SetPathCompleto(Server.MapPath("~/Reportes/VentasPorProducto.rdl"))
                    .SetDataSource("VentasPorProductoDataSet", ventasPorProductoDataSource);

            }

            var ventasPorProductoRankingDataSource =
                Uow.Reportes.VentasPorProductoRanking(reporteVentasFiltrosModel.Desde,
                    hasta,
                    reporteVentasFiltrosModel.RubroId,
                    reporteVentasFiltrosModel.MaxiKioscoId,
                    UsuarioActual.CuentaId,
                    null);

            reporteFactory.SetDataSource("VentasPorProductoRankingDataSet", ventasPorProductoRankingDataSource);

            byte[] archivo = reporteFactory.Renderizar(reporteVentasFiltrosModel.ReporteTipo);

            return File(archivo, reporteFactory.MimeType);
        }
        public ActionResult GenerarRetirosPersonales(ReporteRetirosPersonalesFiltrosModel reporteRetirosPersonalesFiltrosModel)
        {
            DateTime? hasta = reporteRetirosPersonalesFiltrosModel.Hasta == null
                                    ? (DateTime?)null
                                    : reporteRetirosPersonalesFiltrosModel.Hasta.GetValueOrDefault().AddDays(1);

            var cierreDeCajaDataSource = Uow.Reportes.RetirosPersonales(reporteRetirosPersonalesFiltrosModel.Desde,
                                                                         hasta,
                                                                         reporteRetirosPersonalesFiltrosModel.UsuarioId);

            var usuarioNombre = (reporteRetirosPersonalesFiltrosModel.UsuarioId == null)
                                   ? TodosText
                                   : Uow.Usuarios.Obtener(reporteRetirosPersonalesFiltrosModel.UsuarioId.GetValueOrDefault()).NombreUsuario;

            var reporteFactory = new ReporteFactory();

            reporteFactory
                .SetParametro("Desde", reporteRetirosPersonalesFiltrosModel.Desde.ToShortDateString(null))
                .SetParametro("Hasta", reporteRetirosPersonalesFiltrosModel.Hasta.ToShortDateString(null))
                .SetParametro("UsuarioNombre", usuarioNombre)
                .SetPathCompleto(Server.MapPath("~/Reportes/RetirosPersonales.rdl"))
                .SetDataSource("RetirosPersonalesDataSet", cierreDeCajaDataSource);

            byte[] archivo = reporteFactory.Renderizar(reporteRetirosPersonalesFiltrosModel.ReporteTipo);

            return File(archivo, reporteFactory.MimeType);
        }
        public ActionResult GenerarTransferenciasPorProducto(ReporteTransferenciasPorProductosFiltrosModel filtros)
        {
            var reporteFactory = new ReporteFactory();

            var rubro = Uow.Rubros.Obtener(r => r.RubroId == filtros.RubroId);
            var rubroDescripcion = rubro != null ? rubro.Descripcion : TodosText;

            var rubroId = filtros.RubroId.HasValue
                ? filtros.RubroId.Value.ToString()
                : null;

            reporteFactory
                .SetParametro("Desde", filtros.Desde.ToShortDateString(null))
                .SetParametro("Hasta", filtros.Hasta.ToShortDateString(null))
                .SetParametro("CuentaId", UsuarioActual.CuentaId.ToString())
                .SetParametro("RubroId", rubroId)
                .SetParametro("RubroDescripcion", rubroDescripcion);

            if (filtros.MostrarTotalGeneral)
            {
                var transferenciasPorProductoTotalGeneralDataSource =
                    Uow.Reportes.TransferenciasPorProductoTotalGeneral(filtros.Desde,
                        filtros.HastaDiaSiguiente,
                        filtros.RubroId,
                        UsuarioActual.CuentaId);

                reporteFactory.SetPathCompleto(Server.MapPath("~/Reportes/TransferenciaPorProductoTotalGeneral.rdl"))
                    .SetDataSource("TransferenciasPorProductoTotalGeneralDataSet", transferenciasPorProductoTotalGeneralDataSource);
            }
            else
            {
                var transferenciasPorProductoDataSource = Uow.Reportes.TransferenciasPorProducto(filtros.Desde,
                    filtros.HastaDiaSiguiente,
                    filtros.RubroId,
                    filtros.MaxiKioscoOrigenId,
                    filtros.MaxiKioscoDestinoId,
                    UsuarioActual.CuentaId);

                var maxikioscoOrigen = Uow.MaxiKioscos.Obtener(m => m.MaxiKioscoId == filtros.MaxiKioscoOrigenId);
                var maxikioscoOrigenNombre = maxikioscoOrigen != null ? maxikioscoOrigen.Nombre : TodosText;

                var maxikioscoDestino = Uow.MaxiKioscos.Obtener(m => m.MaxiKioscoId == filtros.MaxiKioscoDestinoId);
                var maxikioscoDestinoNombre = maxikioscoDestino != null ? maxikioscoDestino.Nombre : TodosText;

                reporteFactory
                    .SetParametro("MaxikioscoOrigenNombre", maxikioscoOrigenNombre)
                    .SetParametro("MaxikisocoDestinoNombre", maxikioscoDestinoNombre);

                reporteFactory.SetPathCompleto(Server.MapPath("~/Reportes/TransferenciaPorProducto.rdl"))
                    .SetDataSource("TransferenciasPorProductoDataSet", transferenciasPorProductoDataSource);

            }

            byte[] archivo = reporteFactory.Renderizar(filtros.ReporteTipo);

            return File(archivo, reporteFactory.MimeType);
        }
        public ActionResult GenerarGastoPorCategoria(ReporteGastoPorCategoriaFiltrosModel model)
        {
            DateTime? hasta = model.Hasta == null
                                    ? (DateTime?)null
                                    : model.Hasta.GetValueOrDefault().AddDays(1);

            var reporteFactory = new ReporteFactory();

            var categoria = Uow.CategoriasCostos.Obtener(r => r.CategoriaCostoId == model.CategoriaId);
            var categoriaDescripcion = categoria != null ? categoria.Descripcion : TodosText;

            var subcategoria = Uow.CategoriasCostos.Obtener(r => r.CategoriaCostoId == model.SubCategoriaId);
            var subcategoriaDescripcion = subcategoria != null ? subcategoria.Descripcion : TodosText;

            var maxikiosco = Uow.MaxiKioscos.Obtener(r => r.MaxiKioscoId == model.MaxikioscoId);
            var maxikioscoDescripcion = maxikiosco != null ? maxikiosco.Nombre : TodosText;

            var parameters = new Dictionary<string, string>
                                  {
                                      {"MaxikioscoId", model.MaxikioscoId.GetValueOrDefault().ToString()},
                                      {"CategoriaCostoId", model.CategoriaId.GetValueOrDefault().ToString()},
                                      {"SubCategoriaCostoId", model.SubCategoriaId.GetValueOrDefault().ToString()},
                                      {"Categoria", categoriaDescripcion},
                                      {"SubCategoria", subcategoriaDescripcion},
                                      {"Maxikiosco", maxikioscoDescripcion},
                                      {"Desde", model.Desde == null ? "-" : model.Desde.GetValueOrDefault().ToShortDateString()},
                                      {"Hasta", model.Hasta == null ? "-" : model.Hasta.GetValueOrDefault().ToShortDateString()}
                                  };

            if (model.MostrarTotalGeneral)
            {
                var gastosPorCategoriaTotalGeneralDataSource =
                    Uow.Reportes.GastosPorCategoriaTotalGeneral(model.Desde,
                        hasta,
                        model.MaxikioscoId,
                        model.CategoriaId,
                        model.SubCategoriaId);

                reporteFactory.SetPathCompleto(Server.MapPath("~/Reportes/GastosPorCategoriaTotalGeneral.rdl"))
                    .SetDataSource("DataSet1", gastosPorCategoriaTotalGeneralDataSource);
            }
            else
            {
                var gastosPorCategoriaDataSource = Uow.Reportes.GastosPorCategoria(model.Desde,
                    hasta,
                    model.MaxikioscoId,
                    model.CategoriaId,
                    model.SubCategoriaId);

                reporteFactory.SetPathCompleto(Server.MapPath("~/Reportes/GastosPorCategoria.rdl"))
                    .SetDataSource("DataSet1", gastosPorCategoriaDataSource);

            }

            reporteFactory.SetParametro(parameters);

            byte[] archivo = reporteFactory.Renderizar(model.ReporteTipo);

            return File(archivo, reporteFactory.MimeType);
        }
        public ActionResult GenerarGanaciaAdicionalExcepcionRubro(GanaciaAdicionalExcepcionRubroFiltrosModel ganaciaAdicionalExcepcionRubroFiltrosModel)
        {
            DateTime? hasta = ganaciaAdicionalExcepcionRubroFiltrosModel.Hasta == null
                                    ? (DateTime?)null
                                    : ganaciaAdicionalExcepcionRubroFiltrosModel.Hasta.GetValueOrDefault().AddDays(1);

            var ganaciaAdicionalExcepcionRubroDataSource = Uow.Reportes.GanaciaAdicionalExcepcionRubro(ganaciaAdicionalExcepcionRubroFiltrosModel.Desde,
                                                                            hasta,
                                                                            ganaciaAdicionalExcepcionRubroFiltrosModel.MaxiKioscoId,
                                                                            ganaciaAdicionalExcepcionRubroFiltrosModel.RubroId,
                                                                            UsuarioActual.CuentaId).ToList();

            var rubro = Uow.Rubros.Obtener(r => r.RubroId == ganaciaAdicionalExcepcionRubroFiltrosModel.RubroId);
            var rubroDescripcion = rubro != null ? rubro.Descripcion : TodosText;

            var maxikiosco = Uow.MaxiKioscos.Obtener(m => m.MaxiKioscoId == ganaciaAdicionalExcepcionRubroFiltrosModel.MaxiKioscoId);
            var maxikioscoNombre = maxikiosco != null ? maxikiosco.Nombre : TodosText;

            var reporteFactory = new ReporteFactory();

            reporteFactory
                .SetParametro("Desde", ganaciaAdicionalExcepcionRubroFiltrosModel.Desde.ToShortDateString(null))
                .SetParametro("Hasta", ganaciaAdicionalExcepcionRubroFiltrosModel.Hasta.ToShortDateString(null))
                .SetParametro("RubroDescripcion", rubroDescripcion)
                .SetParametro("MaxikioscoNombre", maxikioscoNombre)
                .SetPathCompleto(Server.MapPath("~/Reportes/GanaciaAdicionalExcepcionRubro.rdl"))
                .SetDataSource("GanaciaAdicionalExcepcionRubroDataSet", ganaciaAdicionalExcepcionRubroDataSource);

            byte[] archivo = reporteFactory.Renderizar(ganaciaAdicionalExcepcionRubroFiltrosModel.ReporteTipo);

            return File(archivo, reporteFactory.MimeType);
        }
        public ActionResult GenerarDineroSobranteFaltante(ReporteDineroSobranteFaltanteFiltrosModel reporteDineroSobranteFaltanteFiltros)
        {
            DateTime? hasta = reporteDineroSobranteFaltanteFiltros.Hasta == null
                                    ? (DateTime?)null
                                    : reporteDineroSobranteFaltanteFiltros.Hasta.GetValueOrDefault().AddDays(1);

            var dineroSobranteFaltanteDataSource = Uow.Reportes.DineroSobranteFaltante(reporteDineroSobranteFaltanteFiltros.Desde,
                                                                         hasta,
                                                                         reporteDineroSobranteFaltanteFiltros.MaxiKioscoId,
                                                                         UsuarioActual.CuentaId);

            var maxikiosco = Uow.MaxiKioscos.Obtener(m => m.MaxiKioscoId == reporteDineroSobranteFaltanteFiltros.MaxiKioscoId);
            var maxikioscoNombre = maxikiosco != null ? maxikiosco.Nombre : TodosText;

            var reporteFactory = new ReporteFactory();

            reporteFactory
                .SetParametro("Desde", reporteDineroSobranteFaltanteFiltros.Desde.ToShortDateString(null))
                .SetParametro("Hasta", reporteDineroSobranteFaltanteFiltros.Hasta.ToShortDateString(null))
                .SetParametro("MaxikioscoNombre", maxikioscoNombre)
                .SetPathCompleto(Server.MapPath("~/Reportes/DineroSobranteFaltante.rdl"))
                .SetDataSource("DiferenciaFaltanteSobranteDataSet", dineroSobranteFaltanteDataSource);

            byte[] archivo = reporteFactory.Renderizar(reporteDineroSobranteFaltanteFiltros.ReporteTipo);

            return File(archivo, reporteFactory.MimeType);
        }
        public ActionResult GenerarComprasPorProveedor(ReporteComprasPorProveedorFiltrosModel model)
        {
            DateTime? hasta = model.Hasta == null
                                    ? (DateTime?)null
                                    : model.Hasta.GetValueOrDefault().AddDays(1);

            var proveedoresDataSource = Uow.Reportes.ComprasPorProveedor(model.Desde, hasta, model.ProveedorId, UsuarioActual.CuentaId);
            var top5DataSource = Uow.Reportes.ComprasPorProveedor(model.Desde, hasta, null, UsuarioActual.CuentaId)
                                            .OrderByDescending(p => p.DescuentoTotal).Take(5).ToList();

            var reporteFactory = new ReporteFactory();

            var datasources = new Dictionary<string, object>
                                  {
                                      {"ComprasPorProveedorDataSet", proveedoresDataSource},
                                      {"Top5", top5DataSource }
                                  };

            var proveedor = Uow.Proveedores.Obtener(m => m.ProveedorId == model.ProveedorId);
            var proveedorNombre = proveedor != null ? proveedor.Nombre : TodosText;

            reporteFactory
                .SetParametro("Desde", model.Desde.ToShortDateString(null))
                .SetParametro("Hasta", model.Hasta.ToShortDateString(null))
                .SetParametro("ProveedorNombre", proveedorNombre)
                .SetParametro("ProveedorId", model.ProveedorId.GetValueOrDefault().ToString())
                .SetParametro("CuentaId", UsuarioActual.CuentaId.ToString())
                .SetPathCompleto(Server.MapPath("~/Reportes/ComprasPorProveedor.rdl"))
                .SetDataSource(datasources);

            byte[] archivo = reporteFactory.Renderizar(model.ReporteTipo);

            return File(archivo, reporteFactory.MimeType);
        }
        public ActionResult GenerarCierresDeCaja(ReporteCierresDeCajaFiltrosModel reporteCierresDeCajaFiltrosModel)
        {
            DateTime? hasta = reporteCierresDeCajaFiltrosModel.Hasta == null
                                    ? (DateTime?)null
                                    : reporteCierresDeCajaFiltrosModel.Hasta.GetValueOrDefault().AddDays(1);

            var cierreDeCajaDataSource = Uow.Reportes.CierresDeCaja(reporteCierresDeCajaFiltrosModel.Desde,
                                                                         hasta,
                                                                         reporteCierresDeCajaFiltrosModel.MaxiKioscoId,
                                                                         reporteCierresDeCajaFiltrosModel.UsuarioId,
                                                                         UsuarioActual.CuentaId);

            var usuarioNombre = (reporteCierresDeCajaFiltrosModel.UsuarioId == null)
                                   ? TodosText
                                   : Uow.Usuarios.Obtener(reporteCierresDeCajaFiltrosModel.UsuarioId.GetValueOrDefault()).NombreUsuario;

            var maxikiosco = Uow.MaxiKioscos.Obtener(m => m.MaxiKioscoId == reporteCierresDeCajaFiltrosModel.MaxiKioscoId);
            var maxikioscoNombre = maxikiosco != null ? maxikiosco.Nombre : TodosText;

            var reporteFactory = new ReporteFactory();

            reporteFactory
                .SetParametro("Desde", reporteCierresDeCajaFiltrosModel.Desde.ToShortDateString(null))
                .SetParametro("Hasta", reporteCierresDeCajaFiltrosModel.Hasta.ToShortDateString(null))
                .SetParametro("UsuarioNombre", usuarioNombre)
                .SetParametro("MaxikioscoNombre", maxikioscoNombre)
                .SetPathCompleto(Server.MapPath("~/Reportes/CierresDeCaja.rdl"))
                .SetDataSource("CierresDeCajaDataSet", cierreDeCajaDataSource);

            byte[] archivo = reporteFactory.Renderizar(reporteCierresDeCajaFiltrosModel.ReporteTipo);

            return File(archivo, reporteFactory.MimeType);
        }