public void MakeReservation_Reservation_Not_Created_Return_BadRequest()
{
//Arrange
int expectedStatusCode = 400;
CreateReservationModel createReservationModel = new CreateReservationModel
{
UserId = Guid.NewGuid(),
ProjectionId = Guid.NewGuid(),
SeatIds = new List <SeatDomainModel>()
};
ReservationResultModel reservationResultModel = new ReservationResultModel
{
ErrorMessage = null,
IsSuccessful = false
};
_reservationService = new Mock <IReservationService>();
_reservationService.Setup(x => x
.CreateReservation(It.IsAny <CreateReservationModel>())).Returns(reservationResultModel);
ReservationsController reservationsController = new ReservationsController(_reservationService.Object);
//Act
var result = reservationsController.MakeReservation(createReservationModel).Result;
var createdResult = ((BadRequestObjectResult)result).Value;
var reservationResultDomainModel = (ErrorResponseModel)createdResult;
//Assert
Assert.IsNotNull(createdResult);
Assert.IsInstanceOfType(result, typeof(BadRequestObjectResult));
Assert.AreEqual(expectedStatusCode, ((BadRequestObjectResult)result).StatusCode);
}
public void CreateNormalReservation(CreateReservationModel model, int memberID)
{
if (model.PotentialReservations.Count > 4)
{
throw new Exception("Members should not be more than 4");
}
var teeTimeRepo = new TeeTimeRepository(new BAISTGolfCourseDbContext());
var teeTime = teeTimeRepo.GetWithReservationsById(model.TeeTimeID);
foreach (var member in model.PotentialReservations)
{
var reservation = new Reservations
{
DateCreated = DateTime.Now,
TeeTimeID = model.TeeTimeID,
MemberID = member.MemberID,
Status = member.Status,
IsApproved = false,
Type = Enums.ReservationType.Normal
};
teeTime.Reservations.Add(reservation);
}
var reservationCount = teeTime.Reservations.Count;
if (reservationCount == 4)
{
teeTime.Status = Enums.TeeTimeStatus.Closed;
}
teeTimeRepo.SaveChanges();
}
public ActionResult <ReservationResultModel> MakeReservation([FromBody] CreateReservationModel model)
{
ReservationResultModel res;
try
{
res = _reservationService.CreateReservation(model);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (!res.IsSuccessful)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = res.ErrorMessage,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
return(Created("reservations//" + res.Reservation.Id, res));
}
public void AddCurrentUserToReservation(CreateReservationModel model, int memberID)
{
model.PotentialReservations.Add(new ReservationCreateModel
{
MemberID = memberID, Status = ReservationStatus.Accepted
});
}
public void CreateStandingReservation(CreateReservationModel model, int memberID)
{
var teeTimeRepo = new TeeTimeRepository(new BAISTGolfCourseDbContext());
var teeTime = teeTimeRepo.GetWithReservationsById(model.TeeTimeID);
foreach (var member in model.PotentialReservations)
{
var reservation = new Reservations
{
DateCreated = DateTime.Now,
TeeTimeID = model.TeeTimeID,
MemberID = member.MemberID,
Status = member.Status,
IsApproved = false,
Type = Enums.ReservationType.Standing
};
teeTime.Reservations.Add(reservation);
}
teeTime.Status = Enums.TeeTimeStatus.Closed;
teeTimeRepo.SaveChanges();
}
public async Task <ActionResult <ReservationModel> > PostClientReservation(CreateReservationModel newReservation)
{
var reservation = await _reservationService.CreateClientReservation(newReservation);
var mappedReservation = _mapper.Map <ReservationModel>(reservation);
return(Ok(mappedReservation));
}
public async Task <IActionResult> Create(CreateReservationModel reservation)
{
var dbObject = await _reservationService.Create(_mapper.Map <CreateReservationModel, Reservation>(reservation));
if (dbObject == null)
{
return(BadRequest());
}
return(Created("Created", _mapper.Map <Reservation, SuccessfulReservationModel>(dbObject)));
}
public IActionResult Create(CreateReservationModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = HttpContext.GetUserId();
var result = _reservationService.Create(userId, model.SessionId);
return(Ok(result));
}
public ReservationModel MakeReservation(int projectionId, CreateReservationModel model)
{
return(this.ExecuteOperationHandleExceptions(() =>
{
this.ValidateEmail(model.Email);
var context = new CinemaReserveDbContext();
var theProjection = context.Projections.FirstOrDefault(pr => pr.Id == projectionId);
if (theProjection == null)
{
throw new ArgumentNullException("projection is either non-existant or is not available");
}
var reservedSeatStatus = context.SeatStatus.FirstOrDefault(st => st.Status == "reserved") ?? new SeatStatus()
{
Status = "reserved"
};
List <Seat> reservedSeats = new List <Seat>();
using (TransactionScope tran = new TransactionScope())
{
foreach (var seat in model.Seats)
{
var dbSeat = theProjection.Seats.FirstOrDefault(s => s.Row == seat.Row && s.Column == seat.Column);
if (dbSeat == null || dbSeat.Status.Status == "reserved")
{
throw new InvalidOperationException("Seat is not available");
}
dbSeat.Status = reservedSeatStatus;
reservedSeats.Add(dbSeat);
}
tran.Complete();
}
var reservation = new Reservation()
{
ReservedSeats = reservedSeats,
UserEmail = model.Email.ToLower(),
UserCode = this.GenerateUserCode()
};
//context.Reservations.Add(reservation);
theProjection.Reservations.Add(reservation);
context.SaveChanges();
var reservationModel = Parser.ToReservationModel(reservation);
return reservationModel;
}));
}
internal static string ReserveCall(object seats, string email, int projectionID)
{
ValidateEmail(email);
var seatsCast = seats as IEnumerable <SeatModel>;
CreateReservationModel model = new CreateReservationModel()
{
Seats = seatsCast,
Email = email,
};
ReservationModel code = HttpRequester.Post <ReservationModel>(BaseServicesUrl + "projections/" + projectionID, model);
return(code.UserCode);
}
public void ReservationService_CreateReservation_ReturnsErrorMessage_ProjectionNotExist()
{
//Arrange
List <SeatResultModel> seatResultList = new List <SeatResultModel>();
List <Seat> seats = new List <Seat>();
Seat s1 = new Seat
{
Id = Guid.NewGuid(),
AuditoriumId = 1,
Number = 1,
Row = 1
};
Seat s2 = new Seat
{
Id = Guid.NewGuid(),
AuditoriumId = 1,
Number = 2,
Row = 1
};
seats.Add(s1);
seats.Add(s2);
CreateReservationModel reservation = new CreateReservationModel()
{
ProjectionId = Guid.NewGuid(),
UserId = Guid.NewGuid(),
SeatIds = seats.Select(s => new SeatDomainModel
{
Id = s.Id,
AuditoriumId = s.AuditoriumId,
Number = s.Number,
Row = s.Row
})
};
_mockReservationService.Setup(x => x.GetTakenSeats(It.IsAny <Guid>())).Returns(seatResultList);
_mockSeatRepository.Setup(x => x.GetAll()).ReturnsAsync(seats);
_mockProjectionRepository.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(null as Projection);
//Act
var resultAction = _reservationService.CreateReservation(reservation);
//Assert
Assert.IsNotNull(resultAction);
Assert.IsFalse(resultAction.IsSuccessful);
Assert.AreEqual(Messages.PROJECTION_DOES_NOT_EXIST, resultAction.ErrorMessage);
Assert.IsInstanceOfType(resultAction, typeof(ReservationResultModel));
}
public ActionResult Create(int id, int numberOfPersons, DateTime date)
{
var rest = _reservationService.GetRestaurant(id);
var createModel = new CreateReservationModel();
createModel.TimeSlot = date;
createModel.RestaurantId = rest.Id;
createModel.RestaurantName = rest.Name;
createModel.Email = "";
createModel.AvailableTimes = _reservationService.GetAvailableTimes(rest.Id, numberOfPersons, date);
createModel.TimeSelectList = new SelectList(createModel.AvailableTimes.Where(x => x.FreeSeats), "Hour", "Hour");
createModel.PersonCount = numberOfPersons;
createModel.Date = date;
createModel.Name = "";
return(View(createModel));
}
public ActionResult Create(CreateReservationModel inputModel)
{
if (ModelState.IsValid)
{
var member = _memberService.GetMemberByEmail(User.Identity.Name);
_reservationService.CreateNormalReservation(inputModel, member.ID);
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "unable to save cha. Try again, if the problem persists email system administrator");
}
return(View(inputModel));
}
public void MakeReservation_Throw_DbUpdateException()
{
//Arrange
int expectedStatusCode = 400;
string expectedMessage = "Inner exception error message.";
CreateReservationModel createReservationModel = new CreateReservationModel
{
UserId = Guid.NewGuid(),
ProjectionId = Guid.NewGuid(),
SeatIds = new List <SeatDomainModel>()
};
ReservationResultModel reservationResultModel = new ReservationResultModel
{
Reservation = new ReservationDomainModel
{
Id = Guid.NewGuid(),
ProjectionId = Guid.NewGuid(),
UserId = createReservationModel.UserId
},
ErrorMessage = null,
IsSuccessful = true
};
Exception exception = new Exception("Inner exception error message.");
DbUpdateException dbUpdateException = new DbUpdateException("Error.", exception);
_reservationService = new Mock <IReservationService>();
_reservationService.Setup(x => x
.CreateReservation(It.IsAny <CreateReservationModel>())).Throws(dbUpdateException);
ReservationsController reservationsController = new ReservationsController(_reservationService.Object);
//Act
var result = reservationsController.MakeReservation(createReservationModel).Result;
var badRequestResultValue = ((BadRequestObjectResult)result).Value;
var errorResponse = (ErrorResponseModel)badRequestResultValue;
//Assert
Assert.IsNotNull(badRequestResultValue);
Assert.AreEqual(expectedMessage, errorResponse.ErrorMessage);
Assert.IsInstanceOfType(result, typeof(BadRequestObjectResult));
Assert.AreEqual(expectedStatusCode, ((BadRequestObjectResult)result).StatusCode);
}
public void TestInitialize()
{
_reservationDomainModel = new ReservationDomainModel
{
ProjectionId = Guid.NewGuid(),
SeatId = Guid.NewGuid(),
UserId = Guid.NewGuid()
};
_reservationResultModel = new CreateReservationResultModel
{
ErrorMessage = null,
IsSuccessful = true,
Reservation = _reservationDomainModel
};
_failedReservationResultModel = new CreateReservationResultModel
{
ErrorMessage = "Error",
IsSuccessful = false,
Reservation = null
};
_createReservationModel = new CreateReservationModel
{
ProjectionId = _reservationDomainModel.ProjectionId,
SeatIds = new List <Guid>
{
_reservationDomainModel.SeatId
},
UserId = _reservationDomainModel.UserId
};
List <ReservationDomainModel> reservationList = new List <ReservationDomainModel>();
reservationList.Add(_reservationDomainModel);
IEnumerable <ReservationDomainModel> reservations = reservationList;
Task <IEnumerable <ReservationDomainModel> > responseTask = Task.FromResult(reservations);
_mockReservationService = new Mock <IReservationService>();
_mockUserService = new Mock <IUserService>();
_mockProjectionService = new Mock <IProjectionService>();
}
public void MakeReservation_ReservationCreatedSuccesful_ReturnCreated()
{
//Arrange
int expectedStatusCode = 201;
CreateReservationModel createReservationModel = new CreateReservationModel
{
UserId = Guid.NewGuid(),
ProjectionId = Guid.NewGuid(),
SeatIds = new List <SeatDomainModel>()
};
ReservationResultModel reservationResultModel = new ReservationResultModel
{
Reservation = new ReservationDomainModel
{
Id = Guid.NewGuid(),
ProjectionId = Guid.NewGuid(),
UserId = createReservationModel.UserId
},
ErrorMessage = null,
IsSuccessful = true
};
_reservationService = new Mock <IReservationService>();
_reservationService.Setup(x => x
.CreateReservation(It.IsAny <CreateReservationModel>())).Returns(reservationResultModel);
ReservationsController reservationsController = new ReservationsController(_reservationService.Object);
//Act
var result = reservationsController.MakeReservation(createReservationModel).Result;
var createdResult = ((CreatedResult)result).Value;
var reservationResultDomainModel = (ReservationResultModel)createdResult;
//Assert
Assert.IsNotNull(createdResult);
Assert.AreEqual(createReservationModel.UserId, reservationResultDomainModel.Reservation.UserId);
Assert.IsInstanceOfType(result, typeof(CreatedResult));
Assert.AreEqual(expectedStatusCode, ((CreatedResult)result).StatusCode);
}
public ActionResult Create(CreateReservationModel model)
{
if (ModelState.IsValid)
{
Reservation r = new Reservation();
r.Name = model.Name;
r.Email = model.Email;
r.Telephone = model.Telephone;
r.PersonCount = model.PersonCount;
r.Restaurant = _reservationService.GetRestaurant(model.RestaurantId);
r.TimeSlot = model.Date.AddHours(model.Time);
int reservationId = _reservationService.SaveReservation(r).Id;
return(RedirectToAction("Details", "Reservation", new { id = reservationId }));
}
return(View(model));
}
public async Task <Reservation> CreateClientReservation(CreateReservationModel newReservation)
{
var userId = _httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier);
var reservation = new Reservation()
{
UserId = int.Parse(userId),
CarId = newReservation.CarId,
StartDate = newReservation.StartDate,
EndDate = newReservation.EndDate
};
if (!await IsReservationIntervalValid(reservation))
{
throw new InvalidInputException("Date interval is not valid!");
}
_reservationRepository.Add(reservation);
await _reservationRepository.SaveAll();
return(reservation);
}
public async Task <Data.Entities.Reservation> AddReservationAsync(CreateReservationModel reservationModel)
{
var reservation = _mapper.Map <Data.Entities.Reservation>(reservationModel);
return(await AddAsync(reservation));
}
public virtual async Task <IEnumerable <ReservationItem> > CreateOneReservation(CreateReservationModel item)
{
return(await _reservationService.CreateAsync(item));
}
public void ReservationService_CreateReservation_ReturnsErrorMessage_SeatNotExist()
{
//Arrange
List <SeatDomainModel> seatDomainModels = new List <SeatDomainModel>();
SeatDomainModel seat1 = new SeatDomainModel
{
Id = Guid.NewGuid(),
AuditoriumId = 1,
Number = 2,
Row = 1
};
SeatDomainModel seat2 = new SeatDomainModel
{
Id = Guid.NewGuid(),
AuditoriumId = 1,
Number = 3,
Row = 1
};
seatDomainModels.Add(seat1);
seatDomainModels.Add(seat2);
List <SeatResultModel> seatsTaken = new List <SeatResultModel>();
Seat s1 = new Seat
{
Id = Guid.NewGuid(),
AuditoriumId = 1,
Number = 4,
Row = 1
};
Seat s2 = new Seat
{
Id = Guid.NewGuid(),
AuditoriumId = 1,
Number = 5,
Row = 1
};
List <Seat> seats = new List <Seat>();
seats.Add(s1);
seats.Add(s2);
CreateReservationModel createReservationModel = new CreateReservationModel()
{
ProjectionId = Guid.NewGuid(),
UserId = Guid.NewGuid(),
SeatIds = new List <SeatDomainModel>()
};
Projection projection = new Projection
{
Id = createReservationModel.ProjectionId,
AuditoriumId = 1,
MovieId = Guid.NewGuid(),
DateTime = DateTime.Now.AddDays(1)
};
createReservationModel.SeatIds = seatDomainModels;
_mockReservationService.Setup(x => x.GetTakenSeats(createReservationModel.ProjectionId)).Returns(seatsTaken);
_mockSeatRepository.Setup(x => x.GetAll()).ReturnsAsync(seats);
_mockProjectionRepository.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(projection);
//Act
var resultAction = _reservationService.CreateReservation(createReservationModel);
//Assert
Assert.IsNotNull(resultAction);
Assert.AreEqual(Messages.SEAT_SEATS_NOT_EXIST_FOR_AUDITORIUM, resultAction.ErrorMessage);
Assert.IsNull(resultAction.Reservation);
Assert.IsFalse(resultAction.IsSuccessful);
Assert.IsInstanceOfType(resultAction, typeof(ReservationResultModel));
}
public void ReservationService_CreateReservation_ReturnsCreatedReservation()
{
//Arrange
Projection projection = new Projection
{
Id = Guid.NewGuid(),
AuditoriumId = 1,
DateTime = DateTime.Now.AddHours(5),
MovieId = Guid.NewGuid()
};
SeatResultModel srm1 = new SeatResultModel
{
ErrorMessage = null,
IsSuccessful = true,
SeatDomainModel = new SeatDomainModel
{
Id = Guid.NewGuid(),
AuditoriumId = 1,
Number = 1,
Row = 1
}
};
SeatResultModel srm2 = new SeatResultModel
{
ErrorMessage = null,
IsSuccessful = true,
SeatDomainModel = new SeatDomainModel
{
Id = Guid.NewGuid(),
AuditoriumId = 1,
Number = 2,
Row = 1
}
};
List <SeatResultModel> seatResults = new List <SeatResultModel>();
Seat s1 = new Seat
{
Id = srm1.SeatDomainModel.Id,
AuditoriumId = srm1.SeatDomainModel.AuditoriumId,
Number = srm1.SeatDomainModel.Number,
Row = srm1.SeatDomainModel.Row
};
Seat s2 = new Seat
{
Id = srm2.SeatDomainModel.Id,
AuditoriumId = srm2.SeatDomainModel.AuditoriumId,
Number = srm2.SeatDomainModel.Number,
Row = srm2.SeatDomainModel.Row
};
List <Seat> seats = new List <Seat>();
seats.Add(s1);
seats.Add(s2);
CreateReservationModel reservation = new CreateReservationModel
{
ProjectionId = projection.Id,
UserId = Guid.NewGuid(),
SeatIds = seats.Select(s => new SeatDomainModel
{
Id = s.Id,
AuditoriumId = s.AuditoriumId,
Number = s.Number,
Row = s.Row
})
};
//TO BE CONTINUED.
Reservation reservation2 = new Reservation
{
Id = Guid.NewGuid(),
ProjectionId = reservation.ProjectionId,
UserId = reservation.UserId,
ReservationSeats = new List <ReservationSeat>()
};
ReservationSeat rs1 = new ReservationSeat
{
SeatId = s1.Id,
Seat = s1,
ReservationId = Guid.NewGuid(),
Reservation = reservation2
};
reservation2.ReservationSeats.Add(rs1);
_mockReservationService.Setup(x => x.GetTakenSeats(It.IsAny <Guid>())).Returns(seatResults);
_mockSeatRepository.Setup(x => x.GetAll()).ReturnsAsync(seats);
_mockProjectionRepository.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(projection);
_mockSeatRepository.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(s1);
_mockReservationRepository.Setup(x => x.Insert(It.IsAny <Reservation>())).Returns(reservation2);
//Assert
var resultAction = _reservationService.CreateReservation(reservation);
//Act
Assert.IsNotNull(resultAction);
}
public async Task <ActionResult <ReservationDomainModel> > PostAsync([FromBody] CreateReservationModel reservationModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//PaymentResponse
List <ReservationDomainModel> reservationResultList = new List <ReservationDomainModel>();
int bonusPointsToAdd = 0;
foreach (Guid seatId in reservationModel.SeatIds)
{
bonusPointsToAdd++;
ReservationDomainModel domainModel = new ReservationDomainModel
{
ProjectionId = reservationModel.ProjectionId,
SeatId = seatId,
UserId = reservationModel.UserId
};
CreateReservationResultModel createReservationResultModel;
try
{
createReservationResultModel = await _reservationService.AddReservation(domainModel);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (!createReservationResultModel.IsSuccessful)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = createReservationResultModel.ErrorMessage,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
reservationResultList.Add(createReservationResultModel.Reservation);
}
try
{
var bonusPointsResult = _userService.AddBonusPointsByUserId(reservationModel.UserId, bonusPointsToAdd);
if (bonusPointsResult == -1 || bonusPointsToAdd < 0)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.USER_BONUSPOINTS_ERROR,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.USER_BONUSPOINTS_ERROR,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
return(Created("reservations//", reservationResultList));
}
public ReservationResultModel CreateReservation(CreateReservationModel reservation)
{
//get all taken seats for projection
var takenSeats = GetTakenSeats(reservation.ProjectionId);
var seats = _seatRepository.GetAll().Result;
var projection = _projectionRepository.GetByIdAsync(reservation.ProjectionId).Result;
if(projection == null)
{
return new ReservationResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.PROJECTION_DOES_NOT_EXIST
};
}
//get all seats for auditorium
seats = seats.Where(auditorium => auditorium.AuditoriumId == projection.AuditoriumId);
//check if the requested seats exist in the auditorium
var commonSeats = seats.Select(x => x.Id).Intersect(reservation.SeatIds.Select(s => s.Id));
if(commonSeats.Count() != reservation.SeatIds.Count())
{
return new ReservationResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.SEAT_SEATS_NOT_EXIST_FOR_AUDITORIUM
};
}
//check if requested seats are more than 1 and in the same row
List<SeatDomainModel> seatModels = new List<SeatDomainModel>();
foreach (var seat in reservation.SeatIds)
{
var reqSeat = _seatRepository.GetByIdAsync(seat.Id).Result;
SeatDomainModel seatDomain = new SeatDomainModel()
{
Id = reqSeat.Id,
Number = reqSeat.Number,
Row = reqSeat.Row,
AuditoriumId = reqSeat.AuditoriumId
};
seatModels.Add(seatDomain);
}
//check if seats are duplicates
var row = seatModels[0].Number;
var differentRow = seatModels.Select(x => x.Number).Distinct();
if(differentRow.Count() < seatModels.Count)
{
return new ReservationResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.SEAT_SEATS_CANNOT_BE_DUPLICATES
};
}
if (reservation.SeatIds.ToList().Count() > 1)
{
var singleSeat = seatModels[0];
foreach (var x in seatModels)
{
if(singleSeat.Row != x.Row)
{
return new ReservationResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.SEAT_SEATS_NOT_IN_SAME_ROW
};
}
}
}
//check if seats are not next to each other
if(reservation.SeatIds.Count() > 1)
{
seatModels = seatModels.OrderByDescending(x => x.Number).ToList();
var singleSeat2 = seatModels[0];
var counter = 1;
foreach (var y in seatModels.Skip(1))
{
if (y.Number + counter != singleSeat2.Number)
{
return new ReservationResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.SEAT_SEATS_MUST_BE_NEXT_TO_EACH_OTHER
};
}
else
{
counter++;
}
}
}
//check if requested seats are already taken
if(takenSeats != null)
{
foreach (var takenSeat in takenSeats)
{
foreach (var requestedSeat in reservation.SeatIds)
{
if (takenSeat.SeatDomainModel.Id == requestedSeat.Id)
{
return new ReservationResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.SEAT_SEATS_ALREADY_TAKEN_ERROR
};
}
}
}
}
#region Komentar
/* var auditorium = _auditoriumRepository.GetByIdAsync(projection.AuditoriumId).Result;
List<(int, int)> requestedSeatsRowsAndNumbers =
reservation.SeatsRequested
.Select(s =>
{
var seat = _seatRepository.GetByIdAsync(s.Id).Result;
return (seat.Row, seat.Number);
}).ToList();
int rowMax = auditorium.Seats.Max(s => s.Row);
int numberMax = auditorium.Seats.Max(s => s.Number);
List<(int row, int number)> listOfAllSeats = new List<(int, int)>();
for (int i = 1; i <= rowMax; i++)
{
for (int j = 1; j <= numberMax; j++)
{
listOfAllSeats.Add((i, j));
}
}
List<(int row, int number)> listTakenSeats = takenSeats
.Select(s => (s.SeatDomainModel.Row, s.SeatDomainModel.Number))
.ToList();
List<(int row, int number)> listFreeSeats = listOfAllSeats
.Except(listTakenSeats)
.ToList();
*/
//CHECK IF listFreeSeats CONTAINS AT LEAST 1 REQUESTED
//ROW WHICH HAS EQUAL OR MORE FREE CONTINIOUS SEATS
//COMPARED TO NUMBER OF REQUESTED SEATS. IF SO, THROW ERROR
//BECAUSE CLIENT COULD RESERVE ALL SEATS IN THE SAME ROW.
// IF NOT, ALLOW CLIENT SEPARATE RESERVATIONS.
//LASTLY, CHECK IF SEATS ARE NEXT TO EACH OTHER.
//IF THEY ARE, PROCEED. IF NOT, CHECK IF ROW
// CONTAINS ENOUGH CONTINIOUS SEATS. IF IT DOES,
// THROW ERROR BECAUSE CLIENT COULD RESERVE PROPERLY.
// IF NOT, ALLOW SEPARATE RESERVATIONS IN SAME ROW.
#endregion
//improvised fake payment system
#region Payment
/* Levi9PaymentService payment = new Levi9PaymentService();
var paymentResult = payment.MakePayment().Result;
if(paymentResult.IsSuccess == false)
{
return new ReservationResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.PAYMENT_CREATION_ERROR
};
}*/
//end of payment system
#endregion
//create reservation for inserting
Reservation reservationToAdd = new Reservation
{
Id = Guid.NewGuid(),
ProjectionId = reservation.ProjectionId,
UserId = reservation.UserId
};
int countOfSeats = reservation.SeatIds.Count();
var numOfPoints = countOfSeats * 1;
_userRepository.AddPointsForUser(reservation.UserId, numOfPoints);
var insertedReservation = _reservationsRepository.Insert(reservationToAdd);
foreach(var rs in reservation.SeatIds)
{
reservationToAdd.ReservationSeats.Add(new ReservationSeat
{
SeatId = rs.Id,
ReservationId = insertedReservation.Id
});
}
_reservationsRepository.Save();
return new ReservationResultModel
{
IsSuccessful = true,
Reservation = new ReservationDomainModel
{
Id = insertedReservation.Id,
ProjectionId = insertedReservation.ProjectionId,
UserId = insertedReservation.UserId
}
};
}
public void ReservationService_CreateReservation_ReturnsErrorMessage_SeatNotInTheSameRow()
{
//Arrange
List <SeatDomainModel> seatsRequested = new List <SeatDomainModel>();
SeatDomainModel seat1 = new SeatDomainModel
{
Id = Guid.NewGuid(),
AuditoriumId = 1,
Number = 2,
Row = 1
};
SeatDomainModel seat2 = new SeatDomainModel
{
Id = Guid.NewGuid(),
AuditoriumId = 1,
Number = 3,
Row = 1
};
SeatDomainModel seat3 = new SeatDomainModel
{
Id = Guid.NewGuid(),
AuditoriumId = 1,
Number = 2,
Row = 2
};
seatsRequested.Add(seat1);
seatsRequested.Add(seat2);
seatsRequested.Add(seat3);
List <SeatResultModel> seatsTaken = new List <SeatResultModel>();
Seat s1 = new Seat
{
Id = seat1.Id,
AuditoriumId = seat1.AuditoriumId,
Number = seat1.Number,
Row = seat1.Row
};
Seat s2 = new Seat
{
Id = seat2.Id,
AuditoriumId = seat2.AuditoriumId,
Number = seat2.Number,
Row = seat2.Row
};
Seat s3 = new Seat
{
Id = seat3.Id,
AuditoriumId = seat3.AuditoriumId,
Number = seat3.Number,
Row = seat3.Row
};
List <Seat> seatsInAuditorium = new List <Seat>();
seatsInAuditorium.Add(s1);
seatsInAuditorium.Add(s2);
seatsInAuditorium.Add(s3);
CreateReservationModel createReservationModel = new CreateReservationModel()
{
ProjectionId = Guid.NewGuid(),
UserId = Guid.NewGuid(),
SeatIds = new List <SeatDomainModel>()
};
Projection projection = new Projection
{
Id = createReservationModel.ProjectionId,
AuditoriumId = 1,
MovieId = Guid.NewGuid(),
DateTime = DateTime.Now.AddDays(1)
};
createReservationModel.SeatIds = seatsRequested;
_mockReservationService.Setup(x => x.GetTakenSeats(createReservationModel.ProjectionId)).Returns(seatsTaken);
_mockSeatRepository.Setup(x => x.GetAll()).ReturnsAsync(seatsInAuditorium);
_mockProjectionRepository.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(projection);
_mockSeatRepository.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(s1);
//Act
var resultAction = _reservationService.CreateReservation(createReservationModel);
//Assert
Assert.IsNotNull(resultAction);
Assert.AreEqual(Messages.SEAT_SEATS_CANNOT_BE_DUPLICATES, resultAction.ErrorMessage);
Assert.IsFalse(resultAction.IsSuccessful);
Assert.IsNull(resultAction.Reservation);
Assert.IsInstanceOfType(resultAction, typeof(ReservationResultModel));
}
public async Task <IEnumerable <ReservationItem> > CreateAsync(CreateReservationModel item)
{
var reservation = _mapper.Map <ReservationItem>(item);
return(await _reservationDataService.CreateAsync(reservation));
}
public async Task <ReservationModel> Post([FromBody] CreateReservationModel reservationModel)
{
return(_mapper.Map <ReservationModel>(await _reservationService.AddReservationAsync(reservationModel)));
}
