/// <summary>
/// Gets the subset of <typeparamref name="TEntity"/> entities corresponding to the predicate <paramref name="predicate"/>.
/// </summary>
/// <param name="predicate">Filter which entities are returned.</param>
/// <param name="eager">Indicates whether or not to eagerly load navigation properties.</param>
/// <returns></returns>
public async Task <IEnumerable <TEntity> > GetByConditionAsync(Expression <Func <TEntity, bool> > predicate, bool eager = false)
{
var query = _context.Set <TEntity>().AsQueryable();
if (predicate != null)
{
query = query.Where(predicate);
}
if (eager)
{
var navigations = _context.Model.FindEntityType(typeof(TEntity))
.GetDerivedTypesInclusive()
.SelectMany(type => type.GetNavigations())
.Distinct();
foreach (var property in navigations)
{
query = query.Include(property.Name);
}
}
var results = await query.ToListAsync();
return(results ?? new List <TEntity>());
}
public async Task <Court> GetCourtAsync(int courtId)
{
var entity = await context.Set <CourtEntity>().FindAsync(courtId);
if (entity != null)
{
return(new Court(entity.Id, (CourtType)entity.CourtType));
}
return(null);
}
public IEnumerable <ClientBookingAddress> GetAllClientBookingsAddresses()
{
if (db != null)
{
return(db.Set <ClientBookingAddress>().ToList());
}
return(null);
}
public async Task <IEnumerable <BookingSummaryDto> > GetBookings()
{
return(await bookingContext.Set <BookingEntity>()
.Select(x => new BookingSummaryDto()
{
BookingId = x.Id,
PhoneNo = x.PhoneNo,
CourtId = x.Court.Id,
CourtTypeId = x.Court.CourtType,
CourtType = Enum.GetName(typeof(CourtType), x.Court.CourtType),
BookedFrom = x.BookedFrom,
BookedTo = x.BookedTo,
BookingStatusId = x.Status,
BookingStatus = Enum.GetName(typeof(BookingStatus), x.Status)
})
.AsNoTracking()
.ToListAsync());
}
public async Task <BookingResponseModel> CreateBookingAsync(BookingModel bookingModel)
{
var response = new BookingResponseModel {
IsSuccess = true
};
using var transaction = await _context.Database.BeginTransactionAsync();
try
{
var seatAvailable = await(from seat in _context.Set <Seat>().Where(s => (SeatTypes)s.SeatTypeId == bookingModel.SeatType)
join booking in _context.Set <Booking>().Where(b => b.VisitStartDate == bookingModel.VisitStartDate && b.BookingStatusId != (int)BookingStatuses.Cancelled)
on seat.Id equals booking.SeatId into lj
from subseat in lj.DefaultIfEmpty()
where subseat == null
select seat).FirstOrDefaultAsync();
if (seatAvailable?.Id == null)
{
await transaction.RollbackAsync();
response.IsSuccess = false;
response.ErrorMessage = $"There is no seat available for the given seat type {bookingModel.SeatType} on the date {bookingModel.VisitStartDate:dd-MM-yyyy}";
return(response);
}
var bookingId = (await _context.Set <Booking>().OrderByDescending(b => b.Id).FirstOrDefaultAsync())?.Id ?? 0 + 1;
response.BookingReference = IdGenerator.GenerateBookingReference(bookingId);
response.CreatedDate = DateTime.UtcNow;
await _context.Set <Booking>().AddAsync(new Booking
{
CreatedDate = response.CreatedDate,
BookingReference = response.BookingReference,
BookingTypeId = (int)bookingModel.BookingType,
IsAcceptTsAndCs = false,
IsAcceptCovidCharter = false,
IsNoFaceCovering = false,
IsNoShow = false,
SeatId = seatAvailable.Id,
BookingStatusId = (int)BookingStatuses.Created,
VisitStartDate = bookingModel.VisitStartDate,
VisitEndDate = bookingModel.VisitEndDate,
LastModifiedBy = Modified_By
});
await _context.SaveChangesAsync();
await transaction.CommitAsync();
}
catch
{
await transaction.RollbackAsync();
response.IsSuccess = false;
response.ErrorMessage = $"Error reserving the given seat type {bookingModel.SeatType} on the date {bookingModel.VisitStartDate:dd-MM-yyyy}";
}
return(response);
}
public IQueryable <T> GetAll()
{
return(_bookingContext.Set <T>());
}
public async Task <AvailabilitySummaryModel> GetAvailabilitySummaryAsync()
{
var availableSummaryModel = new AvailabilitySummaryModel();
var standardAvailableDates = await _workingDayService.GetStandardOrderAvailableDatesAsync();
var bulkAvailableDates = await _workingDayService.GetBulkOrderAvailableDatesAsync();
var stdSeatCount = await _context.Seats.CountAsync(s => StandardOrderSeats.Contains((SeatTypes)s.SeatTypeId));
var stdBookingCount = await(from booking in _context.Set <Booking>().Where(b => standardAvailableDates.Contains(b.VisitStartDate) && (BookingStatuses)b.BookingStatusId != BookingStatuses.Cancelled)
join seat in _context.Set <Seat>().Where(s => StandardOrderSeats.Contains((SeatTypes)s.SeatTypeId))
on booking.SeatId equals seat.Id
select new { seat.Number }).CountAsync();
var bulkSeatCount = await _context.Seats.CountAsync(s => BulkOrderSeats.Contains((SeatTypes)s.SeatTypeId));
var bulkBookingCount = await(from booking in _context.Set <Booking>().Where(b => bulkAvailableDates.Contains(b.VisitStartDate) && (BookingStatuses)b.BookingStatusId != BookingStatuses.Cancelled)
join seat in _context.Set <Seat>().Where(s => BulkOrderSeats.Contains((SeatTypes)s.SeatTypeId))
on booking.SeatId equals seat.Id
select new { seat.Number }).CountAsync();
availableSummaryModel.StandardBookingAvailable = (standardAvailableDates.Count * stdSeatCount) - stdBookingCount;
availableSummaryModel.BulkBookingsAvailable = (bulkAvailableDates.Count * bulkSeatCount) - bulkBookingCount;
return(availableSummaryModel);
}
/// <summary>
/// Generic repository providing standard CRUD operations for
/// retreiving data from the Db
/// </summary>
/// <param name="context">
/// Db context used to perform operations against the database.
/// </param>
public Repository(BookingContext context)
{
_db = context.Set <TEntity>();
_context = context;
}
public virtual void Add(T entity)
{
context.Set <T>().Add(entity);
context.SaveChanges();
}
public GenericRepository(BookingContext context)
{
this.context = context;
dbSet = context.Set <TEntity>();
}
