public async Task <List <Place> > GetAllOrFilterPlace(FilterPlacesRequest filterPlaces)
{
var duplicatePlaces = new List <Place>();
int queryCount = 0;
if (FilterTools.AreIntsCorrect(filterPlaces.MinPlaceId, filterPlaces.MaxPlaceId))
{
var filterCapacity = _dataContext.Places.Where(c => c.MaximumCapacity >= filterPlaces.MinPlaceId &&
c.MaximumCapacity <= filterPlaces.MaxPlaceId);
foreach (var capacity in filterCapacity)
{
duplicatePlaces.Add(capacity);
}
queryCount++;
}
if (filterPlaces.Name != null)
{
var filterNames = _dataContext.Places.Where(c => c.Name == filterPlaces.Name);
foreach (var name in filterNames)
{
duplicatePlaces.Add(name);
}
queryCount++;
}
if (FilterTools.AreIntsCorrect(filterPlaces.MinMaxCapacity, filterPlaces.MaxCapacity))
{
var filterIds = _dataContext.Places.Where(c => c.PlaceId >= filterPlaces.MinMaxCapacity &&
c.PlaceId <= filterPlaces.MaxCapacity);
foreach (var id in filterIds)
{
duplicatePlaces.Add(id);
}
queryCount++;
}
var group = duplicatePlaces.GroupBy(i => i);
var filtered = new List <Place>();
if (queryCount == 0)
{
return(await _dataContext.Places.ToListAsync());
}
foreach (var item in group)
{
if (item.Count() == queryCount)
{
filtered.Add(item.Key);
}
}
return(filtered);
}
public async Task <List <Event> > GetAllOrFilterEvent(FilterEventsRequest filterEvents)
{
var duplicateEvents = new List <Event>();
int queryCount = 0;
if (FilterTools.AreIntsCorrect(filterEvents.MinEventId, filterEvents.MaxEventId))
{
var eventId = _dataContext.Events.Where(c => c.EventId >= filterEvents.MinEventId &&
c.EventId <= filterEvents.MaxEventId);
foreach (var id in eventId)
{
duplicateEvents.Add(id);
}
queryCount++;
}
if (FilterTools.AreIntsCorrect(filterEvents.MinPlaceId, filterEvents.MaxPlaceId))
{
var placeId = _dataContext.Events.Where(c => c.PlaceId >= filterEvents.MinPlaceId &&
c.PlaceId <= filterEvents.MaxPlaceId);
foreach (var id in placeId)
{
duplicateEvents.Add(id);
}
queryCount++;
}
if (FilterTools.AreIntsCorrect(filterEvents.MinTypeId, filterEvents.MaxTypeId))
{
var typeId = _dataContext.Events.Where(c => c.PlaceId >= filterEvents.MinTypeId &&
c.PlaceId <= filterEvents.MaxTypeId);
foreach (var id in typeId)
{
duplicateEvents.Add(id);
}
queryCount++;
}
if (filterEvents.Name != null)
{
var eventName = _dataContext.Events.Where(c => c.Name == filterEvents.Name);
foreach (var name in eventName)
{
duplicateEvents.Add(name);
}
queryCount++;
}
if (filterEvents.Description != null)
{
var eventDescription = _dataContext.Events.Where(c => c.Description == filterEvents.Description);
foreach (var description in eventDescription)
{
duplicateEvents.Add(description);
}
queryCount++;
}
if (FilterTools.AreIntsCorrect(filterEvents.MinDate?.Year, filterEvents.MaxDate?.Year))
{
var eventDate = _dataContext.Events.Where(c => c.Date >= filterEvents.MinDate &&
c.Date <= filterEvents.MaxDate);
foreach (var item in eventDate)
{
duplicateEvents.Add(item);
}
queryCount++;
}
var result = new List <Event>();
var group = duplicateEvents.GroupBy(i => i);
if (queryCount == 0)
{
var events = await _dataContext.Events.ToListAsync();
foreach (var item in events)
{
_dataContext.Entry(item).Reference(e => e.Place).Load();
_dataContext.Entry(item).Collection(e => e.SeatStatuses).Load();
}
return(events);
}
foreach (var item in group)
{
if (item.Count() == queryCount)
{
result.Add(item.Key);
}
}
return(result.ToList());
}
public async Task <List <Seat> > GetAllOrFilterSeats(FilterSeatsRequest filterSeats)
{
var duplicateSeats = new List <Seat>();
int queryCount = 0;
if (FilterTools.AreIntsCorrect(filterSeats.MinSeatId, filterSeats.MaxSeatId))
{
var filterIds = _dataContext.Seats.Where(x => x.SeatId >= filterSeats.MinSeatId &&
x.SeatId <= filterSeats.MaxSeatId);
foreach (var id in filterIds)
{
duplicateSeats.Add(id);
}
queryCount++;
}
if (FilterTools.AreIntsCorrect(filterSeats.MinTypeId, filterSeats.MaxSeatId))
{
var filterTypes = _dataContext.Seats.Where(x => x.TypeId >= filterSeats.MinTypeId &&
x.TypeId <= filterSeats.MaxSeatId);
foreach (var type in filterTypes)
{
duplicateSeats.Add(type);
}
queryCount++;
}
if (FilterTools.AreIntsCorrect(filterSeats.MinSeatNumber, filterSeats.MaxSeatNumber))
{
var filterSeatNums = _dataContext.Seats.Where(x => x.SeatNumber >= filterSeats.MinSeatNumber &&
x.SeatNumber <= filterSeats.MaxSeatNumber);
foreach (var seatNum in filterSeatNums)
{
duplicateSeats.Add(seatNum);
}
queryCount++;
}
if (FilterTools.AreIntsCorrect(filterSeats.MinRowNumber, filterSeats.MaxRowNumber))
{
var filterRows = _dataContext.Seats.Where(x => x.RowNumber >= filterSeats.MinRowNumber &&
x.RowNumber <= filterSeats.MaxRowNumber);
foreach (var row in filterRows)
{
duplicateSeats.Add(row);
}
queryCount++;
}
if (FilterTools.AreIntsCorrect(filterSeats.MinSectorNumber, filterSeats.MaxSectorNumber))
{
var filterSectors = _dataContext.Seats.Where(x => x.SectorNumber >= filterSeats.MinSectorNumber &&
x.SectorNumber <= filterSeats.MaxSectorNumber);
foreach (var sector in filterSectors)
{
duplicateSeats.Add(sector);
}
queryCount++;
}
if (FilterTools.AreIntsCorrect(filterSeats.MinPlaceId, filterSeats.MaxPlaceId))
{
var filterPlaces = _dataContext.Seats.Where(x => x.PlaceId >= filterSeats.MinPlaceId &&
x.PlaceId <= filterSeats.MaxPlaceId);
foreach (var place in filterPlaces)
{
duplicateSeats.Add(place);
}
queryCount++;
}
var group = duplicateSeats.GroupBy(i => i);
var finalSeats = new List <Seat>();
if (queryCount == 0)
{
return(await _dataContext.Seats.ToListAsync());
}
foreach (var item in group)
{
if (item.Count() == queryCount)
{
finalSeats.Add(item.Key);
}
}
return(finalSeats);
}
