public static List <CancellationRule> GetCancelFromDB(string sid, string HotelCode, string roomcode, string pid)
{
try
{
List <CancelPolicy> cancelPolicies = new List <CancelPolicy>();
List <CancellationRule> cancellationRules = new List <CancellationRule>();
SearchDBEntities searchDB = new SearchDBEntities();
using (HotelBookingDBEntities db = new HotelBookingDBEntities())
{
cancelPolicies = db.CancelPolicies.Where(a => a.Sid == sid && a.HotelCode == HotelCode && a.RoomCode.ToString() == roomcode && a.ProviderID == pid).ToList();
}
if (cancelPolicies.Count > 0)
{
var searchData = searchDB.SearchCriterias.FirstOrDefault(x => x.sID == sid);
foreach (var item in cancelPolicies)
{
CancellationRule cancellation = new CancellationRule();
cancellation.FromDate = item.FromDate.ToString();
cancellation.Price = (double)item.SellPrice.Value;
cancellation.CanellationRuleText = searchData.language.ToLower() == "en" ? item.SellPrice.Value + " " + searchData.currency + " of the booking amount " + item.FromDate.Value.ToString("MMMM dd, yyyy") : item.FromDate.Value.ToString("MMMM dd, yyyy") + " إلى " + "" + searchData.currency + item.SellPrice;
cancellationRules.Add(cancellation);
}
return(cancellationRules);
}
return(new List <CancellationRule>());
}
catch (Exception ex)
{
LoggingHelper.WriteToFile("AvailabilityController/Errors/", "getcancelpolicy" + "INDAL" + sid, ex.InnerException?.Message, ex.Message + ex.StackTrace);
return(new List <CancellationRule>());
}
}
public void CancellationRule_UtcNow_NotReturningUtcNow()
{
DateTime now = DateTime.Now.AddDays(2);
CancellationRule cxl = new CancellationRule(10.2m, now);
Assert.AreNotEqual(now, cxl.UtcNow);
}
public void CancellationRule_Now_ReturnsNow()
{
DateTime now = DateTime.Now.AddDays(2);
CancellationRule cxl = new CancellationRule(10.2m, now);
Assert.AreEqual(now, cxl.Now);
}
/// <summary>
/// Возвращает точку отсчёта (дату и время) для правила отмены
/// </summary>
/// <param name="cancellationRule">Правило отмены</param>
/// <param name="provider">Провайдер</param>
/// <param name="guestArrivalDateTime">Дата и время заезда гостя</param>
/// <param name="bookingCreationTimeLocalForProvider">Локальное для провайдера время бронирования</param>
/// <returns>Точка отсчёта для правила отмены</returns>
public static DateTime GetReferencePointDateTimeForCancellationRule(
CancellationRule cancellationRule,
Provider provider,
DateTime guestArrivalDateTime,
TimeSpan bookingCreationTimeLocalForProvider)
{
Time referencePointTime = GetReferencePointTimeForCancellationRule(
cancellationRule,
provider,
guestArrivalDateTime.TimeOfDay.ToTime(),
bookingCreationTimeLocalForProvider.ToTime());
return(guestArrivalDateTime.Date.AddTime(referencePointTime));
}
/// <summary>
/// Возвращает точку отсчёта (дату и время) для правила отмены из брони
/// </summary>
/// <param name="bookingCancellationRule">Правило отмены</param>
/// <param name="guestArrivalDateTime">Дата и время заезда гостя</param>
/// <param name="bookingCreationTimeLocalForProvider">Локальное для провайдера время бронирования гостем</param>
/// <returns>Точка отсчёта для правила отмены из брони</returns>
public static DateTime GetReferencePointDateTimeForBookingCancellationRule(
CancellationRule bookingCancellationRule,
DateTime guestArrivalDateTime,
TimeSpan bookingCreationTimeLocalForProvider)
{
Time guestArrivalTime = guestArrivalDateTime.TimeOfDay.ToTime();
Time referencePointTime = GetReferencePointTimeForBookingCancellationRule(
bookingCancellationRule.ReferencePointKind,
bookingCancellationRule.ReferencePointTime,
guestArrivalTime,
bookingCreationTimeLocalForProvider.ToTime());
return(guestArrivalDateTime.Date.AddTime(referencePointTime));
}
public void CancellationRule_Today_ReturnRightFormat()
{
// Arrange
CancellationRule cxl = new CancellationRule(10.2m, DateTime.Now);
DateTime dateValue;
// Act
bool isRightFormat = DateTime.TryParseExact(
cxl.Today.ToString(),
"yyyy-MM-dd",
null,
DateTimeStyles.None, out dateValue);
// Assert
Assert.IsTrue(isRightFormat);
}
public void WhenTheCancellationServiceGetsRatePlanPolicy()
{
actualCancellationType =
CancelationPolicyManager.GetRatePlanCancellationRule(new RatePlanCancellationRuleRequest
{
RatePlanCancellationRule = new RatePlanCancellationRule
{
CancellationClass = cancellationClass
},
StandardCancellationRule = new CancellationRule
{
CancellationType = standardCancellationType
},
CancellationScenario = this.CancellationPolicyScenario,
ChannelSupportsCustomCancellationPolicy = channelCustomCancellationSupport
});
}
public decimal Calculate(CancellationRule cancellationRule)
{
decimal penalty = 0;
List <CancellationRuleCondition> cancellationRuleConditions = GetActiveCancellationRuleConditions(cancellationRule.Id, DateTime.Now);
CancellationRuleConditionPenaltyCalculator cancellationRuleConditionPenaltyCalculator = new CancellationRuleConditionPenaltyCalculator(_maxCancellationBeforeArrivalValue, _logger);
foreach (CancellationRuleCondition cancellationRuleCondition in cancellationRuleConditions)
{
if (cancellationRuleCondition.PenaltyCalcMode != CancellationPenaltyCalcMode.NoPenalty)
{
penalty += cancellationRuleConditionPenaltyCalculator.Calculate(cancellationRuleCondition, _avgBooking);
}
}
return(penalty);
}
static BaseCancellationPolicySteps()
{
var mockedDictionary = new Mock<IDictionaryDao>();
mockedDictionary.Setup(m => m.GetItemByKey(It.IsAny<string>(), It.IsAny<string>()))
.Returns<string, string>((key, culture) => string.Format("[{0}]", key));
CancelationPolicyManager.DictionaryDao = mockedDictionary.Object;
var defaultCancellationRule = new CancellationRule
{
CancellationWindowHours = 48,
CancellationType = CancellationTypeEnum.WindowedCharge,
CancellationChargeType = CancellationChargeTypeEnum.FirstNight
};
var mockedCancellationPolicyDao = new Mock<ICancellationPolicyDao>();
mockedCancellationPolicyDao.Setup(m => m.GetDefaultCancellationRule())
.Returns(defaultCancellationRule);
CancelationPolicyManager.CancellationPolicyDao = mockedCancellationPolicyDao.Object;
}
/// <summary>
/// Возвращает точку отсчёта (время) для правила отмены
/// </summary>
/// <param name="cancellationRule">Правило отмены</param>
/// <param name="provider">Провайдер</param>
/// <param name="guestArrivalTime">Время заезда гостя</param>
/// <param name="bookingCreationTimeLocalForProvider">Локальное для провайдера время бронирования</param>
/// <returns>Точка отсчёта для правила отмены</returns>
public static Time GetReferencePointTimeForCancellationRule(
CancellationRule cancellationRule,
Provider provider,
Time guestArrivalTime,
Time bookingCreationTimeLocalForProvider)
{
if (cancellationRule == null)
{
throw new ArgumentNullException("cancellationRule");
}
if (provider == null)
{
throw new ArgumentNullException("provider");
}
switch (cancellationRule.ReferencePointKind)
{
case CancellationReferencePointKind.ProviderArrivalTime:
return(provider.ArrivalTime);
case CancellationReferencePointKind.ProviderDepartureTime:
return(provider.DepartureTime);
case CancellationReferencePointKind.GuestArrivalTime:
return(guestArrivalTime);
case CancellationReferencePointKind.CustomArrivalTime:
return(cancellationRule.ReferencePointTime);
case CancellationReferencePointKind.BookingCreationTime:
return(bookingCreationTimeLocalForProvider);
}
throw new ArgumentOutOfRangeException("cancellationRule.ReferencePointKind", "Invalid ReferencePointKind value");
}
public decimal Calculate(CancellationRule cancellationRule)
{
decimal penalty = 0;
if (CheckForNotEnabledSpecialOffers(cancellationRule))
{
_logger.Warning($"CheckForNotEnabledSpecialOffers");
return(penalty);
}
if (cancellationRule.DisplayStatus == CancellationRuleDisplayStatus.None)
{
_logger.Warning($"CancellationRuleDisplayStatus.None");
return(penalty);
}
List <CancellationRuleCondition> cancellationRuleConditions = GetActiveCancellationRuleConditions(cancellationRule.Id, DateTime.Now);
// int maxCancellationBeforeArrivalValue = Math.Max(cancellationRuleConditions.Max(condition => condition.CancellationBeforeArrivalUnit == TimeUnit.Day ? condition.CancellationBeforeArrivalValue * 24 : condition.CancellationBeforeArrivalValue ), cancellationRuleConditions.Max(condition => condition.CancellationBeforeArrivalUnit == TimeUnit.Day ? condition.CancellationBeforeArrivalValueMax * 24 : condition.CancellationBeforeArrivalValueMax ) );
// _logger.Info($"\tMaxCancellationBeforeArrivalValue={maxCancellationBeforeArrivalValue}" );
CancellationRuleConditionPenaltyCalculator cancellationRuleConditionPenaltyCalculator = new CancellationRuleConditionPenaltyCalculator(_maxCancellationBeforeArrivalValue, _logger);
foreach (CancellationRuleCondition cancellationRuleCondition in cancellationRuleConditions)
{
if (cancellationRuleCondition.PenaltyCalcMode != CancellationPenaltyCalcMode.NoPenalty
// && cancellationRuleConditionPenaltyCalculator.IsConditionActualForDate( cancellationRuleCondition, now, referencePointDateTime )
)
{
penalty += cancellationRuleConditionPenaltyCalculator.Calculate(cancellationRuleCondition, _avgBooking);
}
}
penalty = penalty / cancellationRuleConditions.Count;
_logger.Info($"\tCancellationRule penalty={penalty}");
return(penalty);
}
public IHttpActionResult Get(string sid, string hotel, string Pid, string rooms)
{
// call bll
try
{
LoggingHelper.WriteToFile("HotelRoomsController/GetRoomsNumber/", "SearchController" + "INController" + sid, "Rooms", "Sid" + sid);
var Rooms = GetRoom.GetRoomsData(sid, hotel, Pid, rooms);
if (Rooms != null && Rooms.rooms.Count > 0)
{
#region tbo disable to not calling pricing api
if (Pid == "5")
{
// var ActionUrlData = ConfigurationSettings.AppSettings["ActionUrl"];
// var BaseCur = ConfigurationSettings.AppSettings["BaseCur"];
//payLinkData.ActionsUrl.ValidationUrl = ActionUrlData + "/api/HotelCheckAvailability?sid=" + Sid + "&bookingnum=" + BN;
SearchDBEntities searchDB = new SearchDBEntities();
RequiredBookingData requiredBooking = new RequiredBookingData();
//var data = searchDB.SearchCriterias.FirstOrDefault(a => a.sID == sid);
var HRooms = searchDB.SearchRoomResults.Where(a => a.sID == sid && a.HotelCode == hotel && a.ProviderId.ToString() == Pid).ToList();
//requiredBooking.Currency = data?.currency;
//requiredBooking.City = data?.cityName;
var RoomsCode = rooms.Split('-');
foreach (var item in RoomsCode)
{
var roomdata = HRooms.FirstOrDefault(a => a.RoomCode == item);
requiredBooking.rooms.Add(roomdata);
}
//TBO
//call check availability tbo to get hotel norms and cancel policy
//get room indexes to send in pricing req
List <int> indexs = new List <int>();
foreach (var indx in requiredBooking.rooms)
{
indexs.Add(int.Parse(indx.RoomCode));
}
string TBOSession = searchDB.ProviderSessions.FirstOrDefault(ps => ps.SearchId == sid).PSession; //Select(s => s.PSession).ToString();
int ResIndex = int.Parse(searchDB.SearchHotelResults.FirstOrDefault(hotl => hotl.sID == sid && hotl.HotelCode == hotel).ResIndex.ToString()); //Select(indx => indx.ResIndex).ToString();
AvailabilityAndPricingRequest req = new AvailabilityAndPricingRequest
{
SessionId = TBOSession,
ResultIndex = ResIndex,
OptionsForBooking = new TBO.WSDL.hotelServiceRef.BookingOptions
{
RoomCombination = new TBO.WSDL.hotelServiceRef.RoomCombination[]
{
new TBO.WSDL.hotelServiceRef.RoomCombination {
RoomIndex = indexs.ToArray()
}
}
}
};
var availRes = AvailablityPricingService.PricingService(req, sid);
RoomResult roomResult = new RoomResult();
if (availRes != null)
{
if (availRes?.PriceVerification?.Status == PriceVerificationStatus.Failed ||
availRes?.PriceVerification?.Status == PriceVerificationStatus.NotAvailable)
{
return(Ok("No Result Found"));
}
if (availRes.HotelCancellationPolicies != null)
{
roomResult.HotelNorms = availRes.HotelCancellationPolicies?.HotelNorms;
//handel cancel policy
var BaseCur = ConfigurationSettings.AppSettings["BaseCur"];
CurrencyManager currencyManager = new CurrencyManager();
double ProviderExcahngeRate = currencyManager.GetCurrencyConversion("USD", BaseCur, sid);
foreach (var cancel in availRes.HotelCancellationPolicies?.CancelPolicies?.CancelPolicy)
{
double costToSave = 0;
string Cur = "";
//Enum.TryParse(cancel.ChargeType.ToString(), out CancellationChargeTypeForHotel Type);
if (cancel.ChargeType == CancellationChargeTypeForHotel.Percentage)
{
costToSave = (double)cancel.CancellationCharge;
Cur = "%";
}
else
{
Cur = "KWD";
costToSave = (double)cancel.CancellationCharge * ProviderExcahngeRate; //Math.Round((double)cancel.CancellationCharge * ProviderExcahngeRate, 3);
}
CancellationRule cancellation = new CancellationRule();
cancellation.FromDate = cancel.FromDate;
cancellation.ToDate = cancel.ToDate;
cancellation.Cost = (double)cancel.CancellationCharge;
cancellation.ChargeType = cancel.ChargeType.ToString();
cancellation.Curency = Cur;
cancellation.Price = costToSave; //
roomResult.cancellationRules.Add(cancellation);
}
if (availRes?.PriceVerification?.PriceChanged == true)
{
//var roomsTbo = searchDB.SearchRoomResults.Where(a => a.sID == sid && a.HotelCode == hotel && a.ProviderId.ToString() == Pid).ToList();
Rooms.Status = 1;
Rooms.Message = "Price Change";
//results.Status = 1;
foreach (var item in availRes?.PriceVerification.HotelRooms)
{
roomResult.TotalSellPrice = Math.Round((double)item.RoomRate.TotalFare * ProviderExcahngeRate, 3);
roomResult.CostPrice = (double)item.RoomRate.TotalFare;
//results.TotalCost += roomResult.TotalSellPrice; //Math.Round((double)item.RoomRate.TotalFare * ProviderExcahngeRate, 3);
roomResult.RoomIndex = item.RoomIndex;
//results.Result.Add(roomResult);
//update Rooms obj with new price
Rooms.rooms.FirstOrDefault(r => r.RoomCode == item.RoomIndex.ToString()).costPrice = (double)item.RoomRate.TotalFare;
Rooms.rooms.FirstOrDefault(r => r.RoomCode == item.RoomIndex.ToString()).SellPrice = Math.Round((double)item.RoomRate.TotalFare * ProviderExcahngeRate, 3);
// update price in search db
// update tbo new rooms prices
SearchRoomResult Newroom = new SearchRoomResult();
Newroom = searchDB.SearchRoomResults.FirstOrDefault(room => room.sID == sid && room.RoomCode == item.RoomIndex.ToString());
Newroom.costPrice = (double)item.RoomRate.TotalFare;
Newroom.rateClass = item.RoomRate.RoomFare.ToString();
Newroom.rateType = item.RoomRate.RoomTax.ToString();
Newroom.SellPrice = roomResult.TotalSellPrice;
searchDB.SaveChanges();
}
}
else
{
Rooms.Status = 0;
Rooms.Message = "No Price Change";
}
Rooms.TBoRooms.Add(roomResult);
}
}
#endregion
LoggingHelper.WriteToFile("HotelRoomsController/GetRoomsOFHotel/", "SearchController" + "OutController" + sid, "RoomsResult", JsonConvert.SerializeObject(Rooms));
return(Ok(Rooms));
}
}
return(Ok("No Result Found"));
}
catch (Exception ex)
{
LoggingHelper.WriteToFile("HotelRoomsController/Errors/", "SearchController" + "INController" + sid, "Exception", ex.InnerException?.Message + ex.Message + ex.StackTrace);
return(BadRequest(ex.Message));
}
}
public void GivenTheOptInCustomCancellationRuleExists()
{
optInCancellationRule = new CancellationRule();
}
public void WhenTheCancellationPolicyIsDetermined()
{
var cancellationRuleRequest = new CancellationRuleRequest
{
ProviderCancellationRule = providerCancellationRule,
ChannelCancellationRule = channelCancellationRule,
OptInCancellationRule = optInCancellationRule,
CancellationPolicyScenario = CancellationPolicyScenario
};
actualCancellationRule = CancelationPolicyManager.GetCancellationRule(cancellationRuleRequest);
}
public ConfirmationModel GetConfirmationData(string sid, string BN)
{
try
{
ConfirmationModel confirmationModel = new ConfirmationModel();
HotelBookingDBEntities BookingDB = new HotelBookingDBEntities();
SearchDBEntities searchDB = new SearchDBEntities();
hotelsDBEntities hotelsDB = new hotelsDBEntities();
HotelBedEntity HBDB = new HotelBedEntity();
List <SearchRoomResult> searchRoomResults = new List <SearchRoomResult>();
List <SearchRoomResult> SelectedRooms = new List <SearchRoomResult>();
var BookingData = BookingDB.HotelsBookings.FirstOrDefault(a => a.SessionId == sid && a.Booking_No == BN);
var Paxes = BookingDB.HotelBookingPaxs.Where(x => x.Booking_No == BN && x.SID == sid && x.PaxNo == 1);
var SearchData = searchDB.SearchCriterias.FirstOrDefault(a => a.sID == sid);
var RoomData = searchDB.SearchRoomDatas.Where(a => a.sID == sid).ToList();
var Rooms = Paxes.Select(x => x.RoomRef.ToString()).ToList();
foreach (var item in Rooms)
{
var roomsearch = searchDB.SearchRoomResults.FirstOrDefault(r => r.sID == sid && r.HotelCode == BookingData.Hotel_ID && r.RoomCode == item);
SelectedRooms.Add(roomsearch);
}
if (BookingData.Provider_ID == "4")
{
var hotelData = hotelsDB.hotels.FirstOrDefault(a => a.hotelID == BookingData.Hotel_ID);
var hotelDesc = hotelsDB.HotelsDescriptions.FirstOrDefault(a => a.hotelID == BookingData.Hotel_ID);
confirmationModel.hotel.HotelDescription = hotelDesc.Description1;
var hotelsImage = hotelsDB.HotelsImages.Where(a => a.HotelID == BookingData.Hotel_ID).ToList();
confirmationModel.hotel.City = hotelData.cityName;
confirmationModel.hotel.Country = hotelData.countryName;
confirmationModel.hotel.hotelCode = BookingData.Hotel_ID;
confirmationModel.hotel.hotelName = hotelData.hotelName;
confirmationModel.hotel.Address = hotelData.address;
confirmationModel.hotel.hotelStars = int.Parse(hotelData.rating);
if (hotelsImage.Count > 0)
{
confirmationModel.hotel.hotelThumb = hotelsImage[0].Thum;
}
confirmationModel.hotel.Location = hotelData.location;
}
else if (BookingData.Provider_ID == "5")
{
using (TBOContext tBOContext = new TBOContext())
{
var hotelData = tBOContext.HotelDetails.FirstOrDefault(a => a.HotelCode == BookingData.Hotel_ID);
var hotelDesc = hotelData.Description;
var hotelsImage = tBOContext.HotelImages.Where(a => a.HotelCode == BookingData.Hotel_ID).ToList();
confirmationModel.hotel.City = hotelData.CityName;
confirmationModel.hotel.Country = hotelData.CountryName;
confirmationModel.hotel.hotelCode = BookingData.Hotel_ID;
confirmationModel.hotel.hotelName = hotelData.HotelName;
confirmationModel.hotel.Address = hotelData.Address;
//confirmationModel.hotel.hotelStars = int.Parse(hotelData.rating);
if (hotelsImage.Count > 0)
{
confirmationModel.hotel.hotelThumb = hotelsImage[0].URL;
}
confirmationModel.hotel.Location = hotelData.HotelLocation;
}
}
confirmationModel.hotel.CheckIn = SearchData.dateFrom.Value.ToString();
confirmationModel.BookingTime = BookingData.Booking_Time.Value;
confirmationModel.hotel.CheckOut = SearchData.dateTo.Value.ToString();
confirmationModel.hotel.Paxes = BookingData.Pax_Qty.Value;
confirmationModel.hotel.Rooms = BookingData.Rooms_Qty.Value;
var PConfirm = BookingDB.BookingConfirmationDatas.FirstOrDefault(a => a.SessionID == sid && a.BookingNum == BN);
if (PConfirm != null)
{
confirmationModel.ProviderConfirmation = PConfirm.Reference;
}
confirmationModel.hotel.sellCurrency = BookingData.Sell_Currency;
confirmationModel.hotel.TotalSellPrice = BookingData.Sell_Price.Value;
confirmationModel.bookingNum = BookingData.Booking_No;
confirmationModel.mail = BookingData.Booking_Email;
confirmationModel.status = BookingData.Booking_Status;
CurrencyRepo repo = new CurrencyRepo();
double ExcahngeRate = repo.GetEveryDayCurrenciesConversion(SearchData.currency, BookingData.Sell_Currency, sid, DateTime.Now).Result.Customer_Sell_Rate;
foreach (var item in Paxes)
{
ConfirmedTraveller traveller = new ConfirmedTraveller();
traveller.FirstName = item.First_name;
traveller.LastName = item.Last_Name;
traveller.Title = item.Salutations;
var roomResult = SelectedRooms.FirstOrDefault(x => x.RoomCode == item.RoomRef.ToString());
searchRoomResults.Add(roomResult);
var specRoom1 = SelectedRooms.FirstOrDefault(s => s.RoomCode == item.RoomRef.ToString());
if (specRoom1.Childern != 0)
{
var specRoom = SelectedRooms.FirstOrDefault(s => s.RoomCode == item.RoomRef.ToString());
var childern = RoomData.Where(a => a.adultNo == specRoom.Adults && a.childernNo == specRoom.Childern).ToList();
if (childern.Count == 1)
{
var childages = childern[0].childAge.Split('-');
traveller.ChildAge.AddRange(childages.ToList());
}
else
{
var child = RoomData.FirstOrDefault(a => a.adultNo == specRoom.Adults && a.childernNo == specRoom.Childern && a.roomNo == item.RoomRef);
var childages = child.childAge.Split('-');
traveller.ChildAge.AddRange(childages.ToList());
}
}
confirmationModel.travellers.Add(traveller);
}
foreach (var item in searchRoomResults)
{
ConfirmedRoom confirmedRoom = new ConfirmedRoom();
if (BookingData.Provider_ID == "5")
{
var roomNo = int.Parse(item.RoomCode);
confirmedRoom.Adult = RoomData.FirstOrDefault(ad => ad.roomNo == roomNo).adultNo ?? default(int);
confirmedRoom.Child = RoomData.FirstOrDefault(ad => ad.roomNo == roomNo).childernNo ?? default(int);
}
else
{
confirmedRoom.Adult = item.Adults.Value;
confirmedRoom.Child = item.Childern.Value;
}
//var RoomsImage = hotelsImage.Where(a => a.Category.ToLower() == "hotel rooms").ToList();
//***************
//if (RoomsImage.Count > 0)
//{
//confirmedRoom.Image = RoomsImage[0].URL;
//}
confirmedRoom.IsRefundable = item.IsRefundable.Value;
confirmedRoom.Paxs = item.PaxSQty.Value;
confirmedRoom.RoomCode = item.RoomCode;
confirmedRoom.RoomMeal = item.meal;
confirmedRoom.RoomType = item.RoomName;
confirmedRoom.RateType = item.rateType;
List <CancelPolicy> cancelPolicies = new List <CancelPolicy>();
using (HotelBookingDBEntities db = new HotelBookingDBEntities())
{
cancelPolicies = db.CancelPolicies.Where(a => a.Sid == sid && a.HotelCode == BookingData.Hotel_ID && a.RoomCode.ToString() == item.RoomCode && a.ProviderID == BookingData.Provider_ID).ToList();
}
if (cancelPolicies.Count > 0)
{
foreach (var p in cancelPolicies)
{
CancellationRule cancellation = new CancellationRule();
cancellation.FromDate = p.FromDate.ToString();
if (BookingData.Sell_Currency == p.Currency)
{
cancellation.Price = (double)p.SellPrice.Value;
}
else
{
cancellation.Price = (double)p.SellPrice.Value * ExcahngeRate;
}
cancellation.CanellationRuleText = cancellation.Price + " " + BookingData.Sell_Currency + " From " + p.FromDate.Value.ToString("MMMM dd, yyyy");
confirmedRoom.cancellations.Add(cancellation);
}
}
confirmationModel.rooms.Add(confirmedRoom);
}
var ConfData = HBDB.BookingConfirmations.FirstOrDefault(a => a.BookingNum == BN);
if (ConfData != null)
{
confirmationModel.PayableNote = "Payable through " + ConfData.supplier + ", acting as agent for the service operating company, details of which can be provided upon request. VAT: " + ConfData.Remark + " Reference:" + ConfData.Reference;
}
return(confirmationModel);
}catch (Exception ex)
{
LoggingHelper.WriteToFile("ConfirmationController/ERROR/", "ConfirmationDAL" + "INDAL" + sid, "ConfirmData", "Sid is " + sid + " and Booking is" + BN + ex.InnerException?.Message + ex.Message + ex.StackTrace);
return(null);
}
}
private bool CheckForNotEnabledSpecialOffers(CancellationRule cancellationRule)
{
return(_specialOffers.Where(offer => offer.CancellationRuleId == cancellationRule.Id).All(offer => !offer.IsEnabled));
}
public void GivenTheOptInCustomCancellationRuleDoesNotExist()
{
optInCancellationRule = null;
}
public void CancellationRule_Today_ReturnBusinessDate()
{
CancellationRule cxl = new CancellationRule(10.2m, DateTime.Now);
Assert.IsInstanceOfType(cxl.Today, typeof(BusinessDate));
}
public void CancellationRule_Price_ReturnSameNumber()
{
CancellationRule cxl = new CancellationRule(10.2m, DateTime.Now);
Assert.AreEqual(10.2m, cxl.Price);
}
public void New_CancellationRule_IsIClockInstance()
{
CancellationRule cxl = CreateDefaultCancellationRule();
Assert.IsInstanceOfType(cxl, typeof(IClock));
}
