public async Task <IActionResult> Create([FromBody] ReservationCreateDTO reservationDTO)
{
try
{
if (reservationDTO == null)
{
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var reservation = _mapper.Map <Reservation>(reservationDTO);
var isSuccess = await _reservationRepository.Create(reservation);
if (!isSuccess)
{
return(InternalError($"Creation failed"));
}
return(Created("Create", new { reservation }));
}
catch (Exception e)
{
return(InternalError($"{e.Message} - {e.InnerException}"));
}
}
public async Task <ReservationDTO> PutAsync(ReservationCreateDTO reservation)
{
this.Logger.LogTrace($"{nameof(this.PutAsync)} called");
var result = await this.ReservationCreateService.CreateAsync(this.Mapper.Map <ReservationUpdateModel>(reservation));
return(this.Mapper.Map <ReservationDTO>(result));
}
private static Reservation DTOCreateToReservation(ReservationCreateDTO reservationDTO) =>
new Reservation
{
Title = reservationDTO.Title,
Description = reservationDTO.Description,
Rating = reservationDTO.Rating,
Favorite = reservationDTO.Favorite,
};
public async Task <ActionResult> Create(ReservationCreateDTO Reservation)
{
var result = await _ReservationService.Create(Reservation);
return(CreatedAtAction(
"GetById",
new { id = result.ReservationId },
result));
}
public static Reservation ToReservation(this ReservationCreateDTO dto)
{
return(new Reservation()
{
RoomId = dto.RoomId,
StartDate = dto.StartDate,
EndDate = dto.EndDate,
AdditionalInfo = dto.AdditionalInfo
});
}
public async Task <ReservationDTO> CreateReservation(ReservationCreateDTO reservationCreateDTO, int userId)
{
ValidationResults result = ModelValidator.IsValid(reservationCreateDTO);
if (!result.Successed)
{
throw ValidationExceptionBuilder.BuildValidationException(result);
}
var room = context.Rooms.Get(reservationCreateDTO.RoomId);
if (room == null)
{
throw new NotFoundException("No such room");
}
Guest guest = context.Guests.Get(userId);
if (context.UserBlackLists.GetAll().Where(x => x.GuestId == userId && x.HotelId == room.HotelId).Count() != 0)
{
throw new ValidationException("You are in a hotel's black list");
}
if (reservationCreateDTO.EndDate < reservationCreateDTO.StartDate)
{
throw new ValidationException("Reservation end date must be greater than a start date");
}
if (reservationCreateDTO.EndDate - reservationCreateDTO.StartDate > TimeSpan.FromDays(20))
{
throw new ValidationException("Reservation duration can't be greater than a 20 days");
}
bool canBeReserved = room.Reservations
.Where(r => r.EndDate <reservationCreateDTO.StartDate || r.StartDate> reservationCreateDTO.EndDate)
.Count() == room.Reservations.Count();
if (!canBeReserved)
{
throw new ValidationException("Room is not available is this time");
}
var reservation = reservationCreateDTO.ToReservation();
reservation.GuestId = userId;
context.Reservations.Create(reservation);
await context.SaveAsync();
return(reservation.ToReservationDTO());
}
public async Task <ActionResult> PostReservation(int contactId, ReservationCreateDTO reservationCreateDTO)
{
var contact = await _context.Contacts.FindAsync(contactId);
if (contact == null)
{
return(NotFound());
}
var reservation = DTOCreateToReservation(reservationCreateDTO);
reservation.Contact = contact;
_context.Reservations.Add(reservation);
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <ReservationDTO> Create(ReservationCreateDTO model)
{
var entry = new Reservation
{
ReservationId = model.ReservationId,
Date = model.Date,
Discount = model.Discount,
Price = model.Price,
LocationId = model.LocationId,
PaymentId = model.PaymentId,
SupplierId = model.SupplierId
};
await _context.AddAsync(entry);
await _context.SaveChangesAsync();
return(_mapper.Map <ReservationDTO>(entry));
}
public async Task <IActionResult> PutReservation(int id, ReservationCreateDTO reservationDTO)
{
if (!ReservationExists(id))
{
return(NotFound());
}
var reservation = DTOCreateToReservation(reservationDTO);
reservation.Id = id;
reservation.UpdatedAt = DateTime.UtcNow;
_context.Entry(reservation).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(BadRequest());
}
return(NoContent());
}
public BLL.App.DTO.Reservation MapCreateDto(ReservationCreateDTO createDto)
{
return(Mapper.Map <BLL.App.DTO.Reservation>(createDto));
}
public async Task <ReservationDTO> CreateReservation([FromBody] ReservationCreateDTO reservationCreateDTO)
{
return(await this.reservationService.CreateReservation(reservationCreateDTO, User.ConvertToUserData().Id));
}
public async Task <ActionResult> CreateReservation(int parkingLotId, ReservationCreateDTO reservationCreateDTO)
{
// Get the userId from the token
var userId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
var userFromRepo = await _repo.GetUserById(userId);
var reservation = _mapper.Map <Reservation>(reservationCreateDTO);
var vehicle = userFromRepo.Vehicles.FirstOrDefault();
var parkinglot = await _repo.GetParkingLotById(parkingLotId);
if (vehicle != null && parkinglot != null)
{
_repo.Add(reservation);
}
else
{
BadRequest("Could not add the reservation");
}
// Save a new reservation
if (await _repo.SaveAll())
{
// For driver
var userReservation = new AppUserReservation
{
User = userFromRepo,
UserId = userId,
Reservation = reservation,
ReservationId = reservation.Id
};
_repo.Add(userReservation);
// For owner
var ownerReservation = new AppUserReservation
{
User = parkinglot.User,
UserId = parkinglot.UserId,
Reservation = reservation,
ReservationId = reservation.Id
};
_repo.Add(ownerReservation);
var reservedParkingLot = new ReservedParkingLot
{
PhotoUrl = parkinglot.PhotoUrl,
Title = parkinglot.Title,
City = parkinglot.City,
Address = parkinglot.Address,
PostalCode = parkinglot.PostalCode
};
//_repo.Add(reservedParkingLot);
reservation.ReservedParkingLot = reservedParkingLot;
if (await _repo.SaveAll())
{
var reservationToReturn = _mapper.Map <ReservationDTO>(reservation);
return(CreatedAtRoute("GetReservation", new { id = reservation.Id }, reservationToReturn));
}
}
return(BadRequest("Could not add the reservation"));
}
