public void CheckOnlineAvailabilityFullResultIfAllBusinessesMarkedMinStayCriteriaNotMet() { // Arrange AvailabilitySearchResult searchResult = new AvailabilitySearchResult { BusinessCandidates = new List<AvailabilityResultBusiness> { new AvailabilityResultBusiness { BusinessId = 1, UnavailabilityReasonCode = UnavailabilityReasonCode.MinStayCriteriaNotMet }, new AvailabilityResultBusiness { BusinessId = 2, UnavailabilityReasonCode = UnavailabilityReasonCode.NoInventory }, }, UnavailabilityReasonCode = null }; var onlineSearchManager = new AvailabilityManager(); var results = onlineSearchManager.FilterSearchResultsForOnlineCheckAvailability(searchResult); Assert.AreEqual(UnavailabilityReasonCode.MinStayCriteriaNotMet, results.UnavailabilityReasonCode, "Result UnavailabilityReasonCode should be MinStayCriteriaNotMet"); }
public void CheckAdditionalRatePlanAvailabilityByRoomTypeIsSuccessful() { // Arrange const int BUSINESS_ID = 1; var availabilityManager = MockRepository.GenerateStub<IAvailabilityManager>(); CalendarDate startDate = CalendarDate.ConvertToCalendarDate(DateTime.UtcNow); CalendarDate endDate = CalendarDate.ConvertToCalendarDate(DateTime.UtcNow).AddDays(1); var searchDto = new AvailabilitySearchCriteriaDto { StartDate = LimitedDataTransferObjectsConverter.ConvertCalendarDateToDto(startDate), EndDate = LimitedDataTransferObjectsConverter.ConvertCalendarDateToDto(endDate), BusinessId = BUSINESS_ID, RoomTypeId = 1, NumberOfAdults = 1, NumberOfChildren = 0 }; var resultToReturn = new AvailabilitySearchResult { StartDate = startDate, EndDate = endDate, NoOfAdults = 2, NoOfChildren = null, BusinessCandidates = new List<AvailabilityResultBusiness> { new AvailabilityResultBusiness { BusinessId = BUSINESS_ID } }, }; resultToReturn.BusinessCandidates[0].RoomTypes = new List<AvailabilityResultRoomType> { new AvailabilityResultRoomType { BusinessId = BUSINESS_ID, RoomIds = new List<int> {1, 2}, RoomTypeCode = "R1", RoomTypeName = "Double Room", RoomTypeId = 1 } }; resultToReturn.BusinessCandidates[0].RoomTypes[0].RatePlans = new List<AvailabilityResultRatePlan> { new AvailabilityResultRatePlan { RatePlanId = 1, RoomTypeId = 1, IsBaseRatePlan = false } }; resultToReturn.BusinessCandidates[0].RoomTypes[0].RatePlans[0].PriceCandidates = new List<AvailabilityResultPrice> { new AvailabilityResultPrice { BusinessId = BUSINESS_ID, RoomTypeId = 1, TotalPrice = 100, RatePlanId = 1 } }; resultToReturn.BusinessCandidates[0].RoomTypes[0].RatePlans[0].PriceCandidates[0]. PriceCalculationBreakdowns = new List<PriceCalculationBreakdown> { new PriceCalculationBreakdown { NightNumber = 1, Price = 100, RateType = new EnumEntity { Code = RateType.BAR } } }; // Stub the BusinessCache to be used by our service method CacheHelper.StubBusinessCacheSingleBusiness(BUSINESS_ID); // invalidate the cache so we make sure our business is loaded into the cache Cache.Business.Invalidate(); availabilityManager.Stub(m => m.CheckAvailability(Arg<AvailabilitySearchCriteria>.Is.Anything)).Return(resultToReturn); limitedMobileService.AvailabilityManager = availabilityManager; // Act AvailabilitySearchResultDto availabilitySearchResult = limitedMobileService.CheckAvailability(BUSINESS_ID, searchDto); // Assert Assert.AreEqual(BUSINESS_ID, availabilitySearchResult.BusinessCandidates[0].BusinessId, "Check the businessId has been correctly set"); Assert.AreEqual(1, availabilitySearchResult.BusinessCandidates[0].RoomTypes.Count, "Number Of RoomTypes returned is incorrect."); Assert.AreEqual(1, availabilitySearchResult.BusinessCandidates[0].RoomTypes[0].RoomTypeId, "RoomType Id retrieved is incorrect."); Assert.IsNotNull(availabilitySearchResult.BusinessCandidates[0].RoomTypes[0].RatePlans, "RatePlans are not retrieved for roomType."); AvailabilityResultRatePlanDto additionalRateplan = availabilitySearchResult.BusinessCandidates[0].RoomTypes[0].RatePlans[0]; Assert.IsFalse(additionalRateplan.IsBaseRatePlan, "Additional Rateplan is not retrieved."); Assert.AreEqual(1, additionalRateplan.RatePlanId, "Rateplan id retrieved is incorrect."); Assert.IsNotNull(additionalRateplan.PriceCandidates, "Price available is null."); Assert.AreEqual(1, additionalRateplan.PriceCandidates.Count, "Total number of price candidates are wrong."); Assert.AreEqual(100, additionalRateplan.PriceCandidates[0].TotalPrice, "TotalPrice calculated is not correct."); }
public void CheckOnlineAvailabilityBusinessCandidateIfNoRoomsAvailableThenGetFirstUnavalailableReason() { // Arrange const long BUSINESS_ID = 500; const string BUSINESS_NAME = "EVO"; // room types var roomTypes = Get6RoomTypesWithNullUnAvailabilityReasonCode(BUSINESS_ID); roomTypes.ForEach(x => x.UnAvailabilityReasonCode = UnavailabilityReasonCode.NoRateDefined); roomTypes[0].UnAvailabilityReasonCode = UnavailabilityReasonCode.MaxAdultExceeded; roomTypes[1].UnAvailabilityReasonCode = UnavailabilityReasonCode.MaxOccupancyExceeded; roomTypes[2].UnAvailabilityReasonCode = UnavailabilityReasonCode.MaxChildrenExceeded; AvailabilitySearchResult searchResult = new AvailabilitySearchResult { BusinessCandidates = new List<AvailabilityResultBusiness> { new AvailabilityResultBusiness { BusinessId = BUSINESS_ID, ShortName = BUSINESS_NAME, RoomTypes = roomTypes, UnavailabilityReasonCode = null } }, UnavailabilityReasonCode = null }; var onlineSearchManager = new AvailabilityManager(); var results = onlineSearchManager.FilterSearchResultsForOnlineCheckAvailability(searchResult); Assert.AreEqual(UnavailabilityReasonCode.MaxOccupancyExceeded, results.BusinessCandidates[0].UnavailabilityReasonCode, "BusinessCandidates UnavailabilityReasonCode should be MaxOccupancyExceeded"); }
public void CheckOnlineAvailabilityBusinessCandidateIfSomeRoomsAvailableDontSetUnavailabilityReason() { // Arrange const long BUSINESS_ID = 500; const string BUSINESS_NAME = "EVO"; // room types var roomTypes = Get6RoomTypesWithNullUnAvailabilityReasonCode(BUSINESS_ID); roomTypes[0].UnAvailabilityReasonCode = UnavailabilityReasonCode.MaxOccupancyExceeded; roomTypes[1].UnAvailabilityReasonCode = UnavailabilityReasonCode.MaxAdultExceeded; roomTypes[2].UnAvailabilityReasonCode = UnavailabilityReasonCode.CheckInNotPossible; AvailabilitySearchResult searchResult = new AvailabilitySearchResult { BusinessCandidates = new List<AvailabilityResultBusiness> { new AvailabilityResultBusiness { BusinessId = BUSINESS_ID, ShortName = BUSINESS_NAME, RoomTypes = roomTypes, UnavailabilityReasonCode = null } }, UnavailabilityReasonCode = null }; var onlineSearchManager = new AvailabilityManager(); var results = onlineSearchManager.FilterSearchResultsForOnlineCheckAvailability(searchResult); Assert.IsNull(results.BusinessCandidates[0].UnavailabilityReasonCode, "BusinessCandidates UnavailabilityReasonCode should be null"); }
/// <summary> /// Check Availability for supplied criteria /// </summary> /// <param name="availabilitySearchCriteria">Criteria to consider in availability check</param> /// <param name="existingBooking">booking to be modified (if already loaded)</param> /// <returns>The Availability Result based on the criteria supplied</returns> public virtual AvailabilitySearchResult CheckAvailability(AvailabilitySearchCriteria availabilitySearchCriteria, Model.Booking.Booking existingBooking = null) { Logger.LogInfo("==========CheckAvailability Called=========="); Logger.LogDebugAsXml(availabilitySearchCriteria); AvailabilitySearchResult result = null; if (availabilitySearchCriteria.ModifyBookingId.HasValue) { existingBooking = existingBooking ?? bookingManager.GetByKey(availabilitySearchCriteria.ModifyBookingId.Value); //Modify the presented criteria if this check is for a pre-existing booking result = UpdateCriteriaForExistingBooking(availabilitySearchCriteria, existingBooking); if (result != null) { return result; } } // Validate the criteria availabilitySearchCriteria.IsValid(); // Get the availability, only return available if there is no channel (help performance on pms slightly) bool onlyReturnAvailable = !availabilitySearchCriteria.ChannelId.HasValue; // set up tasks for availability / rate fetch List<RoomsAvailability> candidateRooms = null; // check if requested currency isn't one of the two for each business var criteriaSentToSproc = availabilitySearchCriteria.Clone(); Task availabilityTask = TaskProxy.StartTask( () => candidateRooms = pricingAvailabilityDao.GetAvailabilityForBusinessesBetweenDates(onlyReturnAvailable, criteriaSentToSproc)); // set up concurrent dictionary with capacity = number of businesses Dictionary<long, List<RateCache>> rateCacheDict = null; Task cacheTask = TaskProxy.StartTask(() => rateCacheDict = RateCacheManager.GetRatesByBusinessesAndDateRange (availabilitySearchCriteria.BusinessIds, availabilitySearchCriteria .StartDate.ConvertToTimeZoneLessDateTime(), availabilitySearchCriteria .EndDate.ConvertToTimeZoneLessDateTime())); Task.WaitAll(availabilityTask, cacheTask); // set the currency for the returned candidates // previously done in sproc var currencyCache = Cache.Cache.CurrencyCache.GetValue("root"); var requestedCurrency = currencyCache.Get(availabilitySearchCriteria.RequestedCurrency); string isoCode = availabilitySearchCriteria.RequestedCurrency; if (requestedCurrency != null) { isoCode = requestedCurrency.ISOCode; } foreach (var cR in candidateRooms) { cR.Currency = requestedCurrency; cR.CurrencyCode = isoCode; } // create initial list of businesses with those added that had neither currency List<AvailabilityResultBusiness> availableBusinesses = (from id in availabilitySearchCriteria.BusinessIds where !criteriaSentToSproc.BusinessIds.Contains(id) select new AvailabilityResultBusiness(UnavailabilityReasonCode.MissingCurrency, id)).ToList(); // If there is no rooms return AvailabilitySearchResult as there is no rooms to check for RoomTypes etc if (candidateRooms == null || candidateRooms.Count == 0) { // no availability or bad business, return empty result back var nullBusinessResult = GetNullBusinessAvailabilityResult(availabilitySearchCriteria); // so that if it was because of currency, we send that back nullBusinessResult.BusinessCandidates = availableBusinesses; if (nullBusinessResult.BusinessCandidates.Any(bc => bc.UnavailabilityReasonCode.HasValue)) { nullBusinessResult.UnavailabilityReasonCode = nullBusinessResult.BusinessCandidates.First(bc => bc.UnavailabilityReasonCode.HasValue).UnavailabilityReasonCode; } return nullBusinessResult; } // assign cache and deal with 0 prices / minloss based on cache results UpdateAvailabilityWithRateCache(availabilitySearchCriteria, candidateRooms, rateCacheDict); // set prepay based on rates set from above UpdateAvailabilityWithPrepay(candidateRooms, availabilitySearchCriteria); // If modify booking for an OTA booking then update all the rates with the current booking rate as OTA booking pricing cannot be changed if (availabilitySearchCriteria.ModifyBookingId.HasValue && existingBooking.Order.IsOTA) { // Set all fields on the available room object foreach (var room in candidateRooms) { room.TotalRate = existingBooking.Cost.Value; SetRoomTypeName(room); } } else { candidateRooms.ForEach(SetRoomTypeName); } // Create the object to be returned result = new AvailabilitySearchResult { StartDate = availabilitySearchCriteria.StartDate, EndDate = availabilitySearchCriteria.EndDate, NoOfAdults = availabilitySearchCriteria.NumberOfAdults, NoOfChildren = availabilitySearchCriteria.NumberOfChildren }; // sort the results by business AvailabilityResultBusiness currentBusiness = null; AvailabilityResultRoomType currentRoomType = null; foreach (RoomsAvailability candidate in candidateRooms) { if (currentBusiness == null || candidate.BusinessId != currentBusiness.BusinessId) { // Currently needs update to get all the businesses in list // We also need to check the criteria is valid for the correct time zone of the businesses. All businesses are assumed in the same time zone var business = Cache.Cache.Business.TryGetValue(candidate.BusinessId); if (business == null) { continue; } // for last of previous business AddRoomTypeToBusiness(currentRoomType, currentBusiness, availabilitySearchCriteria); currentRoomType = null; // add old business to list AddBusinessToList(currentBusiness, availableBusinesses); // set up new business var newBusiness = new AvailabilityResultBusiness { BusinessId = candidate.BusinessId, ShortName = business.ShortName, RoomTypes = new List<AvailabilityResultRoomType>(), Is3DSecureAllowed = business.MerchantDetails.Is3DSecureAllowed ?? true, IsAmexAllowed = business.MerchantDetails.IsAmexAllowed ?? true, IsPaypalAllowed = business.MerchantDetails.IsPaypalAllowed ?? false }; currentBusiness = newBusiness; } // add this roomtype candidate to the business if (currentRoomType == null || candidate.RoomTypeId != currentRoomType.RoomTypeId) { // first add the old one if it is present AddRoomTypeToBusiness(currentRoomType, currentBusiness, availabilitySearchCriteria); // set up new room type AvailabilityResultRoomType newRoomType = new AvailabilityResultRoomType { RoomTypeId = candidate.RoomTypeId, BusinessId = candidate.BusinessId, RoomTypeName = candidate.RoomTypeName, RatesAndRoomsAvailable = new List<RoomsAvailability>(), UnAvailabilityReasonCode = null }; currentRoomType = newRoomType; } currentRoomType.RatesAndRoomsAvailable.Add(candidate); } AddRoomTypeToBusiness(currentRoomType, currentBusiness, availabilitySearchCriteria); AddBusinessToList(currentBusiness, availableBusinesses); if (!availableBusinesses.Any()) { // bad business list, return empty result back return GetNullBusinessAvailabilityResult(availabilitySearchCriteria); } result.BusinessCandidates = availableBusinesses; CorrectWasPriceForResults(candidateRooms); Logger.LogInfo("==========CheckAvailability Returns=========="); Logger.LogDebugAsXml(result); return result; }
public void CheckOnlineAvailabilityBusinessCandidateAllRoomsNoInventoryThenNoInventory() { // Arrange const long BUSINESS_ID = 500; const string BUSINESS_NAME = "EVO"; // room types var roomTypes = Get6RoomTypesWithNullUnAvailabilityReasonCode(BUSINESS_ID); roomTypes.ForEach(x=>x.UnAvailabilityReasonCode = UnavailabilityReasonCode.NoRateDefined); AvailabilitySearchResult searchResult = new AvailabilitySearchResult { BusinessCandidates = new List<AvailabilityResultBusiness> { new AvailabilityResultBusiness { BusinessId = BUSINESS_ID, ShortName = BUSINESS_NAME, RoomTypes = roomTypes, UnavailabilityReasonCode = null } }, UnavailabilityReasonCode = null }; var onlineSearchManager = new AvailabilityManager(); var results = onlineSearchManager.FilterSearchResultsForOnlineCheckAvailability(searchResult); Assert.AreEqual(UnavailabilityReasonCode.NoInventory, results.BusinessCandidates[0].UnavailabilityReasonCode, "BusinessCandidates UnavailabilityReasonCode should be MinStayCriteriaNotMet"); }
public void WhenAnAvailabilitySearchIsPerformedAgainstTheRoomtype() { searchResults = availabilityManager.CheckAvailability(SetupAvailabilityCriteria(string.Empty, 1)); }
public void CheckIfUnavailabilityReasonCodeIsReturnedIfOccupancyRequirementIsNotMetIsSuccessful() { // Arrange const int BUSINESS_ID = 1; var availabilityManager = MockRepository.GenerateStub<IAvailabilityManager>(); var resultToReturn = new AvailabilitySearchResult { StartDate = new CalendarDate { Day = DateTime.UtcNow.Day, Month = DateTime.UtcNow.Month, Year = DateTime.UtcNow.Year }, EndDate = new CalendarDate { Day = DateTime.UtcNow.AddDays(1).Day, Month = DateTime.UtcNow.AddDays(1).Month, Year = DateTime.UtcNow.AddDays(1).Year }, NoOfAdults = 2, NoOfChildren = null, BusinessCandidates = new List<AvailabilityResultBusiness> { new AvailabilityResultBusiness { BusinessId = BUSINESS_ID } }, }; resultToReturn.BusinessCandidates[0].RoomTypes = new List<AvailabilityResultRoomType> { new AvailabilityResultRoomType { BusinessId = BUSINESS_ID, RoomTypeId = 6, RatesAndRoomsAvailable = null, UnAvailabilityReasonCode = UnavailabilityReasonCode.MaxOccupancyExceeded } }; // Stub the BusinessCache to be used by our service method CacheHelper.StubBusinessCacheSingleBusiness(BUSINESS_ID); // invalidate the cache so we make sure our business is loaded into the cache Cache.Business.Invalidate(); availabilityManager.Stub(m => m.CheckAvailability(Arg<AvailabilitySearchCriteria>.Is.Anything)).Return( resultToReturn); PropertyManagementSystemService.AvailabilityManager = availabilityManager; // Act AvailabilitySearchResultDto availabilitySearchResult = PropertyManagementSystemService.CheckAvailability(BUSINESS_ID, new AvailabilitySearchCriteriaDto()); // Assert Assert.AreEqual(BUSINESS_ID, availabilitySearchResult.BusinessCandidates[0].BusinessId, "Check the businessId has been correctly set"); Assert.AreEqual(1, availabilitySearchResult.BusinessCandidates[0].RoomTypes.Count, "Number Of RoomTypesRatesAndRoomsAvailable returned is incorrect."); Assert.IsNull(availabilitySearchResult.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable, "RatesAndRoomsAvailable are retrieved for roomType."); Assert.IsNotNull(availabilitySearchResult.BusinessCandidates[0].RoomTypes[0].UnAvailabilityReasonCode, "UnAvailabilityReasonCode is null."); Assert.AreEqual(UnavailabilityReasonCodeDto.MaxOccupancyExceeded, availabilitySearchResult.BusinessCandidates[0].RoomTypes[0].UnAvailabilityReasonCode, "Reason code returned is incorrect."); }
public void WhenAnAvailabilitySearchIsPerformedAgainstTheBaseRateplanForCheckinDateForNights(string checkinDate, int numberOfNights) { searchResults = availabilityManager.CheckAvailability(SetupAvailabilityCriteria(checkinDate, numberOfNights, baseRatePlanId)); }
public void WhenAnAvailabilitySearchIsPerformedAgainstTheBaseRateplanWhereAdultsAndChildren(int adults, int children) { searchResults = availabilityManager.CheckAvailability(SetupAvailabilityCriteria(string.Empty, 1, baseRatePlanId, adults, children)); }
public void WhenAnAvailabilitySearchIsPerformedAgainstTheBaseRateplanForCheckinDate(string checkinDate) { searchResults = availabilityManager.CheckAvailability(SetupAvailabilityCriteria(checkinDate, 1, baseRatePlanId)); }
public void TestCorrectMethodsAreCalledAndTranslationIsCorrectForCheckAvailability() { // Arrange const long BUSINESS_ID = 1; const string BUSINESS_NAME = "EVO"; const string CURRENCY = "GBP"; // Stub the BusinessCache to be used by our service method CacheHelper.StubBusinessCacheSingleBusiness(BUSINESS_ID, BUSINESS_NAME); // invalidate the cache so we make sure our business is loaded into the cache Cache.Business.Invalidate(); Cache.BusinessByShortName.Invalidate(); OnlineAvailabilitySearchCriteriaDto searchCriteriaSent = new OnlineAvailabilitySearchCriteriaDto { BusinessShortNames = new List<string> { BUSINESS_NAME }, StartDate = new CalendarDateDto { Year = DateTime.Now.Year, Day = DateTime.Now.Day, Month = DateTime.Now.Month }, EndDate = new CalendarDateDto { Year = DateTime.Now.Year, Day = DateTime.Now.Day, Month = DateTime.Now.Month + 1 }, RoomSearchCriteria = new List<OnlineRoomRestrictionsDto> { new OnlineRoomRestrictionsDto { NumberOfAdults = 1, NumberOfChildren = 0 } }, CurrencyCode = CURRENCY }; AvailabilitySearchResult mockResult = new AvailabilitySearchResult { BusinessCandidates = new List<AvailabilityResultBusiness> { new AvailabilityResultBusiness { BusinessId = BUSINESS_ID, ShortName = BUSINESS_NAME, RoomTypes = new List<AvailabilityResultRoomType> { new AvailabilityResultRoomType { BusinessId = BUSINESS_ID, UnAvailabilityReasonCode = UnavailabilityReasonCode.CheckInNotPossible, RatesAndRoomsAvailable = new List<RoomsAvailability> () }, new AvailabilityResultRoomType { BusinessId = BUSINESS_ID, UnAvailabilityReasonCode = UnavailabilityReasonCode.MaxOccupancyExceeded, RatesAndRoomsAvailable = new List<RoomsAvailability> () } } } } }; mockAvailabilityManager.Expect(m => m.CheckOnlineAvailability(Arg<Model.Room.Online.AvailabilitySearchCriteria>.Matches( asc => asc.StartDate.Day == searchCriteriaSent.StartDate.Day && asc.StartDate.Month == searchCriteriaSent.StartDate.Month && asc.StartDate.Year == searchCriteriaSent.StartDate.Year && asc.EndDate.Day == searchCriteriaSent.EndDate.Day && asc.EndDate.Month == searchCriteriaSent.EndDate.Month && asc.EndDate.Year == searchCriteriaSent.EndDate.Year && asc.RoomSearchCriteria[0].NumberOfAdults == searchCriteriaSent.RoomSearchCriteria[0].NumberOfAdults && asc.RoomSearchCriteria[0].NumberOfChildren == searchCriteriaSent.RoomSearchCriteria[0].NumberOfChildren && asc.BusinessShortNames[0] == searchCriteriaSent.BusinessShortNames[0]))).Return(mockResult).Repeat.Once(); // Act OnlineAvailabilitySearchResultDto searchResults = onlineAvailabilitySearchService.CheckOnlineAvailability(searchCriteriaSent).FirstOrDefault(); // Assert mockAvailabilityManager.VerifyAllExpectations(); Assert.IsNotNull(searchResults.BusinessCandidates, "businesses should still have been returned"); Assert.AreEqual(1, searchResults.BusinessCandidates[0].NoAvailabilityReasons.Count, "reasons weren't accumulated for the business"); Assert.IsTrue(searchResults.BusinessCandidates[0].NoAvailabilityReasons.Contains(UnavailabilityReasonCodeDto.NoInventory), "No Inventory in this business"); CacheHelper.ReAssignBusinessDaoToBusinessCache(); }
/// <summary> /// Used to filter out unavailability reasons that the online search shouldn't return /// </summary> /// <param name="searchResults">search results to filter</param> /// <returns>search results with unavailability reasons filtered and applied correctly</returns> internal AvailabilitySearchResult FilterSearchResultsForOnlineCheckAvailability(AvailabilitySearchResult searchResults) { // Filter out unavailability when no rate defined if (searchResults != null && searchResults.BusinessCandidates != null) { // If no results for a business after search, mark business as not available searchResults.BusinessCandidates.ForEach(bc => { if (bc.RoomTypes != null) { bc.RoomTypes.RemoveAll( rt => rt.UnAvailabilityReasonCode == UnavailabilityReasonCode.NoRateDefined); if (bc.RoomTypes == null || bc.RoomTypes.Count == 0) { bc.UnavailabilityReasonCode = UnavailabilityReasonCode.NoInventory; } } }); //If all rooms unavailable, and at least one has mlos not met 1.return unavailability code (MinStayCriteriaNotMet) searchResults.BusinessCandidates.ForEach(bc => { if (bc.RoomTypes != null) { if (bc.RoomTypes.Count(x => x.UnAvailabilityReasonCode != null) == bc.RoomTypes.Count && bc.RoomTypes.Count > 0) { if ( bc.RoomTypes.Any( x => x.UnAvailabilityReasonCode.Equals(UnavailabilityReasonCode.MinStayCriteriaNotMet))) { bc.UnavailabilityReasonCode = UnavailabilityReasonCode.MinStayCriteriaNotMet; } else if ( bc.RoomTypes.Any( x => x.UnAvailabilityReasonCode.Equals( UnavailabilityReasonCode.CheckInNotPossible))) { bc.UnavailabilityReasonCode = UnavailabilityReasonCode.CheckInNotPossible; } else { bc.UnavailabilityReasonCode = bc.RoomTypes.OrderBy(x => x.UnAvailabilityReasonCode) .FirstOrDefault() .UnAvailabilityReasonCode; } } } }); } //Apply above rules at business level if (searchResults.BusinessCandidates.TrueForAll(bc => bc.UnavailabilityReasonCode != null)) { if (searchResults.BusinessCandidates.Count(x => x.UnavailabilityReasonCode != null) == searchResults.BusinessCandidates.Count) { if (searchResults.BusinessCandidates.Any(x => x.UnavailabilityReasonCode.Equals(UnavailabilityReasonCode.MinStayCriteriaNotMet))) { searchResults.UnavailabilityReasonCode = UnavailabilityReasonCode.MinStayCriteriaNotMet; } else if (searchResults.BusinessCandidates.Any(x => x.UnavailabilityReasonCode.Equals(UnavailabilityReasonCode.CheckInNotPossible))) { searchResults.UnavailabilityReasonCode = UnavailabilityReasonCode.CheckInNotPossible; } else if (searchResults.BusinessCandidates.TrueForAll(x => x.UnavailabilityReasonCode.Equals(UnavailabilityReasonCode.NoInventory))) { searchResults.UnavailabilityReasonCode = UnavailabilityReasonCode.NoInventory; } else { searchResults.UnavailabilityReasonCode = searchResults.GetFirstUnavailabilityReasonCodeIfPresent(); } } } return searchResults; }
public void CheckSearchCriteriaIsCorrectlyMapped() { // Arrange const int BUSINESS_ID = 101; var stubAvailabilityManager = MockRepository.GenerateStub<IAvailabilityManager>(); var resultToReturn = new AvailabilitySearchResult { StartDate = new CalendarDate { Day = 3, Month = 3, Year = 2030 }, EndDate = new CalendarDate { Day = 4, Month = 3, Year = 2030 }, NoOfAdults = 2, NoOfChildren = null, BusinessCandidates = new List<AvailabilityResultBusiness> { new AvailabilityResultBusiness { BusinessId = BUSINESS_ID } } }; resultToReturn.BusinessCandidates[0].RoomTypes = new List<AvailabilityResultRoomType> { new AvailabilityResultRoomType { BusinessId = BUSINESS_ID, RoomTypeCode = "ABC123", RoomTypeName = "ABC", RoomTypeId = 6 } }; resultToReturn.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable = new List<RoomsAvailability> { new RoomsAvailability { RatePlanId = 1, RoomTypeId = 6, RoomList = new List<int> {1, 2} } }; // Stub the BusinessCache to be used by our service method CacheHelper.StubBusinessCacheSingleBusiness(BUSINESS_ID); // invalidate the cache so we make sure our business is loaded into the cache Cache.Business.Invalidate(); stubAvailabilityManager.Stub(m => m.CheckAvailability(Arg<AvailabilitySearchCriteria>.Is.Anything)). Return(resultToReturn); PropertyManagementSystemService.AvailabilityManager = stubAvailabilityManager; // Act AvailabilitySearchResultDto result = PropertyManagementSystemService.CheckAvailability(101, new AvailabilitySearchCriteriaDto()); // Assert Assert.AreEqual(2030, result.StartDate.Year, "Check startdate year is correct"); Assert.AreEqual(3, result.StartDate.Month, "Check startdate month is correct"); Assert.AreEqual(3, result.StartDate.Day, "Check startdate day is correct"); Assert.AreEqual(2030, result.EndDate.Year, "Check endDate year is correct"); Assert.AreEqual(3, result.EndDate.Month, "Check endDate month is correct"); Assert.AreEqual(4, result.EndDate.Day, "Check endDate day is correct"); Assert.AreEqual(2, result.NoOfAdults, "Check number of adults returned is correct"); Assert.IsNull(result.NoOfChildren, "Check number of children returned is correct"); Assert.AreEqual(BUSINESS_ID, result.BusinessCandidates[0].BusinessId, "Check the business Id is populated correctly"); Assert.AreEqual(1, result.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable[0].RoomList[0], "Check the rooms are correctly returned"); Assert.AreEqual(2, result.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable[0].RoomList[1], "Check the rooms are correctly returned"); Assert.AreEqual(BUSINESS_ID, result.BusinessCandidates[0].RoomTypes[0].BusinessId, "Check the business id are correctly returned for the roomType"); Assert.AreEqual(6, result.BusinessCandidates[0].RoomTypes[0].RoomTypeId, "Check the roomType id are correctly returned for the roomType"); Assert.AreEqual(1, result.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable[0].RatePlanId, "Check the rateplan id are correctly returned for the rateplan"); // Reassign the Dao on the cache to discard the stub assigned on the StubBusinessCacheSingleBusiness method CacheHelper.ReAssignBusinessDaoToBusinessCache(); }
public void WhenAnAvailabilitySearchIsPerformedForTheHotelForCheckinDateForNights(string checkinDate, int numberOfNights) { searchResults = availabilityManager.CheckAvailability(SetupAvailabilityCriteria(checkinDate, numberOfNights)); }
public void CheckAdditionalRatePlanAvailabilityByOccupancyIsSuccessful() { // Arrange const int BUSINESS_ID = 1; var availabilityManager = MockRepository.GenerateStub<IAvailabilityManager>(); var resultToReturn = new AvailabilitySearchResult { StartDate = new CalendarDate { Day = DateTime.UtcNow.Day, Month = DateTime.UtcNow.Month, Year = DateTime.UtcNow.Year }, EndDate = new CalendarDate { Day = DateTime.UtcNow.AddDays(1).Day, Month = DateTime.UtcNow.AddDays(1).Month, Year = DateTime.UtcNow.AddDays(1).Year }, NoOfAdults = 2, NoOfChildren = null, BusinessCandidates = new List<AvailabilityResultBusiness> { new AvailabilityResultBusiness { BusinessId = BUSINESS_ID } }, }; resultToReturn.BusinessCandidates[0].RoomTypes = new List<AvailabilityResultRoomType> { new AvailabilityResultRoomType { BusinessId = BUSINESS_ID, RoomTypeCode = "R1", RoomTypeName = "Double Room", RoomTypeId = 6 } }; resultToReturn.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable = new List<RoomsAvailability> { new RoomsAvailability { RatePlanId = 1, RoomTypeId = 6, RoomList = new List<int> {1, 2} } }; // Stub the BusinessCache to be used by our service method CacheHelper.StubBusinessCacheSingleBusiness(BUSINESS_ID); // invalidate the cache so we make sure our business is loaded into the cache Cache.Business.Invalidate(); availabilityManager.Stub(m => m.CheckAvailability(Arg<AvailabilitySearchCriteria>.Is.Anything)).Return( resultToReturn); PropertyManagementSystemService.AvailabilityManager = availabilityManager; // Act AvailabilitySearchResultDto availabilitySearchResult = PropertyManagementSystemService.CheckAvailability(BUSINESS_ID, new AvailabilitySearchCriteriaDto()); // Assert Assert.AreEqual(BUSINESS_ID, availabilitySearchResult.BusinessCandidates[0].BusinessId, "Check the businessId has been correctly set"); Assert.AreEqual(1, availabilitySearchResult.BusinessCandidates[0].RoomTypes.Count, "Number Of RoomTypesRatesAndRoomsAvailable returned is incorrect."); Assert.AreEqual(6, availabilitySearchResult.BusinessCandidates[0].RoomTypes[0].RoomTypeId, "RoomType Id retrieved is incorrect."); Assert.IsNotNull(availabilitySearchResult.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable, "RatesAndRoomsAvailable are not retrieved for roomType."); RoomsAvailabilityDto additionalRateplan = availabilitySearchResult.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable[0]; Assert.AreEqual(1, additionalRateplan.RatePlanId, "Rateplan id retrieved is incorrect."); }
/// <summary> /// Used to check two searches match /// </summary> /// <param name="firstSearchResult">search where results are correct</param> /// <param name="secondSearchResult">search that is being checked</param> /// <returns>true if successful</returns> private void CheckSearchResultsMatch(AvailabilitySearchResult firstSearchResult, AvailabilitySearchResult secondSearchResult) { Assert.AreEqual(firstSearchResult.BusinessCandidates.Count, secondSearchResult.BusinessCandidates.Count, "Number of businesses were different"); Assert.AreEqual(firstSearchResult.BusinessCandidates[0].BusinessId, secondSearchResult.BusinessCandidates[0].BusinessId, "Business returned was not the same"); Assert.AreEqual(firstSearchResult.BusinessCandidates[0].RoomTypes.Count, secondSearchResult.BusinessCandidates[0].RoomTypes.Count, "Number of room types returned did not match"); Assert.AreEqual(firstSearchResult.BusinessCandidates[0].RoomTypes[0].RoomTypeId, secondSearchResult.BusinessCandidates[0].RoomTypes[0].RoomTypeId, "Room type Id didn't match"); Assert.AreEqual(firstSearchResult.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable.Count, secondSearchResult.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable.Count, "Number of rate plans returned was different"); Assert.AreEqual(firstSearchResult.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable[0].RoomList.Count, secondSearchResult.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable[0].RoomList.Count, "Number of rooms returned did not match"); Assert.AreEqual(firstSearchResult.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable[0].RoomList[0], secondSearchResult.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable[0].RoomList[0], "Room Id did not match expected room id"); Assert.AreEqual(firstSearchResult.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable[0].RatePlanId, secondSearchResult.BusinessCandidates[0].RoomTypes[0].RatesAndRoomsAvailable[0].RatePlanId, "Rate plan Id did not match"); }
public void CheckIfNoAvailabilityReasonCodeIsReturnedIfThereIsUnavailabilityIsSuccessful() { // Arrange const int BUSINESS_ID = 1; var availabilityManager = MockRepository.GenerateStub<IAvailabilityManager>(); var resultToReturn = new AvailabilitySearchResult { StartDate = new CalendarDate { Day = DateTime.UtcNow.Day, Month = DateTime.UtcNow.Month, Year = DateTime.UtcNow.Year }, EndDate = new CalendarDate { Day = DateTime.UtcNow.AddDays(1).Day, Month = DateTime.UtcNow.AddDays(1).Month, Year = DateTime.UtcNow.AddDays(1).Year }, NoOfAdults = 2, NoOfChildren = null, BusinessCandidates = null, UnavailabilityReasonCode = UnavailabilityReasonCode.NoInventory }; // Stub the BusinessCache to be used by our service method CacheHelper.StubBusinessCacheSingleBusiness(BUSINESS_ID); // invalidate the cache so we make sure our business is loaded into the cache Cache.Business.Invalidate(); availabilityManager.Stub(m => m.CheckAvailability(Arg<AvailabilitySearchCriteria>.Is.Anything)).Return( resultToReturn); PropertyManagementSystemService.AvailabilityManager = availabilityManager; // Act AvailabilitySearchResultDto availabilitySearchResult = PropertyManagementSystemService.CheckAvailability(BUSINESS_ID, new AvailabilitySearchCriteriaDto ()); // Assert Assert.IsNull(availabilitySearchResult.BusinessCandidates, "Business Candidates should be null."); Assert.IsNotNull(availabilitySearchResult.UnavailabilityReasonCode, "UnAvailabilityReasonCode is null."); Assert.AreEqual(UnavailabilityReasonCodeDto.NoInventory, availabilitySearchResult.UnavailabilityReasonCode, "Reason code returned is incorrect."); }
/// <summary> /// Convert the AvailabilitySearchResult Date Model to the Dto Object /// </summary> /// <param name="availabilitySearchResult">AvailabilitySearchResult to convert</param> /// <returns>AvailabilitySearchResultDto</returns> public static AvailabilitySearchResultDto ConvertAvailabilitySearchResultToDto(AvailabilitySearchResult availabilitySearchResult) { // Convert the main object var availabilitySearchResultDto = new AvailabilitySearchResultDto { StartDate = ConvertCalendarDateToDto(availabilitySearchResult.StartDate), EndDate = ConvertCalendarDateToDto(availabilitySearchResult.EndDate), NoOfAdults = availabilitySearchResult.NoOfAdults, NoOfChildren = availabilitySearchResult.NoOfChildren }; if (availabilitySearchResult.BusinessCandidates != null) { // Convert the sub objects availabilitySearchResultDto.BusinessCandidates = availabilitySearchResult.BusinessCandidates.ConvertAll(ConvertAvailabilityResultBusinessToDto); } availabilitySearchResultDto.UnavailabilityReasonCode = (UnavailabilityReasonCodeDto?)availabilitySearchResult.UnavailabilityReasonCode; return availabilitySearchResultDto; }