public async Task Then_New_Reservation_Cloned_From_Existing(
ChangeOfPartyServiceRequest request,
Domain.Entities.Reservation existingReservation,
[Frozen] Mock <IReservationRepository> mockRepository,
AccountReservationService service)
{
request.AccountLegalEntityId = null;
existingReservation.Status = (short)ReservationStatus.Confirmed;
mockRepository
.Setup(repository => repository.GetById(request.ReservationId))
.ReturnsAsync(existingReservation);
var newReservationId = await service.ChangeOfParty(request);
newReservationId.Should().NotBeEmpty();
mockRepository
.Verify(repository => repository.CreateAccountReservation(
It.Is <Domain.Entities.Reservation>(reservation =>
reservation.Id == newReservationId &&
reservation.Status == (short)ReservationStatus.Change &&
reservation.ClonedReservationId == existingReservation.Id &&
reservation.AccountId == existingReservation.AccountId &&
reservation.AccountLegalEntityId == existingReservation.AccountLegalEntityId &&
reservation.AccountLegalEntityName == existingReservation.AccountLegalEntityName &&
reservation.ProviderId == request.ProviderId &&
reservation.CourseId == existingReservation.CourseId &&
reservation.StartDate == existingReservation.StartDate &&
reservation.ExpiryDate == existingReservation.ExpiryDate &&
reservation.IsLevyAccount == existingReservation.IsLevyAccount &&
reservation.TransferSenderAccountId == existingReservation.TransferSenderAccountId)));
}
public async Task Consume(ConsumeContext <ToolBox.Contracts.Resource.CreateResourceReservation> context)
{
_logger.LogInformation("CreateResourceReservationConsumer Called");
var reservationToCreate = new Domain.Entities.Reservation
{
Id = context.Message.Id,
UserId = context.Message.UserId,
ResourceId = context.Message.ResourceId,
From = context.Message.From,
To = context.Message.To
};
var resource = await _dbContext.Resources.FirstOrDefaultAsync(r => r.Id == reservationToCreate.ResourceId);
if (resource != null)
{
resource.Reservations ??= new List <Domain.Entities.Reservation>();
resource.Reservations.Add(reservationToCreate);
await _dbContext.Reservations.AddAsync(reservationToCreate);
await _dbContext.SaveChangesAsync(CancellationToken.None);
await context.Publish <ResourceReservationCreated>(new
{
reservationToCreate.Id
});
}
}
private ScheduleReservation CreateAppointment(Domain.Entities.Reservation reservation)
{
return(new ScheduleReservation
{
StartTime = reservation.From,
EndTime = reservation.To,
Subject = "Reservation",
Notes = $"Reservation by user: {reservation.UserId}",
Color = Color.RoyalBlue,
ReservationId = reservation.Id
});
}
public UpdateReservationViewModel(INavigationService navigator, string navigationPath, Domain.Entities.Reservation reservation, ObservableCollection <ScheduleReservation> reservations)
{
#region Navigation
NavigationPath = navigationPath;
_navigator = navigator;
#endregion
_reservation = reservation;
fromTime = new TimeSpan(reservation.From.Hour, reservation.From.Minute, 0);
toTime = new TimeSpan(reservation.To.Hour, reservation.To.Minute, 0);
_reservations = reservations;
ScheduleReservation = _reservations.FirstOrDefault(r => r.ReservationId == reservation.Id);
}
public Reservation(Domain.Entities.Reservation source)
{
Id = source.Id;
Status = (ReservationStatus)source.Status;
AccountId = source.AccountId;
AccountLegalEntityId = source.AccountLegalEntityId;
AccountLegalEntityName = source.AccountLegalEntityName;
StartDate = source.StartDate.GetValueOrDefault();
EndDate = source.ExpiryDate.GetValueOrDefault();
CreatedDate = source.CreatedDate;
CourseId = source.CourseId;
CourseName = source.Course?.Title;
CourseLevel = source.Course?.Level;
ProviderId = source.ProviderId;
}
private Task SyncReservationAsync(IQueryDbContext queryDb, Domain.Entities.Reservation dbReservation, CancellationToken stoppingToken)
{
var replacement = MapToQueryModel(dbReservation);
var filter = Builders <ReservationModel> .Filter.Eq(u => u.Id, replacement.Id);
if (dbReservation.IsDeleted)
{
return(queryDb.Reservations.DeleteOneAsync(filter, stoppingToken));
}
var options = new ReplaceOptions()
{
IsUpsert = true
};
return(queryDb.Reservations.ReplaceOneAsync(filter, replacement, options, stoppingToken));
}
private ReservationModel MapToQueryModel(Domain.Entities.Reservation dbReservation)
{
return(new ReservationModel
{
Id = dbReservation.Id,
ApartmentId = dbReservation.Apartment.Id,
ApartmentTitle = dbReservation.Apartment.Title,
GuestId = dbReservation.Guest.UserId,
GuestUsername = dbReservation.Guest.User.Username,
HostId = dbReservation.Apartment.Host.UserId,
HostUsername = dbReservation.Apartment.Host.User.Username,
NumberOfNightsRented = dbReservation.NumberOfNightsRented,
ReservationStartDate = dbReservation.ReservationStartDate,
ReservationState = dbReservation.ReservationState,
TotalCost = dbReservation.TotalCost
});
}
public void And_Reservation_Deleted_Status_Then_Throws_ArgumentException(
ChangeOfPartyServiceRequest request,
Domain.Entities.Reservation existingReservation,
[Frozen] Mock <IReservationRepository> mockRepository,
AccountReservationService service)
{
existingReservation.Status = (short)ReservationStatus.Deleted;
mockRepository
.Setup(repository => repository.GetById(request.ReservationId))
.ReturnsAsync(existingReservation);
var act = new Func <Task>(async() => await service.ChangeOfParty(request));
act.Should().Throw <ArgumentException>()
.Where(exception =>
exception.ParamName == nameof(ChangeOfPartyServiceRequest.ReservationId) &&
exception.Message.StartsWith("Reservation cannot be changed due to it's status."));
}
private static IndexedReservation MapReservation(Domain.Entities.Reservation entity, uint indexedProviderId)
{
return(new IndexedReservation
{
IndexedProviderId = indexedProviderId,
ReservationId = entity.Id,
AccountId = entity.AccountId,
IsLevyAccount = entity.IsLevyAccount,
CreatedDate = entity.CreatedDate,
StartDate = entity.StartDate,
ExpiryDate = entity.ExpiryDate,
Status = entity.Status,
CourseId = entity.CourseId,
CourseTitle = entity.Course?.Title,
CourseLevel = entity.Course?.Level,
AccountLegalEntityId = entity.AccountLegalEntityId,
ProviderId = entity.ProviderId,
AccountLegalEntityName = entity.AccountLegalEntityName,
TransferSenderAccountId = entity.TransferSenderAccountId,
UserId = entity.UserId
});
}
public async Task And_New_AccountLegalEntityId_Then_Gets_All_Details_For_That_AccountLegalEntity(
ChangeOfPartyServiceRequest request,
Domain.Entities.Reservation existingReservation,
Domain.Entities.AccountLegalEntity newAccountLegalEntity,
[Frozen] Mock <IReservationRepository> mockRepository,
[Frozen] Mock <IAccountLegalEntitiesRepository> mockAleRepository,
AccountReservationService service)
{
request.ProviderId = null;
existingReservation.Status = (short)ReservationStatus.Change;
existingReservation.IsLevyAccount = false;
newAccountLegalEntity.Account.IsLevy = true;
mockRepository
.Setup(repository => repository.GetById(request.ReservationId))
.ReturnsAsync(existingReservation);
mockAleRepository
.Setup(repository => repository.Get(request.AccountLegalEntityId.Value))
.ReturnsAsync(newAccountLegalEntity);
var newReservationId = await service.ChangeOfParty(request);
newReservationId.Should().NotBeEmpty();
mockRepository
.Verify(repository => repository.CreateAccountReservation(
It.Is <Domain.Entities.Reservation>(reservation =>
reservation.Id == newReservationId &&
reservation.Status == (short)ReservationStatus.Change &&
reservation.ClonedReservationId == existingReservation.Id &&
reservation.AccountId == newAccountLegalEntity.AccountId &&
reservation.AccountLegalEntityId == newAccountLegalEntity.AccountLegalEntityId &&
reservation.AccountLegalEntityName == newAccountLegalEntity.AccountLegalEntityName &&
reservation.ProviderId == existingReservation.ProviderId &&
reservation.CourseId == existingReservation.CourseId &&
reservation.StartDate == existingReservation.StartDate &&
reservation.ExpiryDate == existingReservation.ExpiryDate &&
reservation.IsLevyAccount == newAccountLegalEntity.Account.IsLevy)));
}
private bool ValidateReservation(ObservableCollection <ScheduleReservation> reservations, Domain.Entities.Reservation reservationToValidate)
{
if (!reservations.Any())
{
return(true);
}
foreach (var reservation in reservations)
{
if (reservation.ReservationId == reservationToValidate.Id)
{
continue;
}
if (reservation.StartTime < reservationToValidate.To && reservationToValidate.From < reservation.EndTime)
{
return(false);
}
}
return(true);
}
