/// <summary>
/// 添加预约表单及预约表单字段
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public bool AddReservation(string name, List<ReservationContentEntity> viewFormRows)
{
var viewEntity = new ReservationEntity() { Name = name };
try
{
using (TransactionScope transactionScope = new TransactionScope())
{
//添加预约表单
var dataEntity = viewEntity.GetDataEntity(viewEntity);
int id = new ReservationDll().AddReservation(dataEntity);
if (id > 0)
{
//添加预约表单字段
viewFormRows.ForEach(p => p.ReservationID = id);
List<ReservationContent> dataFormRow = viewFormRows.Select(p => p.GetDataEntity(p)).ToList();
if (new ReservationContentDll().AddReservationContent(dataFormRow))
{
//如果添加预约表单及预约表单字段全部成功，提交事务
transactionScope.Complete();
return true;
}
}
}
}
catch { }
return false;
}
public ReservationEntity Create(ReservationEntity reservationEntity)
{
_context.Reservations.Add(reservationEntity);
_context.SaveChanges();
return(reservationEntity);
}
/// <summary>
/// Check is the Flight is still available , the constrains are :
/// - There is a maximum of 50 bags per flight in total for all the passengers.
/// - Each passenger can have a maximum of 5 bags per flight.
/// - There are 50 seats available per flight, numbered sequentially: “01”, “02”… “50”.
/// - Apart from this, I am checking if there are more than 50 bookings in a flight, in case the seats are duplicated.
/// </summary>
/// <returns></returns>
private bool IsValidReservation(ReservationEntity reservationToValidate)
{
var flightKeys = reservationToValidate.ReservationDetails.Select(m => m.FlightKey).Distinct();
foreach (var flightKey in flightKeys)
{
if (!IsValidFlight(flightKey))
{
return(false);
}
// Calculate the number of bags in the current Reservation by every Flight
// Calculate the number of bags in the previous Reservations by every Flight
// Check the Total of number of bags are not more than the limit
// TODO: Check if the seats are duplicated.
int BagsLimitByFlight = int.Parse(_configuration["Settings:Reservation:BagsLimitByFlight"]);
int SeatsLimitByFlight = int.Parse(_configuration["Settings:Reservation:SeatsLimitByFlight"]);
int TicketsLimitByFlight = int.Parse(_configuration["Settings:Reservation:TicketsLimitByFlight"]);
getFlightDetails(flightKey, out int TotalBagsCurrentReservation, out int MaxSeatCurrentReservation, out int MaxTicketsCurrentReservation, reservationToValidate.ReservationDetails);
getFlightDetails(flightKey, out int TotalBagsByFlight, out int MaxSeatByFlight, out int MaxTicketsByFlight, null);
if (((TotalBagsCurrentReservation + TotalBagsByFlight) > BagsLimitByFlight) ||
(Math.Max(MaxSeatCurrentReservation, MaxSeatByFlight) > SeatsLimitByFlight) ||
(Math.Max(MaxTicketsCurrentReservation, MaxTicketsByFlight) > TicketsLimitByFlight))
{
return(false);
}
}
return(true);
}
public HttpResponseMessage AddReservation(JObject jsonData)
{
var reservation = new ReservationEntity();
HttpResponseMessage response;
try
{
dynamic jsonObj = jsonData;
reservation.WhiteLabel_ID = jsonObj.WhiteLabel_ID.Value;
reservation.Type = jsonObj.Type.Value;
reservation.Status = jsonObj.Status.Value;
reservation.Full_Name = jsonObj.Full_Name.Value;
reservation.Phone_Number = jsonObj.Phone_Number.Value;
reservation.Age = jsonObj.Age.Value;
reservation.Id_Number = jsonObj.Id_Number.Value;
reservation.AdditionalProperties = _reservationService.ConvertJsonAdditionalProperties(jsonObj);
Hub.Clients.Group(reservation.WhiteLabel_ID.ToString()).addReservation(reservation);
Hub.Clients.Group("0").addReservation(reservation);
// Hub.Clients.All.addReservation(reservation);
_reservationService.AddReservation(reservation);
response = Request.CreateResponse(HttpStatusCode.OK);
}
catch (Exception ex)
{
response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, "GetTYPAccountInfo Error");
}
return(response);
}
public long UpdateReservation(Reservation reservation)
{
IMapper mapper = _reservationConfig2.CreateMapper();
ReservationEntity reservationEntity = mapper.Map <Reservation, ReservationEntity>(reservation);
dbCtx.ReservationEntity.Update(reservationEntity);
dbCtx.SaveChanges();
return(reservationEntity.IdReservation);
}
public void CreateReservation_Creates_Reservation()
{
var entity = new ReservationEntity();
var dto = new ReservationDto();
mockMapper.Setup(m => m.Map <ReservationEntity>(dto)).Returns(entity);
reservationService.CreateReservation(dto);
mockRepo.Verify(r => r.Insert(entity), Times.Once);
}
public ReservationsOutput(ReservationEntity reservation)
{
Id = reservation.Id;
User = new UserOutput(reservation.User);
Room = new RoomOutput(reservation.Room);
ReservedFrom = reservation.ReservedFrom;
ReservedTo = reservation.ReservedTo;
Cost = reservation.Cost;
Services = reservation.Services.Select(s => new ServiceOutput(s));
}
public Reservation ReadReservationById(long idReservation)
{
ReservationEntity reservationEntity = new ReservationEntity();
reservationEntity = dbCtx.ReservationEntity.Where(r => r.IdReservation == idReservation).FirstOrDefault();
IMapper mapper = _reservationConfig.CreateMapper();
return(mapper.Map <ReservationEntity, Reservation>(reservationEntity));
}
public void CreateReservation_Returns_ReservationDto()
{
var entity = new ReservationEntity();
var dto = new ReservationDto();
mockRepo.Setup(r => r.Insert(It.IsAny <ReservationEntity>())).Returns(entity);
mockMapper.Setup(m => m.Map <ReservationDto>(entity)).Returns(dto);
var actual = reservationService.CreateReservation(dto);
Assert.AreEqual(dto, actual);
}
public async Task ReserveBook(Guid bookId, string userName)
{
var reservation = new ReservationEntity
{
ReservationDate = DateTime.Now,
BookId = bookId,
User = await _userRepository.GetUserEntity(userName)
};
await _reservationRepository.Add(reservation);
}
public void UpdateReservation_Calls_Update_In_Repo()
{
var entity = new ReservationEntity();
var dto = new ReservationDto {
Id = Guid.NewGuid()
};
mockRepo.Setup(r => r.Get(It.IsAny <Guid>())).Returns(entity);
reservationService.UpdateReservation(dto);
mockRepo.Verify(r => r.Update(It.IsAny <ReservationEntity>()), Times.Once);
}
public void GetById_Returns_Collection_ReservationDtos()
{
var modelId = Guid.NewGuid();
var entity = new ReservationEntity();
var dto = new ReservationDto();
mockRepo.Setup(r => r.Get(It.IsAny <Guid>())).Returns(entity);
mockMapper.Setup(m => m.Map <ReservationDto>(entity)).Returns(dto);
var actual = reservationService.GetById(modelId);
Assert.AreEqual(dto, actual);
}
public ReservationEntity UpdateReservation(ReservationEntity reservation)
{
var currentReservation = carParkContext.Reservations.SingleOrDefault(x => x.Id == reservation.Id);
if (currentReservation == null)
{
currentReservation = AddReservation(reservation);
}
currentReservation.FromDate = reservation.FromDate;
currentReservation.ToDate = reservation.ToDate;
carParkContext.SaveChanges();
return(currentReservation);
}
public Reservation Map(ReservationEntity reservation)
{
return(new Reservation
{
Id = reservation.Id,
ReservationDate = reservation.ReservationDate,
User = new User
{
Id = reservation.User?.Id,
Name = reservation.User?.UserName
}
});
}
public void UpdateReservation_Updates_Reservation()
{
var entity = new ReservationEntity();
var dto = new ReservationDto {
Id = Guid.NewGuid()
};
mockRepo.Setup(r => r.Get(It.IsAny <Guid>())).Returns(entity);
reservationService.UpdateReservation(dto);
mockRepo.Verify(r => r.Update(
It.Is <ReservationEntity>(r =>
r.HasBeenCheckedOut == false)),
Times.Once);
}
public async Task AddReservationAsync(ReservationDto reservation)
{
var tour = this.unitOfWork.TourRepository.FindById(reservation.TourId);
if (tour == null)
{
throw new ServiceException($"No tour with id {reservation.TourId}");
}
ReservationEntity reservationEntity = BaseMapper <ReservationDto, ReservationEntity> .Map(reservation);
reservationEntity.Tour = tour;
reservationEntity.ReservationPrice = tour.Price * reservationEntity.PeopleCount;
await this.unitOfWork.ReservationRepository.AddAsync(reservationEntity);
await this.unitOfWork.CommitAsync();
}
public HttpResponseMessage GetReservationById(JObject jsonData)
{
HttpResponseMessage response;
try
{
dynamic jsonObj = jsonData;
ReservationEntity reservation = _reservationService.GetReservationById(jsonObj.reservationId.Value);
response = Request.CreateResponse(HttpStatusCode.OK, reservation);
}
catch (Exception ex)
{
response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, "GetReservationsListByWhiteLabelId Add Error");
}
return(response);
}
public void AddReservation(ReservationEntity reservation)
{
try
{
_ctx.Reservations.InsertOneAsync(reservation);
}
catch (Exception ex)
{
}
//ReservationEntity r1 = new ReservationEntity { };
//ReservationFormEntity rf = new ReservationFormEntity { };
//rf.First_Name = "sari2";
//rf.Last_Name = "qash2";
//r1.Reservation_Form = rf;
//r1.status = 1;
//r1.WhiteLabel_ID = 1;
}
public async Task UpdateAsync(ReservationEntity item)
{
this.exploreDb.Reservations.Update(item);
}
public void Update(ReservationEntity item)
{
throw new System.NotImplementedException();
}
public async Task AddAsync(ReservationEntity item)
{
await this.exploreDb.Reservations.AddAsync(item);
}
public ReservationEntity AddReservation(ReservationEntity reservation)
{
carParkContext.Reservations.Add(reservation);
carParkContext.SaveChanges();
return(reservation);
}
public ReservedDateOutput(ReservationEntity reservation)
{
From = reservation.ReservedFrom;
To = reservation.ReservedTo;
}
public void Update(ReservationEntity reservation)
{
_context.Reservations.Update(reservation);
_context.SaveChanges();
}
public ReservationEntity Insert(ReservationEntity reservation)
{
_context.Reservations.Add(reservation);
_context.SaveChanges();
return(reservation);
}
public void CancelReservation(ReservationEntity reservation)
{
carParkContext.Reservations.Remove(reservation);
carParkContext.SaveChanges();
}
public async Task Add(ReservationEntity reservation)
{
await _context.Reservations.AddAsync(reservation);
await _context.SaveChangesAsync();
}