public async Task <ActionResult> CreateForUnregistered(CreateReservationForNonRegisteredUserViewModel model)
{
_logger.Info("Creating Reservation! Params: " + model.ToJson());
if (!ModelState.IsValid)
{
_logger.Error("Creating Reservation Form Invalid! Errors:" + ModelState.ToJson());
return(Json(ModelState.ToDictionary()));
}
try
{
CreateReservationDTO reservation = Mapper.Map <CreateReservationForNonRegisteredUserViewModel, CreateReservationDTO>(model);
await ReservationsManager.CreateReservation(reservation);
_logger.Info("Creating Reservation Successfully!");
return(Json("STATUS_OK"));
}
catch (Exception ex)
{
_logger.Error(ex, "Creating Reservation Failed!");
throw;
}
}
public IActionResult Create(CreateReservationDTO createDto)
{
try
{
createDto.Id = 0;
createDto.State = true;
var UserId = _httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
Reservation reservation = _reservationAppService.CreateReservation(UserId, createDto);
if (reservation != null)
{
_generalAppService.CommitTransaction();
return(Created("created", reservation.Id));
}
else
{
_generalAppService.RollbackTransaction();
return(BadRequest("no exists recesation to this day"));
}
}
catch (Exception ex)
{
_generalAppService.RollbackTransaction();
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult> Create(CreateReservationViewModel model)
{
_logger.Info("Creating Reservation! Params: " + model.ToJson());
if (!ModelState.IsValid)
{
_logger.Error("Creating Reservation Form Invalid! Errors:" + ModelState.ToJson());
return(Json(ModelState.ToDictionary()));
}
//if (await UserManager.IsPhoneNumberConfirmedAsync(User.Identity.GetUserId())
// && await UserManager.HasPhoneNumberAsync(User.Identity.GetUserId()))
//{
// return Json("Въведете и потвърдете телефонен номер тогава опитайте отново!");
//}
try
{
CreateReservationDTO reservation = Mapper.Map <CreateReservationViewModel, CreateReservationDTO>(model, o => o.Items["UserId"] = User.Identity.GetUserId());
await ReservationsManager.CreateReservation(reservation);
_logger.Info("Creating Reservation Successfully!");
return(Json("STATUS_OK"));
}
catch (Exception ex)
{
_logger.Error(ex, "Creating Reservation Failed!");
throw;
}
}
public CreateReservationDTO GetToShowInContinuePage(int id)
{
Reservation reserve = TheUnitOfWork.ReservationRepo.GetById(id);
CreateReservationDTO reservationDTO = Mapper.Map <CreateReservationDTO>(reserve);
return(reservationDTO);
}
public void updateReservation(CreateReservationDTO createDto)
{
createDto.Date = createDto.Date.Date;
Reservation reservation = Mapper.Map <Reservation>(createDto);
TheUnitOfWork.ReservationRepo.Update(reservation);
TheUnitOfWork.SaveChanges();
}
public IActionResult update(CreateReservationDTO createDto)
{
try
{
_reservationAppService.updateReservation(createDto);
_generalAppService.CommitTransaction();
return(Ok(new Response {
Message = "Updated"
}));
}
catch (Exception ex)
{
_generalAppService.RollbackTransaction();
return(BadRequest(ex.Message));
}
}
/// <summary>
/// Create Reservation only for dayly available properties
/// </summary>
/// <param name="model"></param>
public async Task CreateReservation(CreateReservationDTO model)
{
var property = await unitOfWork.PropertiesBaseRepository
.Where(r => r.Id == model.PropertyId)
.FirstOrDefaultAsync() ?? throw new ContentNotFoundException("Не е намерен имота, който искате да резервирате!");
if (!property.RentalHirePeriodType.IsTimePeriodSearchable)
{
throw new InvalidReservationException("Само имоти с дневни наемни цени могат да се резервират!");
}
if (property.RentalPrice == null)
{
throw new InvalidReservationException("Имотът, който искате да резервирате няма наемна цена !");
}
if (string.IsNullOrEmpty(model.UserId) && model.NonRegisteredUser == null)
{
throw new ArgumentException("Не е попълнен потребителя правещ резервацията!");
}
//Todal day of the reservation, floored, converted to decimal and multiplied by the rental price (ex. 7,1 days -> 7 * RentalPrice)
decimal totalReservationPrice = (decimal)property.RentalPrice * Convert.ToDecimal(Math.Floor((model.To - model.From).TotalDays));
Reservations reservation = new Reservations
{
From = model.From,
To = model.To,
AdditionalDescription = model.AdditionalDescription,
PropertyId = model.PropertyId,
ApproveStatus = ApproveStatus.Pending,
ClientUserId = model.UserId,
NonRegisteredUser = model.NonRegisteredUser == null ? null : new NonRegisteredReservationUsers
{
ClientName = model.NonRegisteredUser.ClientName,
ClientEmail = model.NonRegisteredUser.ClientEmail,
ClientPhoneNumber = model.NonRegisteredUser.ClientPhoneNumber
},
PaymentStatus = PaymentStatus.Pending,
CaparoPrice = totalReservationPrice / 10,
FullPrice = totalReservationPrice,
};
unitOfWork.ReservationsRepository.Add(reservation);
await unitOfWork.SaveAsync();
}
public Reservation CreateReservation(string userId, CreateReservationDTO createDto)
{
DayShift dayShift = TheUnitOfWork.DayShiftRepo.GetById(createDto.dayShiftId);
createDto.Date = createDto.Date.Date;
Reservation reservation = Mapper.Map <Reservation>(createDto);
reservation.IsRated = false;
reservation.userId = userId;
if (CountOfReversationInDate(createDto.dayShiftId, createDto.Date) < dayShift.MaxNumOfReservation)
{
var reseve = TheUnitOfWork.ReservationRepo.Insert(reservation);
TheUnitOfWork.SaveChanges();
return(reseve);
}
return(null);
}
public async Task <ActionResult <CreateReservationDTO> > PostReservation(CreateReservationDTO reservationDTO)
{
if (reservationDTO == null)
{
return(BadRequest(new { Message = "No reservation input" }));
}
//TODO: check if reservation with flightId and userId exists. if it does do put, else continu post.
try
{
Flight flight = await flightRepo.GetAsyncByGuid(reservationDTO.FlightId);
if (flight != null)
{
Reservation reservation = mapper.Map <Reservation>(reservationDTO);
foreach (ReservedSeat reservedSeat in reservation.ReservedSeats)
{
PriceClass price = await genericPriceRepo.GetAsyncByGuid(reservedSeat.PriceId);
if (price != null)
{
Seat seat = await genericSeatRepo.GetAsyncByGuid(reservedSeat.SeatId);
seat.Reserved = true;
await genericSeatRepo.Update(seat, seat.Id);
reservedSeat.TicketPrice = price.Value != 0 && flight.DistanceInKm != 0 ? price.Value * (flight.DistanceInKm / 1000) : 0;
reservedSeat.PersonId = reservedSeat.Person.Id;
reservation.TotalPrice += reservedSeat.TicketPrice;
reservation.TotalSeats += 1;
flight.Airplane = await airplaneRepo.GetAsyncByGuid(flight.AirplaneId.Value);
flight.Airplane.ReservedSeats += 1;
if (flight.Airplane.ReservedSeats == flight.Airplane.TotalSeats)
{
//TODO: realtime message to admin
Console.WriteLine("Airplane is fully booked.");
MessageObject message = new MessageObject()
{
Message = $"Airplane {flight.Airplane.Name} on flight with Id {flight.Id} is fully booked. Please add an extra plane."
};
await sender.Send(message);
}
}
else
{
return(RedirectToAction("HandleErrorCode", "Error", new
{
statusCode = 404,
errorMessage = $"Could not find price. "
}));
}
}
var createdReservation = await reservationRepo.Create(reservation);
if (createdReservation == null)
{
return(BadRequest(new { Message = $"Reservation could not be saved" }));
}
return(Created("/api/reservations", reservationDTO));
}
else
{
return(RedirectToAction("HandleErrorCode", "Error", new
{
statusCode = 404,
errorMessage = $"Could not find flight. "
}));
}
}
catch (Exception ex)
{
return(RedirectToAction("HandleErrorCode", "Error", new
{
statusCode = 400,
errorMessage = $"Creating reservation failed {ex}"
}));
}
}
