public async Task <IEnumerable <Passenger> > GetAllAsync(QueryStringParameters queryStringParameters) { IQueryable <Passenger> passengersIq; // search if (!string.IsNullOrEmpty(queryStringParameters.SearchString)) { var search = queryStringParameters.SearchString; passengersIq = _context.Passengers.Where(p => p.PassportNumber == search || p.Citizenship == search || p.Surname == search || p.Name == search) .Include(passenger => passenger.Booking) .ThenInclude(booking => booking.Customer) .Include(passenger => passenger.Seat) .AsNoTracking(); } else { passengersIq = from b in _context.Passengers .Include(passenger => passenger.Booking) .ThenInclude(booking => booking.Customer) .Include(passenger => passenger.Seat) .AsNoTracking() select b; } // page IEnumerable <Passenger> passengers = await PaginatedList <Passenger> .CreateAsync(passengersIq, queryStringParameters.PageNumber, queryStringParameters.PageSize); // sort string not set if (string.IsNullOrEmpty(queryStringParameters.SortString)) { return(passengers); } // sort var sort = queryStringParameters.SortString; var count = ((PaginatedList <Passenger>)passengers).ItemCount; var index = ((PaginatedList <Passenger>)passengers).PageIndex; var size = ((PaginatedList <Passenger>)passengers).PageSize; passengers = sort switch { "name_desc" => passengers.OrderByDescending(p => p.Name), "surname" => passengers.OrderBy(p => p.Surname), "surname_desc" => passengers.OrderByDescending(p => p.Surname), "passport" => passengers.OrderBy(p => p.PassportNumber), "passport_desc" => passengers.OrderByDescending(p => p.PassportNumber), _ => passengers.OrderBy(p => p.Name) }; return(PaginatedList <Passenger> .ParsePaginatedList(passengers, count, index, size)); }
public async Task <IEnumerable <Booking> > GetAllAsync(QueryStringParameters queryStringParameters) { IQueryable <Booking> bookingsIq; // search if (!string.IsNullOrEmpty(queryStringParameters.SearchString)) { var search = queryStringParameters.SearchString; // search by date bookingsIq = _context.Bookings .Where(b => b.TimeStamp == DateTime.Parse(search)) .Include(booking => booking.Passengers) .ThenInclude(passenger => passenger.Seat) .Include(b => b.Customer) .AsNoTracking(); } else { bookingsIq = from b in _context.Bookings .Include(booking => booking.Passengers) .ThenInclude(passenger => passenger.Seat) .Include(b => b.Customer) .AsNoTracking() select b; } // page IEnumerable <Booking> bookings = await PaginatedList <Booking> .CreateAsync(bookingsIq, queryStringParameters.PageNumber, queryStringParameters.PageSize); // sort string not set if (string.IsNullOrEmpty(queryStringParameters.SortString)) { return(bookings); } // sort var sort = queryStringParameters.SortString; var count = ((PaginatedList <Booking>)bookings).ItemCount; var index = ((PaginatedList <Booking>)bookings).PageIndex; var size = ((PaginatedList <Booking>)bookings).PageSize; bookings = sort switch { "timestamp_desc" => bookings.OrderByDescending(b => b.TimeStamp), "cost" => bookings.OrderBy(b => b.Cost), "cost_desc" => bookings.OrderByDescending(b => b.Cost), _ => bookings.OrderBy(b => b.TimeStamp) }; return(PaginatedList <Booking> .ParsePaginatedList(bookings, count, index, size)); }
public async Task <IEnumerable <Flight> > GetAllAsync(QueryStringParameters queryStringParameters) { IQueryable <Flight> flightsIq; // search if (!string.IsNullOrEmpty(queryStringParameters.SearchString)) { var search = queryStringParameters.SearchString; flightsIq = _context.Flights .Where(f => f.Name.ToUpper().Contains(search.ToUpper()) || f.Description.ToUpper().Contains(search.ToUpper())) .Include(f => f.Departure) .ThenInclude(departure => departure.Airport) .Include(f => f.Destination) .ThenInclude(destination => destination.Airport) .AsNoTracking(); } else { flightsIq = from f in _context.Flights .Include(f => f.Departure) .ThenInclude(departure => departure.Airport) .Include(f => f.Destination) .ThenInclude(destination => destination.Airport) .AsNoTracking() select f; } // page IEnumerable <Flight> flights = await PaginatedList <Flight> .CreateAsync(flightsIq, queryStringParameters.PageNumber, queryStringParameters.PageSize); // sort string not set if (string.IsNullOrEmpty(queryStringParameters.SortString)) { return(flights); } // sort var sort = queryStringParameters.SortString; var count = ((PaginatedList <Flight>)flights).ItemCount; var index = ((PaginatedList <Flight>)flights).PageIndex; var size = ((PaginatedList <Flight>)flights).PageSize; flights = sort switch { "name_desc" => flights.OrderByDescending(f => f.Name), _ => flights.OrderBy(f => f.Name) }; return(PaginatedList <Flight> .ParsePaginatedList(flights, count, index, size)); }
public async Task <IEnumerable <Customer> > GetAllAsync(QueryStringParameters queryStringParameters) { IQueryable <Customer> customersIq; // search if (!string.IsNullOrEmpty(queryStringParameters.SearchString)) { var search = queryStringParameters.SearchString; // search by date customersIq = _context.Customers .Where(c => c.Name == search || c.Email == search) .Include(customer => customer.Bookings) .ThenInclude(booking => booking.Passengers) .AsNoTracking(); } else { customersIq = from c in _context.Customers .Include(customer => customer.Bookings) .ThenInclude(booking => booking.Passengers) .AsNoTracking() select c; } // page IEnumerable <Customer> customers = await PaginatedList <Customer> .CreateAsync(customersIq, queryStringParameters.PageNumber, queryStringParameters.PageSize); // sort string not set if (string.IsNullOrEmpty(queryStringParameters.SortString)) { return(customers); } // sort var sort = queryStringParameters.SortString; var count = ((PaginatedList <Customer>)customers).ItemCount; var index = ((PaginatedList <Customer>)customers).PageIndex; var size = ((PaginatedList <Customer>)customers).PageSize; customers = sort switch { "name_desc" => customers.OrderByDescending(c => c.Name), "email" => customers.OrderBy(c => c.Email), "email_desc" => customers.OrderByDescending(c => c.Email), _ => customers.OrderBy(c => c.Name) }; return(PaginatedList <Customer> .ParsePaginatedList(customers, count, index, size)); }
public async Task <IEnumerable <Departure> > GetAllAsync(QueryStringParameters queryStringParameters) { IQueryable <Departure> departuresIq; // search if (!string.IsNullOrEmpty(queryStringParameters.SearchString)) { var searchDate = DateTime.Parse(queryStringParameters.SearchString); departuresIq = _context.Departures .Where(d => d.Date.Equals(searchDate)) .Include(dep => dep.Airport) .AsNoTracking(); } else { departuresIq = from d in _context.Departures .Include(dep => dep.Airport) .AsNoTracking() select d; } // page IEnumerable <Departure> departures = await PaginatedList <Departure> .CreateAsync(departuresIq, queryStringParameters.PageNumber, queryStringParameters.PageSize); // sort - not set if (string.IsNullOrEmpty(queryStringParameters.SortString)) { return(departures); } // sort var sort = queryStringParameters.SortString; var count = ((PaginatedList <Departure>)departures).ItemCount; var index = ((PaginatedList <Departure>)departures).PageIndex; var size = ((PaginatedList <Departure>)departures).PageSize; departures = sort switch { "date_desc" => departures.OrderByDescending(d => d.Date), "flight" => departures.OrderBy(d => d.FlightId), "flight_desc" => departures.OrderBy(d => d.FlightId), "airport" => departures.OrderByDescending(d => d.AirportId), "airport_desc" => departures.OrderByDescending(d => d.AirportId), _ => departures.OrderBy(d => d.Date) }; return(PaginatedList <Departure> .ParsePaginatedList(departures, count, index, size)); }
public async Task <IEnumerable <Airport> > GetAllAsync(QueryStringParameters queryStringParameters) { IQueryable <Airport> airportsIq; // search if (!string.IsNullOrEmpty(queryStringParameters.SearchString)) { var searchString = queryStringParameters.SearchString; airportsIq = _context.Airports.Where(a => a.Name.ToUpper().Contains(searchString.ToUpper()) || a.Country.ToUpper().Contains(searchString.ToUpper()) || a.City.ToUpper().Contains(searchString.ToUpper())); } else { airportsIq = from a in _context.Airports select a; } // page IEnumerable <Airport> airports = await PaginatedList <Airport> .CreateAsync(airportsIq, queryStringParameters.PageNumber, queryStringParameters.PageSize); // sort string not set if (string.IsNullOrEmpty(queryStringParameters.SortString)) { return(airports); } // sort var sort = queryStringParameters.SortString; var count = ((PaginatedList <Airport>)airports).ItemCount; var index = ((PaginatedList <Airport>)airports).PageIndex; var size = ((PaginatedList <Airport>)airports).PageSize; airports = sort switch { "name_desc" => airports.OrderByDescending(a => a.Name), "country" => airports.OrderBy(a => a.Country), "country_desc" => airports.OrderByDescending(a => a.Country), "city" => airports.OrderBy(a => a.City), "city_desc" => airports.OrderByDescending(a => a.City), _ => airports.OrderBy(a => a.Name) }; return(PaginatedList <Airport> .ParsePaginatedList(airports, count, index, size)); }
public async Task <IEnumerable <Seat> > GetAllAsync(QueryStringParameters queryStringParameters) { IQueryable <Seat> seatsIq; // search if (!string.IsNullOrEmpty(queryStringParameters.SearchString)) { var search = queryStringParameters.SearchString; seatsIq = _context.Seats .Where(s => s.SeatNum.ToUpper().Contains(search.ToUpper())); } else { seatsIq = from s in _context.Seats select s; } // page IEnumerable <Seat> seats = await PaginatedList <Seat> .CreateAsync(seatsIq, queryStringParameters.PageNumber, queryStringParameters.PageSize); // sort - string not set if (string.IsNullOrEmpty(queryStringParameters.SortString)) { return(seats); } // sort var sort = queryStringParameters.SortString; var count = ((PaginatedList <Seat>)seats).ItemCount; var index = ((PaginatedList <Seat>)seats).PageIndex; var size = ((PaginatedList <Seat>)seats).PageSize; seats = sort switch { "seat_desc" => seats.OrderByDescending(s => s.SeatNum), "cabin" => seats.OrderBy(s => s.Cabin), "cabin_desc" => seats.OrderByDescending(s => s.Cabin), _ => seats.OrderBy(s => s.SeatNum) }; return(PaginatedList <Seat> .ParsePaginatedList(seats, count, index, size)); }