public GenericStatusMessage ValidateRequest(long roomId, long requestId, long userId, bool validateDoubleBooking = false)
{
using (ReservationDataContext context = new ReservationDataContext())
{
ReservationRequest reservationRequest = context.ReservationRequests.Include(x => x.Room).SingleOrDefault(x => x.Id == requestId);
if (reservationRequest == null)
{
return(new GenericStatusMessage(false, $"Reservation with ID {requestId} does not exist."));
}
if (reservationRequest.RoomId != roomId)
{
return(new GenericStatusMessage(false, $"Request {requestId} does not belong to room {roomId}."));
}
if (reservationRequest.Room.OwnerId != userId)
{
return(new GenericStatusMessage(false, $"Request {requestId} can not be verified by user."));
}
if (validateDoubleBooking)
{
return(ValidateRoomAvailability(context, reservationRequest));
}
return(new GenericStatusMessage(true));
}
}
public void Should_be_a_value_type()
{
var firstInstance = new ReservationRequest("A-train", 3);
var secondInstance = new ReservationRequest("A-train", 3);
Check.That(firstInstance).IsEqualTo(secondInstance);
}
public async Task <IActionResult> MakeReservation([FromBody] ReservationRequest request)
{
var device = _devicesService.GetById(request.DeviceId);
if (device == null)
{
return(NotFound());
}
var user = await _userManager.GetUserAsync(HttpContext.User);
var conflicts = await _reservationsService.MakeReservation(device, request.DateFrom, request.DateTo, user);
if (conflicts != null)
{
var response = conflicts.Select(conflict => new ReservationForDate()
{
Id = conflict.Id,
DateFrom = conflict.DateFrom,
DateTo = conflict.DateTo,
UserName = conflict.User.Name
});
return(StatusCode((int)HttpStatusCode.Conflict, response));
}
return(Ok());
}
public void Should_Insert_ANewItem()
{
ReservationRequestViewObject viewObject = new ReservationRequestViewObject()
{
NUMERO = "12190"
};
IReservationRequest reservationRequest = new ReservationRequest(viewObject);
bool isRegistered = false;
DataPayLoad currentDataPayLoad = null;
var requestService = new Mock <IReservationRequestDataService>();
requestService.Setup(x => x.GetNewDo(It.IsAny <string>())).Returns(reservationRequest);
_eventManager.Setup(x => x.NotifyToolBar(It.IsAny <DataPayLoad>())).Callback <DataPayLoad>(x =>
{
isRegistered = x.PayloadType == DataPayLoad.Type.RegistrationPayload;
currentDataPayLoad = x;
});
_dataServices.Setup(x => x.GetReservationRequestDataService()).Returns(requestService.Object);
var reservationRequestsView = new ReservationRequestsViewModel(_dataServices.Object, _interacionController.Object, _dialogService.Object, _eventManager.Object, _navigator.Object, null, null, _unityContainer.Object);
// now i should arrange a new id and send to the reservation request view model.
DataPayLoad payload = new DataPayLoad();
payload.PayloadType = DataPayLoad.Type.Insert;
payload.DataObject = reservationRequest;
payload.HasDataObject = true;
reservationRequestsView.IncomingPayload(payload);
Assert.AreEqual(reservationRequestsView.DataObject.NUMERO, viewObject.NUMERO);
}
public async Task <ActionResult <ReservationResponse> > CreateAsync(ReservationRequest item)
{
var roomItem = await db.Rooms.FindAsync(item.RoomId);
if (roomItem == null)
{
return(NotFound(new ProblemDetails
{
Title = $"Room id {item.RoomId} not found"
}));
}
var hasOverlapped = db.Reservations.Where(q =>
q.RoomId == item.RoomId &&
!q.IsCanceled &&
q.CheckInDate <= item.CheckInDate &&
q.CheckOutDate >= item.CheckInDate
).Any();
if (hasOverlapped)
{
return(BadRequest(new ProblemDetails
{
Title = $"Reservation Duplicate"
}));
}
var newItem = item.ToModel();
await db.AddAsync(newItem);
await db.SaveChangesAsync();
return(CreatedAtAction(nameof(GetByIdAsync), new { id = item.Id }, ReservationResponse.FromModel(newItem)));
}
public virtual void TestSimple()
{
PrepareBasicPlan();
// create a request with a single atomic ask
ReservationDefinition rr = new ReservationDefinitionPBImpl();
rr.SetArrival(5 * step);
rr.SetDeadline(20 * step);
ReservationRequest r = ReservationRequest.NewInstance(Org.Apache.Hadoop.Yarn.Api.Records.Resource
.NewInstance(2048, 2), 10, 5, 10 * step);
ReservationRequests reqs = new ReservationRequestsPBImpl();
reqs.SetReservationResources(Collections.SingletonList(r));
rr.SetReservationRequests(reqs);
ReservationId reservationID = ReservationSystemTestUtil.GetNewReservationId();
agent.CreateReservation(reservationID, "u1", plan, rr);
NUnit.Framework.Assert.IsTrue("Agent-based allocation failed", reservationID != null
);
NUnit.Framework.Assert.IsTrue("Agent-based allocation failed", plan.GetAllReservations
().Count == 3);
ReservationAllocation cs = plan.GetReservationById(reservationID);
System.Console.Out.WriteLine("--------AFTER SIMPLE ALLOCATION (queue: " + reservationID
+ ")----------");
System.Console.Out.WriteLine(plan.ToString());
System.Console.Out.WriteLine(plan.ToCumulativeString());
for (long i = 10 * step; i < 20 * step; i++)
{
NUnit.Framework.Assert.IsTrue("Agent-based allocation unexpected", Resources.Equals
(cs.GetResourcesAtTime(i), Org.Apache.Hadoop.Yarn.Api.Records.Resource.NewInstance
(2048 * 10, 2 * 10)));
}
}
public static Reservation ToDataModel(this ReservationRequest request, string userId, Reservation item = null)
{
if (item == null)
{
item = new Reservation()
{
Id = Guid.NewGuid().ToString(),
CreatedAt = DateTime.Now,
ModifiedAt = DateTime.Now
};
}
else
{
item.Id = request.Id;
}
item.Comment = request.Comment;
item.StartAt = request.StartAt;
item.EndAt = request.EndAt;
item.IsEndless = request.IsEndless;
item.ObjectTagId = request.ObjectTagId;
item.OwnerUserId = userId;
item.Priority = request.Priority;
return(item);
}
private IDictionary <ReservationInterval, ReservationRequest> GenerateAllocation(int
startTime, int[] alloc, bool isStep, bool isGang)
{
IDictionary <ReservationInterval, ReservationRequest> req = new Dictionary <ReservationInterval
, ReservationRequest>();
int numContainers = 0;
for (int i = 0; i < alloc.Length; i++)
{
if (isStep)
{
numContainers = alloc[i] + i;
}
else
{
numContainers = alloc[i];
}
ReservationRequest rr = ReservationRequest.NewInstance(Org.Apache.Hadoop.Yarn.Api.Records.Resource
.NewInstance(1024, 1), (numContainers));
if (isGang)
{
rr.SetConcurrency(numContainers);
}
req[new ReservationInterval(startTime + i, startTime + i + 1)] = rr;
}
return(req);
}
public void Retornar_exception_se_nao_tiver_capacidade_disponivel_no_mesmo_vagao()
{
//arrange
_repositoryMock.Setup(x => x.GetTrainByDestinationAndDate("BAHIA", new DateTime(2017, 01, 01, 11, 0, 0)))
.Returns(new List <Train>
{
new Train
{
Id = Guid.NewGuid(),
Coachs = 10,
Destination = "BAHIA",
SeatsInCoach = 1,
ScheduledDate = new DateTime(2017, 01, 01, 11, 0, 0)
}
});
var request = new ReservationRequest
{
Destination = "BAHIA",
ScheduledDate = new DateTime(2017, 01, 01, 11, 0, 0),
Passengers = new[] { "Passageiro1", "Passageiro2" }
};
//act
var response = _sut.MakeReservation(request);
}
//[HttpGet("freeCourts/{from}/{to}/{minutes}")]
//public IActionResult GetFreeCourtsFromTo(string from, string to, string minutes)
//{
// if (!DateTime.TryParse(from, out DateTime fromTime))
// {
// _logger.LogError($"System was not able to parse {from} to Start Time.");
// return BadRequest($"System was not able to parse {from} to Start Time.");
// }
// if (!DateTime.TryParse(to, out DateTime toTime))
// {
// _logger.LogError($"System was not able to parse {to} to End Time.");
// return BadRequest($"System was not able to parse {to} to End Time.");
// }
// if(!Int16.TryParse(minutes, out Int16 min))
// {
// _logger.LogError($"System was not able to parse {minutes} to reqested play time.");
// return BadRequest($"System was not able to parse {minutes} to reqested play time.");
// }
// TimeSpan requestedTime = new TimeSpan(0, min, 0);
// _logger.LogInformation($"Squash Controller is reqesting Free Courts from: {fromTime} to: {toTime} for: {requestedTime}");
// List<CourtDto> korty = _squash.GetFreeSquashCourts(new ReservationRequest() { FromTime= fromTime, ToTime= toTime,Duration= requestedTime });
// _messanger.Send("### Squash Team", $"API found {korty.Count()} free squash courts ###");
// return Ok(korty);
//}
private ReservationRequest ConvertReservation(ReservationDto reservation)
{
ReservationRequest request = new ReservationRequest(reservation);
return(request);
}
/// <exception cref="Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Reservation.Exceptions.ContractValidationException
/// "/>
private void ValidateInput(Plan plan, ReservationRequest rr, Resource totalCapacity
)
{
if (rr.GetConcurrency() < 1)
{
throw new ContractValidationException("Gang Size should be >= 1");
}
if (rr.GetNumContainers() <= 0)
{
throw new ContractValidationException("Num containers should be >= 0");
}
// check that gangSize and numContainers are compatible
if (rr.GetNumContainers() % rr.GetConcurrency() != 0)
{
throw new ContractValidationException("Parallelism must be an exact multiple of gang size"
);
}
// check that the largest container request does not exceed
// the cluster-wide limit for container sizes
if (Resources.GreaterThan(plan.GetResourceCalculator(), totalCapacity, rr.GetCapability
(), plan.GetMaximumAllocation()))
{
throw new ContractValidationException("Individual" + " capability requests should not exceed cluster's maxAlloc"
);
}
}
public async Task UpdateReservationRequest(ReservationRequest reservationRequest)
{
using (var sqlConnection = await _db.GetSqlConnection())
{
await sqlConnection.ExecuteAsync("UpdateReservationRequest", reservationRequest, commandType : System.Data.CommandType.StoredProcedure);
}
}
public ReservationReponse reserver(ReservationRequest request)
{
ReservationReponse reservationReponse = new ReservationReponse();
String numeroDeChambre = chambreMap[request.offreId];
String dateDep = dateDepart[request.offreId];
foreach (Reponse reponse in reponses)
{
if (reponse.offreId.CompareTo(request.offreId) == 0)
{
foreach (Chambre c in hotel.chambre)
{
if (c.numero.CompareTo(numeroDeChambre) == 0)
{
if (!c.disponible)
{
reservationReponse.confirmation = "désolé le chambre n'est pas disponible pour l'instant veuillez regardé " +
"la date disponible de cette offre ou choisir un autre offre";
return(reservationReponse);
}
c.disponible = false;
c.dateDispo = dateDep;
double percentage = c.prix * 0.1;
agences.Add(request.agenceId, (float)(percentage));
Console.WriteLine("Agence numero " + request.agenceId + "vous avez gagné " + agences[request.agenceId] + " Euros de cette reservation");
}
}
reservationReponse.confirmation = "Vous avez réservé votre chambre chez Place hotel!";
return(reservationReponse);
}
}
reservationReponse.confirmation = "Désole il y a eu une erreur ";
return(reservationReponse);
}
public static ReservationDefinition GenerateBigRR(Random rand, long i)
{
rand.SetSeed(i);
long now = Runtime.CurrentTimeMillis();
// start time at random in the next 2 hours
long arrival = rand.Next(2 * 3600 * 1000);
// deadline at random in the next day
long deadline = rand.Next(24 * 3600 * 1000);
// create a request with a single atomic ask
ReservationDefinition rr = new ReservationDefinitionPBImpl();
rr.SetArrival(now + arrival);
rr.SetDeadline(now + deadline);
int gang = 1;
int par = 100000;
// 100k tasks
long dur = rand.Next(60 * 1000);
// 1min tasks
ReservationRequest r = ReservationRequest.NewInstance(Resource.NewInstance(1024,
1), par, gang, dur);
ReservationRequests reqs = new ReservationRequestsPBImpl();
reqs.SetReservationResources(Collections.SingletonList(r));
rand.Next(3);
ReservationRequestInterpreter[] type = ReservationRequestInterpreter.Values();
reqs.SetInterpreter(type[rand.Next(type.Length)]);
rr.SetReservationRequests(reqs);
return(rr);
}
private void createRes_Click(object sender, EventArgs e)
{
string initiator = usersBox.Text.Split(',')[0];
List <string> usersList = usersBox.Text.Split(',').ToList <string>();
List <int> slotsList = slotsBox.Text.Split(',').ToList().ConvertAll <int>(Convert.ToInt32);
string desc = descBox.Text;
ReservationRequest rr = new ReservationRequest();
rr.Description = desc;
rr.Users = usersList;
rr.Slots = slotsList;
IClientFacade icf = (IClientFacade)pms.getClientFacadeList()[initiator];
try
{
if (icf != null)
{
icf.CreateReservation(rr); //There is an exception unhandled here.
}
else
{
show("Unable to get Client Facade of Initiator");
}
}
catch (Exception ex)
{
Console.WriteLine("[PMS-EXCEPTION] " + ex.ToString());
}
}
private ReservationUpdateRequest CreateSimpleReservationUpdateRequest(int numRequests
, int numContainers, long arrival, long deadline, long duration)
{
// create a request with a single atomic ask
ReservationUpdateRequest request = new ReservationUpdateRequestPBImpl();
ReservationDefinition rDef = new ReservationDefinitionPBImpl();
rDef.SetArrival(arrival);
rDef.SetDeadline(deadline);
if (numRequests > 0)
{
ReservationRequests reqs = new ReservationRequestsPBImpl();
rDef.SetReservationRequests(reqs);
if (numContainers > 0)
{
ReservationRequest r = ReservationRequest.NewInstance(Org.Apache.Hadoop.Yarn.Api.Records.Resource
.NewInstance(1024, 1), numContainers, 1, duration);
reqs.SetReservationResources(Sharpen.Collections.SingletonList(r));
reqs.SetInterpreter(ReservationRequestInterpreter.RAll);
}
}
request.SetReservationDefinition(rDef);
request.SetReservationId(ReservationSystemTestUtil.GetNewReservationId());
return(request);
}
public async Task <ActionResult <object> > Post([FromBody] ReservationRequest tenantsRequest)
{
var userDataClaim = GetCurrentUserIdClaim();
if (userDataClaim is null)
{
return(NotFound());
}
tenantsRequest.TenantId = userDataClaim.Value;
tenantsRequest.Created = DateTime.UtcNow;
ReservationRequestValidator validator = new(_dbContext);
var result = validator.Validate(tenantsRequest);
if (!result.IsValid)
{
return(StatusCode(500, new { errors = result.Errors }));
}
_dbContext.ReservationRequests.Add(tenantsRequest);
await _dbContext.SaveChangesAsync();
return(StatusCode(201, new { id = tenantsRequest.Id }));
}
public async Task <IActionResult> GetUserReservations([FromBody] ReservationRequest model)
{
var result = await _service.GetUserReservations(model?.Username);
List <BookModel> models = _mapper.Map <List <BookModel> >(result);
return(Ok(models));
}
public async Task <IActionResult> Details(ReservationRequest reservation, int reservationId)
{
if (reservation.ReferenceNo == Guid.Empty)
{
reservation = await _service.GetOneReservation(reservation.Id);
}
return(View(reservation));
}
public bool CreateReservation(ReservationRequest reservation)
{
//initiate the reservation
//setup callbacks
//return;
return(true);
}
public IViewComponentResult Invoke(int bikeId)
{
var request = new ReservationRequest
{
RequestedBikeId = bikeId
};
return(View(request));
}
public async Task <IActionResult> Edit(int id, ReservationRequest reservation)
{
if (id != reservation.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var isVaildReservation = await _service.IsValidReservation(reservation);
if (!isVaildReservation)
{
ViewBag.AvailableTimeMsg = "Sorry, the reservation end time is outside the sitting period";
return(View(reservation));
}
try
{
var user = await _userManager.FindByEmailAsync(User.Identity.Name);
var userId = user?.Id;
var isSuccess = await _service.EditReservation(reservation, userId);
if (isSuccess)
{
return(RedirectToAction(nameof(Index)));
}
else
{
var availableTimeRange = await _service.GetAvailableTimeRange(reservation);
if (availableTimeRange == null)
{
ViewBag.AvailableTimeMsg = "Sorry, there is no available time on selected date, please select another date";
}
else
{
var startTime = availableTimeRange[0];
ViewBag.AvailableTimeMsg =
$"There is no vacancy on selected time, please select {reservation.StartDateTime.ToString("yyyy-MM-dd")} {startTime}";
}
return(View(reservation));
}
}
catch (DbUpdateConcurrencyException)
{
if (!_service.IsReservationExist(id))
{
return(NoContent());
}
else
{
throw;
}
}
}
return(View(reservation));
}
static void Main(string[] args)
{
//List<Room> list;
//using (HotelDBEntities hotelDBEntities = new HotelDBEntities())
//{
// var query = from it in hotelDBEntities.Rooms
// where it.RoomType != null
// select it;
// list = query.ToList();
// foreach (var item in list)
// {
// item.RoomTypeReference.Load();
// }
//}
//return;
//Program program = new Program();
//program.createReservation();
var client = new HotelDataInfoUpdateClient();
try
{
// RoomInfo[] roomInfos = client.getAllRoomInfos();
//bool avail = client.checkRoomAvailability("1001","5/11/2011",1);
ReservationRequest request = new ReservationRequest();
request.CardType = "VISA";
request.Duration = 2;
request.GuestAccount = "12345678";
request.GuestName = "Tan Geok";
request.GuestPassport = "G19881030";
request.NumOfGuest = 2;
request.RoomNo = "1001";
request.StartDate = "5/11/2011";
request.TotalCharge = "600";
String response = client.makeRoomReservation(request.CardType, request.GuestAccount, request.GuestName, request.GuestPassport, request.Duration, request.NumOfGuest, request.RoomNo, request.StartDate, request.TotalCharge);
// createRoom();
client.Close();
Console.WriteLine(response);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
client.Abort();
}
//HotelFacade facade = new HotelFacade();
// List<Room> rooms = facade.getAllRooms();
// Console.WriteLine(rooms.Count);
Console.ReadLine();
}
public void Reserve1SeatsInFullyBookedCoachReturnFailReservation()
{
Reservation expected = Reservation.Of("test_3000", "", new List <Seat>()
{
});
Reservation result = _ticketOffice.MakeReservationInCoach(ReservationRequest.Of("test_3000", 1));
Assert.AreEqual(expected, result);
}
public void Reserve2SeatsInTrainReservedAtMoreThan70PercentReturnSuccessReservation()
{
Reservation expected = Reservation.Of("FullyReserved_train", "", new List <Seat>()
{
});
Reservation result = _ticketOffice.MakeReservation(ReservationRequest.Of("FullyReserved_train", 2));
Assert.AreEqual(expected, result);
}
static void Main(string[] args)
{
//List<Room> list;
//using (HotelDBEntities hotelDBEntities = new HotelDBEntities())
//{
// var query = from it in hotelDBEntities.Rooms
// where it.RoomType != null
// select it;
// list = query.ToList();
// foreach (var item in list)
// {
// item.RoomTypeReference.Load();
// }
//}
//return;
//Program program = new Program();
//program.createReservation();
var client = new HotelDataInfoUpdateClient();
try
{
// RoomInfo[] roomInfos = client.getAllRoomInfos();
//bool avail = client.checkRoomAvailability("1001","5/11/2011",1);
ReservationRequest request = new ReservationRequest();
request.CardType = "VISA";
request.Duration = 2;
request.GuestAccount = "12345678";
request.GuestName = "Tan Geok";
request.GuestPassport = "G19881030";
request.NumOfGuest = 2;
request.RoomNo = "1001";
request.StartDate = "5/11/2011";
request.TotalCharge = "600";
String response = client.makeRoomReservation(request.CardType, request.GuestAccount, request.GuestName, request.GuestPassport, request.Duration, request.NumOfGuest, request.RoomNo, request.StartDate, request.TotalCharge);
// createRoom();
client.Close();
Console.WriteLine(response);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
client.Abort();
}
//HotelFacade facade = new HotelFacade();
// List<Room> rooms = facade.getAllRooms();
// Console.WriteLine(rooms.Count);
Console.ReadLine();
}
public IActionResult Reserver(ReservationRequest request)
{
using (var client = new HttpClient())
{
request.agenceId = "1034A";
request.password = "******";
client.BaseAddress = new Uri("https://localhost:46767/api/Home/");
var postJob = client.PostAsJsonAsync <ReservationRequest>("reserver", request);
postJob.Wait();
var reponse = postJob.Result;
if (reponse.IsSuccessStatusCode)
{
Console.WriteLine("deta era");
var readTask = reponse.Content.ReadFromJsonAsync <ReservationReponse>();
readTask.Wait();
ReservationReponse reponses = readTask.Result;
ViewBag.reservation = reponses;
return(View("Result"));
}
else
{
Console.WriteLine("dew");
}
}
using (var clientIbiza = new HttpClient())
{
request.agenceId = "1034A";
request.password = "******";
clientIbiza.BaseAddress = new Uri("https://localhost:31627/api/Home/");
var postJob = clientIbiza.PostAsJsonAsync <ReservationRequest>("reserver", request);
postJob.Wait();
var reponse = postJob.Result;
if (reponse.IsSuccessStatusCode)
{
Console.WriteLine("deta era");
var readTask = reponse.Content.ReadFromJsonAsync <ReservationReponse>();
readTask.Wait();
ReservationReponse reponses = readTask.Result;
ViewBag.reservation = reponses;
return(View("Result"));
}
else
{
Console.WriteLine("dew");
}
}
ModelState.AddModelError(string.Empty, "il y a eu une errur de capter le api");
return(View(request));
}
/// <summary>Removes a resource for the specified interval</summary>
/// <param name="reservationInterval">
/// the interval for which the resource is to be
/// removed
/// </param>
/// <param name="capacity">the resource to be removed</param>
/// <returns>true if removal is successful, false otherwise</returns>
public virtual bool RemoveInterval(ReservationInterval reservationInterval, ReservationRequest
capacity)
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource totCap = Resources.Multiply(capacity.
GetCapability(), (float)capacity.GetNumContainers());
if (totCap.Equals(ZeroResource))
{
return(true);
}
writeLock.Lock();
try
{
long startKey = reservationInterval.GetStartTime();
long endKey = reservationInterval.GetEndTime();
// update the start key
NavigableMap <long, Org.Apache.Hadoop.Yarn.Api.Records.Resource> ticks = cumulativeCapacity
.HeadMap(endKey, false);
// Decrease all the capacities of overlapping intervals
SortedDictionary <long, Org.Apache.Hadoop.Yarn.Api.Records.Resource> overlapSet =
ticks.TailMap(startKey);
if (overlapSet != null && !overlapSet.IsEmpty())
{
Org.Apache.Hadoop.Yarn.Api.Records.Resource updatedCapacity = Org.Apache.Hadoop.Yarn.Api.Records.Resource
.NewInstance(0, 0);
long currentKey = -1;
for (IEnumerator <KeyValuePair <long, Org.Apache.Hadoop.Yarn.Api.Records.Resource> >
overlapEntries = overlapSet.GetEnumerator(); overlapEntries.HasNext();)
{
KeyValuePair <long, Org.Apache.Hadoop.Yarn.Api.Records.Resource> entry = overlapEntries
.Next();
currentKey = entry.Key;
updatedCapacity = Resources.Subtract(entry.Value, totCap);
// update each entry between start and end key
cumulativeCapacity[currentKey] = updatedCapacity;
}
// Remove the first overlap entry if it is same as previous after
// updation
long firstKey = overlapSet.FirstKey();
if (IsSameAsPrevious(firstKey, overlapSet[firstKey]))
{
Sharpen.Collections.Remove(cumulativeCapacity, firstKey);
}
// Remove the next entry if it is same as end entry after updation
if ((currentKey != -1) && (IsSameAsNext(currentKey, updatedCapacity)))
{
Sharpen.Collections.Remove(cumulativeCapacity, cumulativeCapacity.HigherKey(currentKey
));
}
}
return(true);
}
finally
{
writeLock.Unlock();
}
}
public void Reserve1SeatsInPartiallyReservedCoachReturnSuccessReservation()
{
Reservation expected = Reservation.Of("express_2000", "75bcd15", new List <Seat>()
{
Seat.Of("A", 5, "")
});
Reservation result = _ticketOffice.MakeReservationInCoach(ReservationRequest.Of("express_2000", 1));
Assert.AreEqual(expected, result);
}
public void Reserve2SeatsInEmptyCoachReturnSuccessReservation()
{
Reservation expected = Reservation.Of("local_1000", "75bcd15", new List <Seat>()
{
Seat.Of("A", 1, ""), Seat.Of("A", 2, "")
});
Reservation result = _ticketOffice.MakeReservationInCoach(ReservationRequest.Of("local_1000", 2));
Assert.AreEqual(expected, result);
}
public void Reserve2SeatsInTrainReservedAtLessThan70PercentReturnSuccessReservation()
{
Reservation expected = Reservation.Of("1coachReserved_train", "75bcd15", new List <Seat>()
{
Seat.Of("B", 1, ""), Seat.Of("B", 2, "")
});
Reservation result = _ticketOffice.MakeReservation(ReservationRequest.Of("1coachReserved_train", 2));
Assert.AreEqual(expected, result);
}
/// <summary>
/// Gets a reservation by confirmation number from ESS reservation manager service.
/// </summary>
/// <param name="reservationRequest">Reservation Request</param>
/// <returns>ReservationSearchResult</returns>
public ReservationResponse GetReservationSearchResult(ReservationRequest reservationRequest)
{
using (Profiler.Step("ReservationServiceClient.GetReservationSearchResult"))
{
var activityId = String.Empty;
try
{
var header = ContextListBuilder.New().WithBusinessContext(ContextListAppContextSourceBusinessContext.VA)
.WithUserId(reservationRequest.UserUniqueId.ToString())
.Build();
activityId = header.DiagnosticContext.ActivityId;
if (reservationRequest.SearchItemType.IsNullOrEmpty() ||
reservationRequest.SearchItemValue.IsNullOrEmpty())
return null;
QueryReservationRQQueryType queryType;
switch (reservationRequest.SearchItemType)
{
case "email":
queryType = QueryReservationRQQueryType.CRS_ConfirmationNumberAndGuestEmail;
break;
default:
queryType = QueryReservationRQQueryType.CRS_ConfirmationNumber;
break;
}
using (var itineraryManagerClient = new ItineraryManagerClient(header, ServiceRegistry.AddressPool.OfType<IItineraryManager>()))
{
var queryReservationResponse = itineraryManagerClient.QueryReservation(CreateReservationQueryRequest(queryType, reservationRequest.ChainId, reservationRequest.SearchItemValue));
var rez = queryReservationResponse.ReservationList.FirstOrDefault();
return new ReservationResponse
{
ApplicationResults = new ApplicationResultsModel(
queryReservationResponse.ApplicationResults.Success.IsNotNull(),
queryReservationResponse.ApplicationResults.Warning.IfNotNull(
w => w.Select(
warning => warning.SystemSpecificResults.ShortText),
queryReservationResponse.ApplicationResults.Error.IfNotNull(
e => e.Select(error => error.SystemSpecificResults.ShortText))
)),
Reservation = MapReservationResponse(rez)
};
}
}
catch (Exception exception)
{
Logger.AppLogger.Error(
"GetReservationSearchResultUnhandledException",
exception,
"SearchItemType".ToKvp(reservationRequest.SearchItemType),
"SearchItemValue".ToKvp(reservationRequest.SearchItemValue),
"ChainId".ToKvp(reservationRequest.ChainId),
"HotelId".ToKvp(reservationRequest.HotelId),
"UserId".ToKvp(reservationRequest.UserUniqueId));
throw HttpResponseExceptionHelper.CreateHttpResponseException(activityId, exception);
}
}
}
/// <summary>
/// Updates a reservation and sets the status to confirmed.
/// </summary>
/// <param name="reservationRequest">Reservation request</param>
/// <param name="profileServiceClient">Profile service client</param>
/// <returns></returns>
public ReservationResponse UpdateReservation(ReservationRequest reservationRequest, IProfileServiceClient profileServiceClient)
{
using (Profiler.Step("ReservationServiceClient.UpdateReservation"))
{
var activityId = String.Empty;
try
{
var header = ContextListBuilder.New().WithBusinessContext(ContextListAppContextSourceBusinessContext.VA)
.WithUserId(reservationRequest.UserUniqueId.ToString())
.Build();
activityId = header.DiagnosticContext.ActivityId;
var profileRequest = new ProfileRequest
{
ChainId = reservationRequest.ChainId,
HotelId = reservationRequest.HotelId,
TravelerProfileId = reservationRequest.GuestProfileId
};
var guestProfile = profileServiceClient.GetTravelerProfile(profileRequest);
using (var itineraryManagerClient = new ItineraryManagerClient(header, ServiceRegistry.AddressPool.OfType<IItineraryManager>()))
{
var updateReservationRq = new UpdateReservationRQ
{
Reservation = CreateUpdateReservationRequest(reservationRequest, guestProfile),
ReturnReservationDetails = true,
UserDetails = new UpdateReservationRQUserDetails
{
Preferences = new UpdateReservationRQUserDetailsPreferences
{
Language = new Language
{
Code = reservationRequest.Language
}
}
}
};
var updateReservationResponse = itineraryManagerClient.UpdateReservation(updateReservationRq);
var reservationResponse = new ReservationResponse
{
ApplicationResults = new ApplicationResultsModel(
updateReservationResponse.ApplicationResults.Success.IfNotNull(result => result.SystemSpecificResults.ShortText.Equals("Success"), false),
updateReservationResponse.ApplicationResults.Warning.IfNotNull(
applicationResultWarning => applicationResultWarning.Select(warning => warning.SystemSpecificResults.ShortText),
new List<String>()),
updateReservationResponse.ApplicationResults.Error.IfNotNull(applicationResultError => applicationResultError.Select(error => error.SystemSpecificResults.ShortText), new List<String>()))
};
if (reservationResponse.ApplicationResults.Success)
{
reservationResponse.Reservation = MapReservationResponse(updateReservationResponse.ReservationList.Reservation);
}
return reservationResponse;
}
}
catch (Exception exception)
{
Logger.AppLogger.Error(
"UpdateReservationUnhandledException",
exception,
"ChainId".ToKvp(reservationRequest.ChainId),
"HotelId".ToKvp(reservationRequest.HotelId),
"UserId".ToKvp(reservationRequest.UserUniqueId));
throw HttpResponseExceptionHelper.CreateHttpResponseException(activityId, exception);
}
}
}
/// <summary>
/// Creates a reservation request reservation
/// </summary>
/// <param name="reservationRequest">Reservation Request</param>
/// <returns>CreateReservationRQReservation</returns>
private CreateReservationRQReservation CreateReservationRequest(ReservationRequest reservationRequest)
{
return new CreateReservationRQReservation
{
Hotel = new CreateReservationRQReservationHotel
{
id = reservationRequest.HotelId
},
action = CreateReservationRQReservationAction.Booked,
BookingInfo = new CreateReservationRQReservationBookingInfo
{
BookingSource = new CreateReservationRQReservationBookingInfoBookingSource
{
IP_Address = reservationRequest.IpAddress,
PrimaryChannel = new CreateReservationRQReservationBookingInfoBookingSourcePrimaryChannel
{
code = WebConstants.PrimaryChannelCode
},
SecondaryChannel = new CreateReservationRQReservationBookingInfoBookingSourceSecondaryChannel
{
code = WebConstants.PrimaryChannelCode
}
}
},
Comment = reservationRequest.Comment,
CouponOfferCode = reservationRequest.CouponOfferCode,
Currency = new Currency { CurrencyCode = reservationRequest.CurrencyCode },
RoomStay = reservationRequest.GetCreateRoomStay(),
NumRooms = reservationRequest.Occupancy.NumberOfRooms
};
}
/// <summary>
/// Creates and update reservation request.
/// </summary>
/// <param name="reservationRequest">Reservation request</param>
/// <param name="profile">Profile</param>
/// <returns>UpdateReservationRQReservation</returns>
private UpdateReservationRQReservation CreateUpdateReservationRequest(ReservationRequest reservationRequest, Profile profile)
{
return new UpdateReservationRQReservation
{
CRS_confirmationNumber = reservationRequest.CrsConfirmationNumber,
action = UpdateReservationRQReservationAction.Confirmed,
BookingInfo = new UpdateReservationRQReservationBookingInfo
{
BookingSource = new UpdateReservationRQReservationBookingInfoBookingSource
{
IP_Address = reservationRequest.IpAddress,
PrimaryChannel = new UpdateReservationRQReservationBookingInfoBookingSourcePrimaryChannel
{
code = WebConstants.PrimaryChannelCode
},
SecondaryChannel = new UpdateReservationRQReservationBookingInfoBookingSourceSecondaryChannel
{
code = WebConstants.PrimaryChannelCode
}
}
},
//Comment = reservationRequest.Comment,
//CouponOfferCode = reservationRequest.CouponOfferCode,
Currency = new Currency { CurrencyCode = reservationRequest.CurrencyCode },
RoomStay = reservationRequest.GetUpdateRoomStay(),
NumRooms = reservationRequest.Occupancy.NumberOfRooms,
Guest = reservationRequest.GetGuest(profile).ToArray()
};
}
