//Borrar reserva con id de reserva inválido
public void DeleteReservationIdExCommandTest()
{
//Obtiene comando para borrar
DeleteReservationCommand command = CommandFactory.CreateDeleteReservationCommand(-1);
Assert.Throws <ValidationErrorException>(delegate { command.Execute(); });
}
public ReservationsViewModel()
{
addReservationCommand = new AddReservationCommand(this);
updateReservationCommand = new UpdateReservationCommand(this);
deleteReservationCommand = new DeleteReservationCommand(this);
changeDayTherapistReservation = new ChangeDayTherapistReservation(this);
DateTime currentTime = DateTime.Now;
DateTime dataVisitStart = new DateTime(2019, 12, 23, 08, 30, 00);
DateTime dataVisitEnd = new DateTime(2019, 12, 23, 09, 30, 00);
DatesReservations = new ObservableCollection <DateTime> {
DateTime.Today
};
therapistsListToReservation = new ObservableCollection <string>
{
};
readPatients();
readTherapists();
reservationsList = new ObservableCollection <ReservationModel>
{
};
//DataGrid_Loaded();
DataGridReservation_Loaded();
}
public void SetReservation(TimeshiftReservationDetailItem reservationInfo)
{
Reservation = reservationInfo;
ReservationStatus = LiveStatus is LiveStatus.Onair ? null : reservationInfo?.GetReservationStatus();
DeleteReservationCommand.NotifyCanExecuteChanged();
AddReservationCommand.NotifyCanExecuteChanged();
}
public async Task Then_An_Event_Is_Fired(
DeleteReservationCommand command,
[ReservationWithCourse] Reservation reservationToDelete,
[Frozen] ValidationResult validationResult,
[Frozen] Mock <IAccountReservationService> mockService,
[Frozen] Mock <IUnitOfWorkContext> mockContext,
DeleteReservationCommandHandler handler)
{
validationResult.ValidationDictionary.Clear();
mockService
.Setup(service => service.GetReservation(command.ReservationId))
.ReturnsAsync(reservationToDelete);
await handler.Handle(command, CancellationToken.None);
mockContext.Verify(x => x.AddEvent(It.Is <ReservationDeletedEvent>(e =>
e.Id.Equals(command.ReservationId) &&
e.AccountId.Equals(reservationToDelete.AccountId) &&
e.AccountLegalEntityId.Equals(reservationToDelete.AccountLegalEntityId) &&
e.AccountLegalEntityName.Equals(reservationToDelete.AccountLegalEntityName) &&
e.ProviderId.Equals(reservationToDelete.ProviderId) &&
e.CourseId.Equals(reservationToDelete.Course.CourseId) &&
e.CourseName.Equals(reservationToDelete.Course.Title) &&
e.CourseLevel.Equals(reservationToDelete.Course.Level) &&
e.StartDate.Equals(reservationToDelete.StartDate) &&
e.EndDate.Equals(reservationToDelete.ExpiryDate) &&
e.CreatedDate.Equals(reservationToDelete.CreatedDate) &&
e.EmployerDeleted.Equals(command.EmployerDeleted)
)), Times.Once);
}
public async Task And_Guid_Then_Is_Valid(
DeleteReservationCommand command,
DeleteReservationCommandValidator validator)
{
var result = await validator.ValidateAsync(command);
result.IsValid().Should().BeTrue();
}
public async Task And_Default_Guid_Then_Not_Valid(
DeleteReservationCommandValidator validator)
{
var command = new DeleteReservationCommand();
var result = await validator.ValidateAsync(command);
result.IsValid().Should().BeFalse();
result.ValidationDictionary.Keys.Should().Contain(nameof(command.ReservationId));
}
public void And_Command_Fails_Validation_Then_Throws_ValidationException(
DeleteReservationCommand command,
string propertyName,
[Frozen] ValidationResult validationResult,
DeleteReservationCommandHandler handler)
{
validationResult.AddError(propertyName);
var act = new Func <Task>(async() => await handler.Handle(command, CancellationToken.None));
act.Should().Throw <ArgumentException>()
.WithMessage($"The following parameters have failed validation*{propertyName}*");
}
public async Task Then_Calls_Service_To_Delete_Reservation(
DeleteReservationCommand command,
[Frozen] ValidationResult validationResult,
[Frozen] Mock <IAccountReservationService> mockService,
DeleteReservationCommandHandler handler)
{
validationResult.ValidationDictionary.Clear();
await handler.Handle(command, CancellationToken.None);
mockService
.Verify(service => service.DeleteReservation(command.ReservationId),
Times.Once);
}
public ReservationListContentViewModel(DatabaseService databaseService)
{
_databaseService = databaseService;
Reservations = new ObservableCollection <ReservationItemViewModel>();
SelectedItem = new ReactiveProperty <ReservationItemViewModel>();
ConfirmationRequest = new InteractionRequest <Confirmation>();
ConditionalReservationRequest = new InteractionRequest <DataPassingNotification>();
SelectedItem.Subscribe(w =>
{
EditReservationCommand.RaiseCanExecuteChanged();
DeleteReservationCommand.RaiseCanExecuteChanged();
}).AddTo(this);
ViewModelHelper.Subscribe(this, w => w.Notification, w => UpdateRsvList());
}
public async Task DeleteReservation_NewReservation_SuccessfullyMissing()
{
IServiceCollection services = new ServiceCollection();
services.AddHostingDomain()
.AddHostingApplication()
.AddHostingInfrastructure("Server=.;Database=RestaurantManagementSystem;Trusted_Connection=True;MultipleActiveResultSets=true", "S0M3 M4G1C UN1C0RNS G3N3R4T3D TH1S S3CR3T");
var serviceProviderFactory = new DefaultServiceProviderFactory();
IServiceProvider serviceProvider = serviceProviderFactory.CreateServiceProvider(services);
IMediator Mediator = serviceProvider.GetService <IMediator>();
var createTableCommand = new CreateTableCommand();
createTableCommand.Indoor = true;
createTableCommand.Location = "Do Prozoreca";
createTableCommand.Name = "Bestest Table EVER";
createTableCommand.NumberOfSeats = 6;
createTableCommand.SmokingAllowed = true;
createTableCommand.RestaurantName = "Best Restaurant EVER";
var createTableOutputModel = await Mediator.Send(createTableCommand);
var tommorow = DateTime.UtcNow.AddDays(1);
var addReservationCommand = new AddReservationCommand();
addReservationCommand.TableId = createTableOutputModel.TableId;
addReservationCommand.Start = new DateTime(tommorow.Year, tommorow.Month, tommorow.Day, 13, 30, 0);
addReservationCommand.Guest = new Guest("Goshko", "Loshkov", "0900tainamaina");
var addReservationOutput = await Mediator.Send(addReservationCommand);
var deleteReservationCommand = new DeleteReservationCommand();
deleteReservationCommand.ReservationId = addReservationOutput.ReservationId;
await Mediator.Send(deleteReservationCommand);
var getTablesQuery = new GetTablesQuery();
var getTablesOutput = await Mediator.Send(getTablesQuery);
var dbTable = getTablesOutput.Tables.FirstOrDefault(table => table.Id == createTableOutputModel.TableId);
var targetSchedule = dbTable.GetScheduleForDateTime(addReservationCommand.Start);
await Assert.ThrowsExceptionAsync <InvalidOperationException>(() =>
{
var targetRes = targetSchedule.Reservations.First(res => res.Id == addReservationOutput.ReservationId);
return(Task.CompletedTask);
});
}
public async Task Then_Validates_The_Command(
DeleteReservationCommand command,
[Frozen] Mock <IValidator <DeleteReservationCommand> > mockValidator,
DeleteReservationCommandHandler handler)
{
mockValidator
.Setup(validator => validator.ValidateAsync(command))
.ReturnsAsync(new ValidationResult());
await handler.Handle(command, CancellationToken.None);
mockValidator
.Verify(validator => validator.ValidateAsync(command),
Times.Once);
}
public ActionResult <IEnumerable <String> > Delete(int id_res)
{
try{
DeleteReservationCommand command = CommandFactory.CreateDeleteReservationCommand(id_res);
command.Execute();
return(StatusCode(200, "Se elimino satisfactoriamente"));
}catch (ValidationErrorException ex)
{
return(BadRequest(ex.Message));
}catch (Exception ex) {
return(BadRequest(ex.Message));
}
}
public void And_Command_Not_Valid_Then_Throws_ValidationException(
DeleteReservationCommand command,
string propertyName,
ValidationResult validationResult,
[Frozen] Mock <IValidator <DeleteReservationCommand> > mockValidator,
DeleteReservationCommandHandler handler)
{
validationResult.AddError(propertyName);
mockValidator
.Setup(validator => validator.ValidateAsync(It.IsAny <DeleteReservationCommand>()))
.ReturnsAsync(validationResult);
Func <Task> act = async() => { await handler.Handle(command, CancellationToken.None); };
act.Should().ThrowExactly <ValidationException>()
.Which.ValidationResult.MemberNames.First(c => c.StartsWith(propertyName)).Should().NotBeNullOrEmpty();
}
public async Task <IActionResult> DeleteReservation([FromRoute] Guid id)
{
try
{
var command = new DeleteReservationCommand()
{
Id = id
};
var result = await _mediator.Send(command);
return(NoContent());
}
catch (EntityNotFoundException e)
{
logger.LogError(e.Message);
return(NotFound(e.Message));
}
}
public ReservationsViewModel(AccommodationUnit unit, HomePageViewModel homePageViewModel)
{
HomePageViewModel = homePageViewModel;
if (unit != null)
{
Unit = unit;
Reservations = ReservationService.GetReservations(Unit.Id, Unit.Accommodation.Id);
UnitString = "Floor : " + Unit.Floor + ", Number : " + Unit.Number;
}
else
{
Reservations = ReservationService.GetReservations(0, HomePageViewModel.Accommodation.Id);
}
//EnableUpdate = false;
//EnableDelete = false;
AddReservationCommand = new AddReservationCommand(Unit, Reservation, this);
UpdateReservationCommand = new UpdateReservationCommand(this);
DeleteReservationCommand = new DeleteReservationCommand(this);
}
public async Task Then_Sends_Delete_Request_To_Reservations_Api(
DeleteReservationCommand command,
[Frozen] Mock <IValidator <DeleteReservationCommand> > mockValidator,
[Frozen] Mock <IApiClient> mockApiClient,
[Frozen] Mock <IOptions <ReservationsApiConfiguration> > mockOptions,
DeleteReservationCommandHandler handler)
{
var expectedApiRequest = new ReservationApiRequest(mockOptions.Object.Value.Url, command.ReservationId, command.DeletedByEmployer);
mockValidator
.Setup(validator => validator.ValidateAsync(command))
.ReturnsAsync(new ValidationResult());
await handler.Handle(command, CancellationToken.None);
mockApiClient
.Verify(client => client.Delete(
It.Is <IDeleteApiRequest>(request => request.DeleteUrl == expectedApiRequest.DeleteUrl)),
Times.Once);
}
public void DeleteReservationCommandTest()
{
FlightResDTO flightDTO = new FlightResDTO("", "2019-7-6 23:00", 1, 1, 1);
//Crea la entidad por medio del mapper devuelvo del factory
ReservationFlightMapper ResFlightMapper = MapperFactory.CreateReservationFlightMapper();
Entity entity = ResFlightMapper.CreateEntity(flightDTO);
//Instancia el comando por medio del factory pasandole la entidad al constructor
AddReservationFlightCommand command = CommandFactory.CreateAddReservationFlightCommand((FlightRes)entity);
//Ejecuta y obtiene el resultado del comando
command.Execute();
int id_res = command.GetResult();
//Obtiene comando para borrar
DeleteReservationCommand command2 = CommandFactory.CreateDeleteReservationCommand(id_res);
command2.Execute();
}
public async Task <Reservation> Handle(DeleteReservationCommand request, CancellationToken cancellationToken)
{
return(await _repository.DeleteAsync(request.Id));
}
public async Task DeleteReservation([FromServices] DeleteReservationCommand command, [FromRoute] Guid reservationId)
{
await command.ExecuteAsync(reservationId);
}
public async Task <ActionResult <Unit> > DeleteReservation([FromQuery] DeleteReservationCommand deleteReservationCommand)
{
return(await Send(deleteReservationCommand));
}
public async Task DeleteReservation(DeleteReservationCommand cmd)
{
var reservation = await _reservations.FindById(cmd.Id);
await _reservations.RemoveReservation(reservation);
}
