Пример #1
0
        public async Task <PagedList <Rol> > GetRoles(RolQueryFilter filters)
        {
            var roles = await _unitOfWork.RolRepository.GetAll();

            roles = filters.TipoRol != null?roles.Where(x => x.TipoRol == filters.TipoRol) : roles;

            roles = filters.Descripcion != null?roles.Where(x => x.Descripcion.ToLower().Contains(filters.Descripcion.ToLower())) : roles;

            return(_pagedGenerator.GeneratePagedList(roles, filters));
        }
        public async Task <PagedList <SangreCliente> > GetSangreClientes(SangreClienteQueryFilter filters)
        {
            var sangresListado = await _unitOfWork.SangreClienteRepository.GetAll();

            sangresListado = filters.Tipo != null?sangresListado.Where(x => x.TipoSangre.ToLower().Contains(filters.Tipo.ToLower())) : sangresListado;

            sangresListado = filters.Descripcion != null?sangresListado.Where(x => x.Descripcion.ToLower().Contains(filters.Descripcion.ToLower())) : sangresListado;

            sangresListado = filters.Estatus != null?sangresListado.Where(x => x.Estatus == filters.Estatus) : sangresListado;

            return(_pagedGenerator.GeneratePagedList(sangresListado, filters));
        }
Пример #3
0
        public async Task <PagedList <Vehiculo> > GetVehiculos(VehiculoQueryFilter filters, ResourceLocation resourceLocation)
        {
            var vehiculos = await _unitOfWork.VehiculoRepository.GetAll();

            vehiculos = filters.Matricula != null?vehiculos.Where(x => x.Matricula == filters.Matricula) : vehiculos;

            vehiculos = filters.Placa != null?vehiculos.Where(x => x.Placa == filters.Placa) : vehiculos;

            vehiculos = filters.Lanzamiento != null?vehiculos.Where(x => x.Lanzamiento == filters.Lanzamiento.ToString()) : vehiculos;

            return(_pagedGenerator.GeneratePagedList(GetItemsOrdered(vehiculos, resourceLocation), filters));
        }
Пример #4
0
        public async Task <PagedList <Modelo> > GetModelos(ModeloQueryFilter filters)
        {
            var modelos = await _unitOfWork.ModeloRepository.GetAll();

            modelos = filters.Nombre != null?modelos.Where(x => x.Nombre.ToLower() == filters.Nombre.ToLower()) : modelos;

            modelos = filters.Descripcion != null?modelos.Where(x => x.Descripcion.ToLower().Contains(filters.Descripcion.ToLower())) : modelos;

            modelos = filters.Estatus != null?modelos.Where(x => x.Estatus == filters.Estatus) : modelos;

            return(_pagedGenerator.GeneratePagedList(modelos, filters));
        }
        public async Task <PagedList <Combustible> > GetCombustibles(CombustibleQueryFilter filters)
        {
            var combustibles = await _unitOfWork.CombustibleRepository.GetAll();

            combustibles = filters.TipoCombustible != null?combustibles.Where(x => x.TipoCombustible == filters.TipoCombustible) : combustibles;

            combustibles = filters.Descripcion != null?combustibles.Where(x => x.Descripcion.ToLower().Contains(filters.Descripcion.ToLower())) : combustibles;

            combustibles = filters.Estatus != null?combustibles.Where(x => x.Estatus == filters.Estatus) : combustibles;

            return(_pagedGenerator.GeneratePagedList(combustibles, filters));
        }
Пример #6
0
        public async Task <PagedList <Color> > GetColors(ColorQueryFilter filters)
        {
            var colores = await _unitOfWork.ColorRepository.GetAll();

            colores = filters.Nombre != null?colores.Where(x => x.Nombre.ToLower() == filters.Nombre.ToLower()) : colores;

            colores = filters.Descripcion != null?colores.Where(x => x.Descripcion.ToLower().Contains(filters.Descripcion.ToLower())) : colores;

            colores = filters.Estatus != null?colores.Where(x => x.Estatus == filters.Estatus) : colores;

            return(_pagedGenerator.GeneratePagedList(colores, filters));
        }
Пример #7
0
        public async Task <PagedList <Usuario> > GetUsuarios(UsuarioQueryFilter filters, ResourceLocation resourceLocation)
        {
            var usuarios = await _unitOfWork.UsuarioRepository.GetAll();

            usuarios = filters.Nombre != null?usuarios.Where(x => x.Nombre.ToLower() == filters.Nombre.ToLower()) : usuarios;

            usuarios = filters.Apellidos != null?usuarios.Where(x => x.Apellidos.ToLower() == filters.Apellidos.ToLower()) : usuarios;

            usuarios = filters.Email != null?usuarios.Where(x => x.Email.Contains(filters.Email.ToLower())) : usuarios;

            usuarios = filters.Creacion != null?usuarios.Where(x => x.Creacion == filters.Creacion) : usuarios;

            return(_pagedGenerator.GeneratePagedList(GetItemsOrdered(usuarios, resourceLocation), filters));
        }
Пример #8
0
        public async Task <PagedList <Marca> > GetMarcas(MarcaQueryFilter filters, ResourceLocation resourceLocation)
        {
            var marcas = await _unitOfWork.MarcaRepository.GetAll();

            marcas = filters.Nombre != null?marcas.Where(x => x.Nombre.ToLower() == filters.Nombre.ToLower()) : marcas;

            marcas = filters.Descripcion != null?marcas.Where(x => x.Descripcion.ToLower().Contains(filters.Descripcion.ToLower())) : marcas;

            marcas = filters.Lanzamiento != null?marcas.Where(x => x.Lanzamiento == filters.Lanzamiento.ToString()) : marcas;

            marcas = filters.Estatus != null?marcas.Where(x => x.Estatus == filters.Estatus) : marcas;

            return(_pagedGenerator.GeneratePagedList(GetItemsOrdered(marcas, resourceLocation), filters));
        }
Пример #9
0
        public async Task <PagedList <Cliente> > GetClientes(ClienteQueryFilter filters, ResourceLocation resourceLocation)
        {
            var clientes = await _unitOfWork.ClienteRepository.GetAll();

            clientes = filters.Dni != null ? clientes = clientes.Where(x => x.Dni == filters.Dni) : clientes;
            clientes = filters.Nombre != null ? clientes = clientes.Where(x => x.Nombre.ToLower() == filters.Nombre.ToLower()) : clientes;
            clientes = filters.Apellidos != null ? clientes = clientes.Where(x => x.Apellidos.ToLower() == filters.Apellidos.ToLower()) : clientes;
            clientes = filters.Email != null ? clientes = clientes.Where(x => x.Email.ToLower().Contains(filters.Email.ToLower())) : clientes;
            clientes = filters.Telefono != null ? clientes = clientes.Where(x => x.Telefono == filters.Telefono) : clientes;
            clientes = filters.Direccion != null ? clientes = clientes.Where(x => x.Direccion.ToLower().Contains(filters.Direccion.ToLower())) : clientes;
            clientes = filters.Nacimiento != null ? clientes = clientes.Where(x => DateTime.Parse(x.Nacimiento).Year == filters.Nacimiento) : clientes;
            clientes = GetItemsOrdered(clientes, resourceLocation);
            return(_pagedGenerator.GeneratePagedList(clientes, filters));
        }
Пример #10
0
        public async Task <PagedList <Contrato> > GetContratos(ContratoQueryFilter filters)
        {
            var contratos = await _unitOfWork.ContratoRepository.GetAll();

            contratos = filters.Concepto != null?contratos.Where(x => x.Concepto.ToLower().Contains(filters.Concepto.ToLower())) : contratos;

            contratos = filters.Descripcion != null?contratos.Where(x => x.Descripcion.ToLower().Contains(filters.Descripcion.ToLower())) : contratos;

            contratos = filters.Estatus != null?contratos.Where(x => x.Estatus == filters.Estatus) : contratos;

            contratos = filters.Cliente != null?contratos.Where(x => x.IdCliente == filters.Cliente) : contratos;

            contratos = filters.Usuario != null?contratos.Where(x => x.IdUsuario == filters.Usuario) : contratos;

            contratos = filters.Vehiculo != null?contratos.Where(x => x.IdVehiculo == filters.Vehiculo) : contratos;

            return(_pagedGenerator.GeneratePagedList(contratos, filters));
        }