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;
}
