public List<OrdenesPagoDetalleDto> Listado(string sortBy, string sortDirection, DateTime fechaDesde, DateTime fechaHasta, 
                bool? conAnulados, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();

            fechaDesde = fechaDesde.AddMilliseconds(-1);
            fechaHasta = fechaHasta.AddDays(1);
            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "FechaPago";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "ASC";

            Expression<Func<OrdenesPagoDetalle, bool>> where = x => (x.ImportePagado.Value == 0) &&
                                                                    (!conAnulados.HasValue || x.FechaAnulacion.HasValue == conAnulados) &&
                                                                    (x.FechaPago.Value > fechaDesde && x.FechaPago.Value < fechaHasta);
           
            var resultados = Uow.OrdenesPagosDetalle.Listado(criteros,
                                                     where,
                                                     x => x.OrdenesPago,
                                                     x => x.SucursalAlta);
            

            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.Project().To<OrdenesPagoDetalleDto>().ToList();   
        }
        public List<ProveedorDto> Listado(string sortBy, string sortDirection, int? cuenta, string denominacion, string cuit, int? provinciaId, int? localidadId, TipoProveedor tipoProveedor, bool? activo, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "Denominacion";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            Expression<Func<Proveedor, bool>> where = x => ((tipoProveedor == TipoProveedor.Normal && x.Gto == false) || (tipoProveedor == TipoProveedor.Gastos && x.Gto == true)) &&
                                                           (!cuenta.HasValue || (x.Cuenta.HasValue && x.Cuenta.ToString().Contains(cuenta.ToString()))) &&
                                                           (string.IsNullOrEmpty(denominacion) ||
                                                            x.Denominacion.Contains(denominacion)) &&
                                                           (string.IsNullOrEmpty(cuit) || x.Cuit.Contains(cuit)) &&
                                                           (!provinciaId.HasValue || x.ProvinciaId == provinciaId) &&
                                                           (!localidadId.HasValue || x.LocalidadId == localidadId) &&
                                                           (!activo.HasValue || x.Activo == activo);

            var resultados = Uow.Proveedores.Listado(criteros,
                                                     where,
                                                     x => x.Localidad,
                                                     x => x.Provincia,
                                                     x => x.CondicionCompra,
                                                     x => x.Banco);


            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.Project().To<ProveedorDto>().ToList();
        }
        public List<CuentaDto> Listado(string sortBy, string sortDirection, string nombre, int? tipoCuentaId, int? bancoPropioId, string titular, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();
            
            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "FechaApertura";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            Expression<Func<Cuenta, bool>> where = x => (string.IsNullOrEmpty(nombre) || x.Nombre.Contains(nombre)) &&
                                                        (string.IsNullOrEmpty(titular) || x.Titular.Contains(titular)) &&
                                                        (!tipoCuentaId.HasValue || x.TipoCuentaId == tipoCuentaId) &&
                                                        (!bancoPropioId.HasValue || x.BancoPropioId == bancoPropioId) &&
                                                        (x.Activo);
           
            var resultados = Uow.Cuentas.Listado(criteros,
                                                     where,
                                                     c => c.BancosPropio,
                                                     c=> c.TiposCuenta);
            

            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.Project().To<CuentaDto>().ToList();   
        }
        public List<RemitosVentaDetalleDto> Listado(string sortBy, string sortDirection, string criteria,
                               string remitoVentaId, int pageIndex, int pageSize, out int pageTotal)
        {

            var criteros = new PagingCriteria();
            Guid _remitoVentaId;
            Guid.TryParse(remitoVentaId, out _remitoVentaId);

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "FechaAlta";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            var denominacionFormateado = criteria.ToStringSearch();

            Expression<Func<RemitosVentaDetalle, bool>> where = x => x.RemitoVentaId == _remitoVentaId;

            var resultados = Uow.RemitosVentasDetalle.Listado(criteros, 
                                                        where,
                                                        x => x.Titulo,
                                                        x => x.SucursalAlta);

            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.Project().To<RemitosVentaDetalleDto>().ToList();
        }
        public List<RemitosVentaDto> Listado(string sortBy, string sortDirection, string criteria,
                                      Guid clienteId, int? numeroComprobante, 
                                      int pageIndex, int pageSize, out int pageTotal)
        {

            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "FechaAlta";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            var denominacionFormateado = criteria.ToStringSearch();
            
            Expression<Func<RemitosVenta, bool>> where = x => 
                                                         ((string.IsNullOrEmpty(criteria) || SqlFunctions.PatIndex(denominacionFormateado, x.ClienteConsignado.Denominacion) > 0) || x.ClienteConsignado.Denominacion.Contains(denominacionFormateado)) &&
                                                       (!numeroComprobante.HasValue || x.NumeroComprobante.ToString().Contains(numeroComprobante.ToString()));

            var resultados = Uow.RemitosVentas.Listado(criteros, 
                                                        where,
                                                        x => x.ClienteConsignado,
                                                        x => x.SucursalAlta);

            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.Project().To<RemitosVentaDto>().ToList();
        }
        public List<RemitosVentaDto> GetByClienteId(Guid clienteId, int sucursalId)
        {

            var criteros = new PagingCriteria();

            criteros.PageNumber = 1;
            criteros.PageSize = 500;
            criteros.SortBy = "FechaAlta";
            criteros.SortDirection = "DESC";

            Expression<Func<RemitosVenta, bool>> where = x => x.ClienteId == clienteId &&
                                                                x.SucursalAltaId==sucursalId &&
                                                              x.TipoComprobante ==
                                                              (int) TipoComprobanteEnum.RemitosConsignacCliente
                                                          &&
                                                            ((x.RemitosVentaDetalles.Sum(r => r.CntPr) + x.RemitosVentaDetalles.Sum(r => r.CntCn))
                                                                >
                                                                (x.RemitosVentaDetalles.Where(r => r.CntCn.HasValue).Sum(r => r.CntDevuelta ?? 0) + x.RemitosVentaDetalles.Where(r => r.CntCn.HasValue).Sum(r => r.CntVendida ?? 0)));
                                                           

            var resultados = Uow.RemitosVentas.Listado(criteros,
                                                            where,
                                                            x => x.RemitosVentaDetalles,
                                                            x => x.SucursalAlta);
            
            return resultados.Entities.Project().To<RemitosVentaDto>().ToList();
        }
        public List<PresupuestoDto> Listado(string sortBy, string sortDirection, string criteria, string lcn, int pageIndex, int pageSize, out int pageTotal)
        {

            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "FechaAlta";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            var cuitFormateado = criteria.PadLeft(11, '0');
            var denominacionFormateado = criteria.ToStringSearch();
            var lcnFormateado = lcn.ToStringSearch();

            Expression<Func<Presupuestos, bool>> where =
                x => (
                        (string.IsNullOrEmpty(criteria) || SqlFunctions.PatIndex(denominacionFormateado, x.Cliente.Denominacion) > 0) 
                        || x.Cliente.Denominacion.Contains(denominacionFormateado)
                        || x.Concepto.Contains(criteria) || x.Cliente.Cuit.Contains(cuitFormateado))
                        &&
                        (x.LCN.Contains(lcn) || SqlFunctions.PatIndex(lcnFormateado, x.LCN) > 0)
                        ;

            var resultados = Uow.Presupuesto.Listado(criteros,
                                                     where,
                                                     x => x.Cliente);

            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.Project().To<PresupuestoDto>().ToList();
        }
        public List<ClienteDto> Listado(string sortBy, string sortDirection, string denominacion, string cuit, bool? activo, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "Denominacion";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            var cuitFormateado = cuit.PadLeft(11, '0');
            var denominacionFormateado = denominacion.ToStringSearch();

            Expression<Func<Cliente, bool>> where =
                x =>
                (string.IsNullOrEmpty(denominacionFormateado) || SqlFunctions.PatIndex(denominacionFormateado, x.Denominacion) > 0) &&
                (string.IsNullOrEmpty(cuit) || SqlFunctions.PatIndex(cuitFormateado, x.Cuit) > 0) &&
                (!activo.HasValue || x.Activo == activo);

            var resultados = Uow.Clientes.Listado(criteros,
                                                    where,
                                                    x => x.TiposDocumentosIdentidad,
                                                    x => x.Localidad,
                                                    x => x.Profesion,
                                                    x => x.Especialidad);

            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.Project().To<ClienteDto>().ToList();
        }
        public List<Compra> Listado(string sortBy, string sortDirection, Guid proveedor)
        {
            var criteros = new PagingCriteria();

            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "FechaAlta";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "ASC";

            Expression<Func<Compra, bool>> where = x => (x.ProveedorId == proveedor);

            var resultados = Uow.Compras.Listado(criteros,
                                                    where);

            return resultados.Entities.Project().To<Compra>().ToList();
        }
Example #10
0
        public List<AutorDto> Listado(string sortBy, string sortDirection, string nombre, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "Nombre";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            Expression<Func<Autor, bool>> where = x => (string.IsNullOrEmpty(nombre) || x.Nombre.Contains(nombre));
           
            var resultados = Uow.Autores.Listado(criteros,
                                                     where);
            

            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.Project().To<AutorDto>().ToList();   
        }
        public List<VentaReservadaDto> Listado(string sortBy, string sortDirection, Guid operador, int sucursal, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "FechaAlta";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "ASC";

            Expression<Func<VentaReservada, bool>> where = x => (x.OperadorAltaId==operador) &&
                                                         (x.FechaModificacion == null) &&
                                                         (x.SucursalAltaId == sucursal);

            var resultados = Uow.VentasReservadas.Listado(criteros,
                                                    where);

            pageTotal = resultados.PagedMetadata.TotalItemCount;

         return resultados.Entities.Project().To<VentaReservadaDto>().ToList();
        }
        public List<RemitosVentaDetalleDto> ListadoByRemitoVentaId(string remitoVentaId)
        {

            var criteros = new PagingCriteria();
            Guid _remitoVentaId;
            Guid.TryParse(remitoVentaId, out _remitoVentaId);

            criteros.PageNumber = 1;
            criteros.PageSize = 100;
            criteros.SortBy = "FechaAlta";
            criteros.SortDirection =  "DESC";
            
            Expression<Func<RemitosVentaDetalle, bool>> where = x => x.RemitoVentaId == _remitoVentaId;

            var resultados = Uow.RemitosVentasDetalle.Listado(criteros,
                                                        where,
                                                        x => x.Titulo,
                                                        x => x.SucursalAlta);
            
            return resultados.Entities.Project().To<RemitosVentaDetalleDto>().ToList();
        }
Example #13
0
        public List<BancoDto> Listado(string sortBy, string sortDirection, string nombre, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "Nombre";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "ASC";

            Expression<Func<Banco, bool>> where = x => (string.IsNullOrEmpty(nombre) || x.Nombre.Contains(nombre));

            using (var uow = UowFactory.Create<ILaPazUow>())
            {
                var resultados = uow.Bancos.Listado(criteros,
                                                    where);

                pageTotal = resultados.PagedMetadata.TotalItemCount;

                return resultados.Entities.Project().To<BancoDto>().ToList();
            }
        }
        public List<ComprasDetalleDto> Listado(string sortBy, string sortDirection, Guid? compraId, Guid? tituloId, int sucursal, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "FechaAlta";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            Expression<Func<ComprasDetalle, bool>> where = x => (!compraId.HasValue || x.CompraId == compraId) &&
                                                           (!tituloId.HasValue || x.TituloId == tituloId) &&
                                                           (x.SucursalAltaId == sucursal) 
                                                           ;

            var resultados = Uow.ComprasDetalles.Listado(criteros,
                                                where,
                                                x => x.Titulo,
                                                x => x.Compra);

            pageTotal = resultados.PagedMetadata.TotalItemCount;
            return resultados.Entities.Project().To<ComprasDetalleDto>().ToList();
        }
        public List<UsuarioDto> Listado(string sortBy, string sortDirection, string criteria, string cuit,bool? habilitado, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "Usuario";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            Expression<Func<Operador, bool>> where = x => (string.IsNullOrEmpty(criteria) || x.Usuario.Contains(criteria)) &&
                                                          (string.IsNullOrEmpty(cuit) || x.Personal.Cuit.Contains(cuit)) &&
                                                          (!habilitado.HasValue || x.Habilitado == habilitado);

            var resultados = Uow.Operadores.Listado(criteros,
                                                    where,
                                                    x => x.Personal,
                                                    x => x.Roles);

            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.Project().To<UsuarioDto>().ToList();
        }
        public List<EditorialDto> Listado(string sortBy, string sortDirection, string nombre, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "Nombre";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";
            
            var nombreFormateado = nombre.ToStringSearch();

            Expression<Func<Editorial, bool>> where =
                x => (x.Activo == true) &&
                (string.IsNullOrEmpty(nombreFormateado) || SqlFunctions.PatIndex(nombreFormateado, x.Nombre) > 0);

            var resultados = Uow.Editoriales.Listado(criteros,
                                                    where);

            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.Project().To<EditorialDto>().ToList();   
        }
        public List<ProveedorSenia> Senias(string sortBy, string sortDirection, Guid? proveedorId, int sucursalId, int pageIndex, int pageSize, out int pageTotal)
        {
            using (var uow = UowFactory.Create<ILaPazUow>())
            {
                var criteros = new PagingCriteria();

                criteros.PageNumber = pageIndex;
                criteros.PageSize = pageSize;
                criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "FechaAlta";
                criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

                Expression<Func<ProveedorSenia, bool>> where =
                    x => (!proveedorId.HasValue || x.ProveedorId == proveedorId)
                         && x.SucursalAltaId == sucursalId;

                var resultados = uow.ProveedoresSenias.Listado(criteros, where);

                pageTotal = resultados.PagedMetadata.TotalItemCount;

                return resultados.Entities.ToList();
            }
        }
        public List<PresupuestoDetalleDto> ListadoByPresupuestoId(string presupuestoId)
        {

            var criteros = new PagingCriteria();
            Guid _presupuestoId;
            Guid.TryParse(presupuestoId, out _presupuestoId);

            criteros.PageNumber = 1;
            criteros.PageSize = 100;
            criteros.SortBy = "FechaAlta";
            criteros.SortDirection =  "DESC";
            
            Expression<Func<PresupuestosDetalle, bool>> where = x => x.PresupuestoId == _presupuestoId;

            var resultados = Uow.PresupuestoDetalle.Listado(criteros,
                                                        where
                                                        , x => x.Titulos
                                                        ,x => x.Sucursales
                                                        );
            
            return resultados.Entities.Project().To<PresupuestoDetalleDto>().ToList();
        }
        public List<OrdenesPagoDto> Listado(string sortBy, string sortDirection, string concepto, string nrocomprobante, 
                        string proveedorId, int? sucursalGastoId, int? centroCostoId, int? tipogastoId, 
                        TipoComprobanteEnum? tipoComprobanteId, bool pendiente, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();
            Guid _proveedorId;
            Guid.TryParse(proveedorId, out _proveedorId);

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "Fecha";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            Expression<Func<OrdenesPago, bool>> where = x => (string.IsNullOrEmpty(concepto) || x.Concepto.Contains(concepto)) &&
                                                             (string.IsNullOrEmpty(nrocomprobante) || x.Concepto.Contains(nrocomprobante)) &&
                                                             (sucursalGastoId == 0 || x.SucursalGastoId==sucursalGastoId) &&
                                                             (centroCostoId == 0 || x.CentroCostoId==centroCostoId) &&
                                                             (tipogastoId == 0 || tipogastoId == 0 || x.TipoGastoId == tipogastoId) &&
                                                             (tipoComprobanteId == 0 || tipoComprobanteId == null || x.TipoComprobanteId == tipoComprobanteId) &&
                                                             (_proveedorId == Guid.Empty || x.ProveedorId==_proveedorId) &&
                                                             (!x.FechaAnulacion.HasValue) &&
                                                             (!pendiente || x.Importe > x.ImportePagado);
           
            var resultados = Uow.OrdenesPagos.Listado(criteros,
                                                     where,
                                                     x => x.Proveedor,
                                                     x => x.Sucursal,
                                                     x => x.TiposGasto,
                                                     x => x.SucursalGasto,
                                                     x => x.CentrosCosto,
                                                     x => x.OrdenesPagoDetalles);
            

            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.Project().To<OrdenesPagoDto>().ToList();   
        }
Example #20
0
        public List<ComprasDto> Listado(string sortBy, string sortDirection, Guid? proveedorId, string nroComprobante, TipoComprobanteEnum? tipoId, int sucursal, DateTime fechaInicio, DateTime fechaFin, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "FechaAlta";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            Expression<Func<Compra, bool>> where = x => (string.IsNullOrEmpty(nroComprobante) || x.NumeroComprobante.Contains(nroComprobante)) &&
                                                           (!tipoId.HasValue || x.TipoComprobanteId == tipoId) &&
                                                           (!proveedorId.HasValue || x.ProveedorId == proveedorId) &&
                                                           (x.SucursalAltaId == sucursal) &&
                                                           (x.FechaAlta > fechaInicio) && (x.FechaAlta < fechaFin)
                                                           ;

            var resultados = Uow.Compras.Listado(criteros,
                                                where,
                                                x => x.Proveedor,
                                                x => x.TiposComprobante);

            pageTotal = resultados.PagedMetadata.TotalItemCount;
            return resultados.Entities.Project().To<ComprasDto>().ToList();
        }
        public List<ProveedorCtaCteDto> ProveedorCtaCte(string sortBy, string sortDirection, int? cuenta, string denominacion, string cuit, bool? activo, int sucursalId, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "CompraId";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            Expression<Func<ProveedoresCuentasCorriente, bool>> where = x => (
                                                           (!cuenta.HasValue || (x.Proveedor.Cuenta.HasValue && x.Proveedor.Cuenta.ToString().Contains(cuenta.ToString()))) &&
                                                           (string.IsNullOrEmpty(denominacion) ||
                                                            x.Proveedor.Denominacion.Contains(denominacion)) &&
                                                           (string.IsNullOrEmpty(cuit) || x.Proveedor.Cuit.Contains(cuit)) &&
                                                           (!activo.HasValue || x.Proveedor.Activo == activo) &&
                                                           ((x.Importe - x.Pagado) > 0)
                                                           && x.SucursalAltaId== sucursalId);

            var resultados = Uow.ProveedoresCuentasCorrientes.Listado(criteros,
                                                     where,
                                                     x => x.Proveedor,
                                                     x => x.Compra);


            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.Project().To<ProveedorCtaCteDto>().ToList();
        }
        public List<ProveedorConsignacionDto> ProveedorConsignacion(string sortBy, string sortDirection, Guid? proveedorId, int? cuenta,
            string denominacion, string cuit, bool? activo, DateTime? fechaConsigDesde, DateTime? fechaConsigHasta, bool? pendientePago,
            int sucursalId,
            int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "Id";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            Expression<Func<TituloConsignacionRendida, bool>> where = x => (x.SucursalAltaId == sucursalId &&
                (!cuenta.HasValue ||
                 (x.Proveedor.Cuenta.HasValue && x.Proveedor.Cuenta.ToString().Contains(cuenta.ToString()))) &&
                (string.IsNullOrEmpty(denominacion) ||
                 x.Proveedor.Denominacion.Contains(denominacion)) &&
                (string.IsNullOrEmpty(cuit) || x.Proveedor.Cuit.Contains(cuit)) &&
                (!activo.HasValue || x.Proveedor.Activo == activo) &&
                (!proveedorId.HasValue || x.ProveedorId == proveedorId) &&
                (!fechaConsigDesde.HasValue || x.FechaConsignacion >= fechaConsigDesde) &&
                (!fechaConsigHasta.HasValue || x.FechaConsignacion <= fechaConsigHasta)
                &&
                (!pendientePago.HasValue ||
                 (pendientePago.Value && ((x.Importe - x.Pagado) > 0 || x.Pagado == null))) ||
                (!pendientePago.Value && ((x.Importe >= x.Pagado)))
                );

            var resultados = Uow.TitulosConsignacionesRendidas.Listado(criteros, where, x => x.Proveedor);

            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.Project().To<ProveedorConsignacionDto>().ToList();
        }
        public List<ClienteMontoFavor> Senias(string sortBy, string sortDirection, Guid? clienteId, int sucursalId, int pageIndex, int pageSize, out int pageTotal)
        {
            var criteros = new PagingCriteria();

            criteros.PageNumber = pageIndex;
            criteros.PageSize = pageSize;
            criteros.SortBy = !string.IsNullOrEmpty(sortBy) ? sortBy : "FechaAlta";
            criteros.SortDirection = !string.IsNullOrEmpty(sortDirection) ? sortDirection : "DESC";

            Expression<Func<ClienteMontoFavor, bool>> where = x => x.ClienteId == clienteId &&
                                                             (x.TipoComprobanteId == TipoComprobanteEnum.SeñaCliente ||
                                                              x.TipoComprobanteId == TipoComprobanteEnum.NotaCrédito)
                                                              && x.SucursalAltaId== sucursalId
                                                              ;

            var resultados = Uow.ClientesMontosFavor.Listado(criteros, where);

            pageTotal = resultados.PagedMetadata.TotalItemCount;

            return resultados.Entities.ToList();
        }