public async Task <IActionResult> Create([FromBody] JObject createReservationDtoJObject)
{
var createReservationDto = new CreateReservationDto(createReservationDtoJObject);
await _reservationRepository.Create(createReservationDto);
return(Ok());
}
public IActionResult Post(CreateReservationDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ReservationReadDto readDto = new ReservationReadDto();
try
{
//mark room as booked
//might want to differientiate online and admin end points but
//use the same implementation
// online user's reservation room should still be free until they make payment
//perphaps there should be a setup that tell us how long an online room should
//remain booked before successful transaction is confirmed.
_repository.BeginTransaction();
var reservation = _mapper.Map <Reservation>(model);
// reservation.DateCreated = DateTime.Now;
reservation.ReservationDate = DateTime.Now;
_repository.updateRoomStatus(reservation.RoomId, RoomStatusEnum.BookedPaid);
_repository.createReservation(reservation);
_repository.saveChanges();
_repository.CommitTransaction();
readDto = _mapper.Map <ReservationReadDto>(reservation);
}
catch (Exception ex)
{
_repository.RollBackTransaction();
throw new ApiException(ex.Message, 400);
}
return(Ok(readDto));
}
public async Task <APIResponse> Post(CreateReservationDto createReservationDto)
{
try
{
var reserv = _mapper.Map <Reservation>(createReservationDto);
_cinemaDbContext.Reservation.Add(reserv);
await _cinemaDbContext.SaveChangesAsync();
return(APIResponse.GetAPIResponse((int)HttpStatusCode.Created, "Reservation Created Successfully", reserv));
}
catch (Exception x)
{
return(APIResponse.GetAPIResponse((int)HttpStatusCode.BadRequest, x.InnerException?.Message ?? x.Message, null));
}
}
public async Task <GetReservationDto> CreateReservation(CreateReservationDto reservationDto)
{
Reservation reservation = new Reservation
{
ArrivalDate = reservationDto.ArrivalDate,
DepartureDate = reservationDto.DepartureDate,
NumberOfAdults = reservationDto.NumberOfAdults,
NumberOfChildren = reservationDto.NumberOfChildren,
UserId = reservationDto.UserId,
};
_context.Reservations.Add(reservation);
await _context.SaveChangesAsync();
return(new GetReservationDto(reservation));
}
public async Task <ActionResult <GetReservationDto> > PostReservation([FromBody] CreateReservationDto reservationDto)
{
GetReservationDto getReservationDto = await _reservationService.CreateReservation(reservationDto);
return(CreatedAtAction("GetReservationByRef", new { reference = getReservationDto.Ref }, getReservationDto));
}
public async Task Create(CreateReservationDto createReservationDto)
{
var employeeDb = await _dbLjepotaServisContext
.UserStores
.Include(userStore => userStore.Store)
.SingleAsync(userStore => userStore.UserId == createReservationDto.Employee.Id);
var store = employeeDb.Store;
var clientStoreOrDefault = await _dbLjepotaServisContext.UserStores.SingleOrDefaultAsync(userStore => userStore.UserId == createReservationDto.Client.Id && userStore.StoreId == store.Id);
if (clientStoreOrDefault == null)
{
var clientDb = await _dbLjepotaServisContext.Users.FindAsync(createReservationDto.Client.Id);
clientStoreOrDefault = new UserStore
{
UserId = clientDb.Id,
User = clientDb,
Store = store,
StoreId = store.Id
};
await _dbLjepotaServisContext.AddAsync(clientStoreOrDefault);
await _dbLjepotaServisContext.SaveChangesAsync();
}
var reservation = new Reservation
{
UserStoreEmployee = employeeDb,
UserStoreEmployeeId = employeeDb.Id,
UserStore = clientStoreOrDefault,
UserStoreId = clientStoreOrDefault.Id,
TimeOfReservation = createReservationDto.DateTimeOfReservation
};
await _dbLjepotaServisContext.Reservations.AddAsync(reservation);
await _dbLjepotaServisContext.SaveChangesAsync();
var reservationServiceList = createReservationDto.Services
.Select(service =>
{
var serviceDb = _dbLjepotaServisContext.Services.Find(service.Id);
return(new ReservationService
{
Reservation = reservation,
ReservationId = reservation.Id,
Service = serviceDb,
ServiceId = serviceDb.Id
});
}).ToList();
var totalTimeOfReservation = new TimeSpan();
totalTimeOfReservation = reservationServiceList.Aggregate(totalTimeOfReservation,
(accumulator, r) => accumulator + r.Service.Duration);
reservation.EndOfReservation = reservation.TimeOfReservation.Add(totalTimeOfReservation);
await _dbLjepotaServisContext.ReservationServices.AddRangeAsync(reservationServiceList);
await _dbLjepotaServisContext.SaveChangesAsync();
}
public async Task <APIResponse> Post([FromForm] CreateReservationDto createReservationDto)
{
return(await _reservationService.Post(createReservationDto));
}
