public void CreateVariantRatePlanPopulatesRatePlanId() { // Arrange // Create rate plan var variantRatePlan = new VariantRatePlan { Name = "Test", BusinessId = 1, RoomTypeId = 1, RatePlanType = new RatePlanType { Type = RatePlanTypeEnum.Variant }, MaxOccupancy = 2, MaxAdults = 2, MaxChildren = 1, BoardBasis = new EnumEntity { Code = BoardBasisTypeEnum.BreakfastIncluded.GetCode() }, CancellationClass = new EnumEntity { Code = CancellationClassTypeEnum.NoRefund.GetCode() }, CurrencyCode = "GBP", VariantAmount = 10, VariantType = new VariantType { Type = VariantTypeEnum.Amount }, ApplicableDays = "1111111" }; // Act variantRatePlanDao.Create(variantRatePlan); // Assert // Check if the rate plan id is attributed Assert.IsNotNull(variantRatePlan.Id, "The rate plan id was not attributed."); }
/// <summary> /// Map the basic fields for the VariantRatePlan table to the VariantRatePlan model object /// </summary> /// <param name="record">The SqlDataReader with the executed query result</param> /// <param name="prefix">a prefix used to identify fields for the VariantRatePlan model in the resultset if required</param> /// <returns>An instance of Model.Pricing.VariantRatePlan</returns> internal static VariantRatePlan MapRecord(IDataRecord record, string prefix = "") { var ratePlan = new VariantRatePlan(); RatePlanMapper.MapRecord(record, ratePlan, prefix); ratePlan.Name = DbHelper.ConvertValue<string>(record[prefix + Parameters.Name]); ratePlan.PeriodId = DbHelper.ConvertValue<int?>(record[prefix + Parameters.PeriodId]); ratePlan.MinStay = DbHelper.ConvertValue<int?>(record[prefix + Parameters.MinStay]); ratePlan.ApplicableDays = DbHelper.ConvertValue<string>(record[prefix + Parameters.ApplicableDays]); ratePlan.VariantType = VariantTypeMapper.MapRecord(record, Parameters.VariantType.ToString()); ratePlan.VariantAmount = DbHelper.ConvertValue<decimal>(record[prefix + Parameters.VariantAmount]); ratePlan.ApplyToAllPeriods = DbHelper.ConvertValue<bool>(record[prefix + Parameters.ApplyToAllPeriods]); ratePlan.VariantRatePlanRateId = DbHelper.ConvertValue<int>(record[prefix + Parameters.VariantRatePlanRateId]); ratePlan.Period = PeriodMapper.MapRecord(record, "Period"); return ratePlan; }
/// <summary> /// Set rates on variant rate plan /// </summary> /// <param name="varRate">RatePlanRate</param> /// <param name="variantRatePlan">VariantRatePlan</param> private void SetOccupantVariantRates(RatePlanRate varRate, VariantRatePlan variantRatePlan) { var variantType = variantRatePlan.VariantType.Type; var variantAmount = variantRatePlan.VariantAmount; varRate.MonRate = CalculateVariantRate(variantType, varRate.MonRate.HasValue ? varRate.MonRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[0], true); varRate.TueRate = CalculateVariantRate(variantType, varRate.TueRate.HasValue ? varRate.TueRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[1], true); varRate.WedRate = CalculateVariantRate(variantType, varRate.WedRate.HasValue ? varRate.WedRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[2], true); varRate.ThuRate = CalculateVariantRate(variantType, varRate.ThuRate.HasValue ? varRate.ThuRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[3], true); varRate.FriRate = CalculateVariantRate(variantType, varRate.FriRate.HasValue ? varRate.FriRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[4], true); varRate.SatRate = CalculateVariantRate(variantType, varRate.SatRate.HasValue ? varRate.SatRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[5], true); varRate.SunRate = CalculateVariantRate(variantType, varRate.SunRate.HasValue ? varRate.SunRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[6], true); variantRatePlan.Rates = varRate; }
/// <summary> /// Set rates on variant rate plan /// </summary> /// <param name="varRate">RatePlanRate</param> /// <param name="variantRatePlan">VariantRatePlan</param> private void SetVariantRates(RatePlanRate varRate, VariantRatePlan variantRatePlan) { var variantType = variantRatePlan.VariantType.Type; var variantAmount = variantRatePlan.VariantAmount; varRate.MonRate = CalculateVariantRate(variantType, varRate.MonRate.HasValue ? varRate.MonRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[0]); varRate.MonMinStay = variantRatePlan.MinStay.HasValue && varRate.MonRate.HasValue ? variantRatePlan.MinStay.Value : default(int); varRate.TueRate = CalculateVariantRate(variantType, varRate.TueRate.HasValue ? varRate.TueRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[1]); varRate.TueMinStay = variantRatePlan.MinStay.HasValue && varRate.TueRate.HasValue ? variantRatePlan.MinStay.Value : default(int); varRate.WedRate = CalculateVariantRate(variantType, varRate.WedRate.HasValue ? varRate.WedRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[2]); varRate.WedMinStay = variantRatePlan.MinStay.HasValue && varRate.WedRate.HasValue ? variantRatePlan.MinStay.Value : default(int); varRate.ThuRate = CalculateVariantRate(variantType, varRate.ThuRate.HasValue ? varRate.ThuRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[3]); varRate.ThuMinStay = variantRatePlan.MinStay.HasValue && varRate.ThuRate.HasValue ? variantRatePlan.MinStay.Value : default(int); varRate.FriRate = CalculateVariantRate(variantType, varRate.FriRate.HasValue ? varRate.FriRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[4]); varRate.FriMinStay = variantRatePlan.MinStay.HasValue && varRate.FriRate.HasValue ? variantRatePlan.MinStay.Value : default(int); varRate.SatRate = CalculateVariantRate(variantType, varRate.SatRate.HasValue ? varRate.SatRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[5]); varRate.SatMinStay = variantRatePlan.MinStay.HasValue && varRate.SatRate.HasValue ? variantRatePlan.MinStay.Value : default(int); varRate.SunRate = CalculateVariantRate(variantType, varRate.SunRate.HasValue ? varRate.SunRate.Value : 0, variantAmount, variantRatePlan.ApplicableDays[6]); varRate.SunMinStay = variantRatePlan.MinStay.HasValue && varRate.SunRate.HasValue ? variantRatePlan.MinStay.Value : default(int); variantRatePlan.Rates = varRate; }
/// <summary> /// Set the default period on a variant rate plan when the period is not set /// <param name="variantRatePlan">Culture Code</param> private void SetVariantDefaultPeriod(VariantRatePlan variantRatePlan, string cultureCode) { if (variantRatePlan.PeriodId == null) { variantRatePlan.Periods = new List<VariantRatePlanPeriod>() { new VariantRatePlanPeriod { Id = 0, Name = dictionaryDao.GetItemByKey(EVERGREEN_PERIOD_NAME, cultureCode) } }; } }
public void CreateRatePlanAsVariantPopulatesRatePlanId() { // Arrange // Create rate plan var ratePlan = new VariantRatePlan { BusinessId = 1, RatePlanType = new RatePlanType { Type = RatePlanTypeEnum.Variant } }; // Act ratePlanDao.Create(ratePlan); // Assert // Check if the rate plan id is attributed Assert.IsNotNull(ratePlan.Id, "The rate plan id was not attributed."); }
public void ModifyVariantRatePlanNoIdThrowsException() { // Arrange var businessEventDao = MockRepository.GenerateMock<IBusinessEventDao>(); var variantRatePlanDao = MockRepository.GenerateStrictMock<IVariantRatePlanDao>(); var mockOfRatePlanManager = MockRepository.GeneratePartialMock<RatePlanManager>(); mockOfRatePlanManager.BusinessEventDao = businessEventDao; mockOfRatePlanManager.VariantRatePlanDao = variantRatePlanDao; const int RATE_PLAN_ID = 1; const long BUSINESS_ID = 1; const int RATE_PLAN_RATE_ID = 5; mockOfRatePlanManager.Expect( rtm => rtm.ModifyRatePlanRates(Arg<RatePlanRate>.Matches(rpr => rpr.Id == RATE_PLAN_RATE_ID), Arg<bool>.Is.Anything)) .Return(new RatePlanRate { Id = RATE_PLAN_RATE_ID }) .Repeat.Never(); var ratePlan = new VariantRatePlan { BusinessId = BUSINESS_ID, RatePlanType = new RatePlanType { Type = RatePlanTypeEnum.Variant }, Rates = new RatePlanRate { Id = RATE_PLAN_RATE_ID } }; variantRatePlanDao.Expect(rp => rp.Modify(Arg<VariantRatePlan>.Matches(vpr => vpr.Id == RATE_PLAN_ID && vpr.BusinessId == BUSINESS_ID))).Repeat.Never(); businessEventDao.Expect(be => be.Create(Arg<BusinessEvent>.Matches(ev => ev.BusinessId == BUSINESS_ID && ev.EventType.Code == BusinessEventTypesEnum.RatePlanModified.GetCode() && ev.Reference == ratePlan.Id.ToString(CultureInfo.InvariantCulture)))).Repeat.Never(); try { // Act mockOfRatePlanManager.ModifyVariantRatePlan(ratePlan); // Assert Assert.Fail("Validation exception was not thrown"); } catch (ValidationException vex) { Assert.AreEqual(Errors.SRVEX30098.ToString(), vex.Code, "Incorrect validation exception was thrown"); variantRatePlanDao.VerifyAllExpectations(); businessEventDao.VerifyAllExpectations(); mockOfRatePlanManager.VerifyAllExpectations(); } }
/// <summary> /// Modify a particular variant rate plan /// </summary> /// <param name="ratePlan">Variant Rate plan</param> /// <returns>Modified rate plan</returns> public virtual VariantRatePlan ModifyVariantRatePlan(VariantRatePlan ratePlan) { if (ratePlan == null) { return null; } if (ratePlan.Id == default(int)) { // can't modify with bad id throw new ValidationException(ErrorFactory.CreateAndLogError(Errors.SRVEX30098, "RoomTypeManager.ModifyVariantRatePlan", arguments: new object[] { ratePlan })); } using (var tx = new BusinessTransaction()) { variantRatePlanDao.Modify(ratePlan); //modify rate plan rates for rate plan here. ratePlan.Rates = ModifyRatePlanRates(ratePlan.Rates, false); tx.Commit(); } // events will need data in future eventTrackingManager.CreateBusinessEventAsync(ratePlan.BusinessId, BusinessEventTypesEnum.VariantRatePlanModified, ratePlan.Id.ToString(CultureInfo.InvariantCulture)); // Invalidate the cache so it refreshes Cache.Cache.RatePlanViewCache.Invalidate(ratePlan.BusinessId); return ratePlan; }
/// <summary> /// Creates just the rates for a particular variant rate plan /// </summary> /// <param name="ratePlan">Rate plan</param> /// <returns>created rate plan with rates</returns> public VariantRatePlan CreateVariantRatePlanRate(VariantRatePlan ratePlan) { if (ratePlan == null) { return null; } using (var tx = new BusinessTransaction()) { variantRatePlanDao.CreateVariantRatePlanRate(ratePlan); tx.Commit(); } eventTrackingManager.CreateBusinessEventAsync(ratePlan.BusinessId, BusinessEventTypesEnum.VariantRatePlanRateAdded, ratePlan.VariantRatePlanRateId.ToString(CultureInfo.InvariantCulture)); return ratePlan; }
public void DeleteRatePlanExpectdVariantRatePlanRemoved() { // Arrange const long BUSINESS_ID = 1; var ratePlanToDelete = new VariantRatePlan { Name = "Test", BusinessId = BUSINESS_ID, RoomTypeId = 1, RatePlanType = new RatePlanType { Type = RatePlanTypeEnum.Variant }, MaxOccupancy = 2, MaxAdults = 2, MaxChildren = 1, BoardBasis = new EnumEntity { Code = BoardBasisTypeEnum.BreakfastIncluded.GetCode() }, CancellationClass = new EnumEntity { Code = CancellationClassTypeEnum.NoRefund.GetCode() }, CurrencyCode = "GBP", VariantAmount = 10, VariantType = new VariantType { Type = VariantTypeEnum.Amount }, ApplicableDays = Constants.FULL_AVAILABILITY }; variantRatePlanDao.Create(ratePlanToDelete); variantRatePlanDao.CreateVariantRatePlanRate(ratePlanToDelete); Assert.IsNotNull(ratePlanToDelete, "RatePlan should have been created"); Assert.IsTrue(ratePlanToDelete.VariantRatePlanRateId != default(int), "RatePlanRate should have been created"); // Act var deleteResult = variantRatePlanDao.DeleteVariantRatePlan(ratePlanToDelete.Id); // Assert Assert.IsTrue(deleteResult,"Expect deletion outcome to be true for successful deletion"); VariantRatePlan ratePlan = variantRatePlanDao.GetByBusinessId(BUSINESS_ID).First(); Assert.IsNotNull(ratePlan,"Expect VariantRatePlan to be present "); Assert.IsTrue(ratePlan.VariantRatePlanRateId != default(int), "Expect VariantRatePlan rates to be present"); }
public void CreateVariantRatePlanRateWithNonExistingVariantRatePlanExpectExceptionThrown() { // Arrange var variantRatePlan = new VariantRatePlan() {Id = 0}; // Act variantRatePlanDao.CreateVariantRatePlanRate(variantRatePlan); }
public void CreateVariantRatePlanRatePopulatesVariantRatePlanRateId() { // Arrange var variantRatePlan = new VariantRatePlan { Name = "Test", BusinessId = 1, RoomTypeId = 1, RatePlanType = new RatePlanType { Type = RatePlanTypeEnum.Variant }, MaxOccupancy = 2, MaxAdults = 2, MaxChildren = 1, BoardBasis = new EnumEntity { Code = BoardBasisTypeEnum.BreakfastIncluded.GetCode() }, CancellationClass = new EnumEntity { Code = CancellationClassTypeEnum.NoRefund.GetCode() }, CurrencyCode = "GBP", VariantAmount = 10, VariantType = new VariantType { Type = VariantTypeEnum.Amount }, ApplicableDays = Constants.FULL_AVAILABILITY }; variantRatePlanDao.Create(variantRatePlan); // Act variantRatePlanDao.CreateVariantRatePlanRate(variantRatePlan); // Assert Assert.IsTrue(variantRatePlan.VariantRatePlanRateId != default(int)); }
public void UpsertPromotionRatePlanLinksCallsMethodsCorrectly() { var existingPromotions = new List<Model.Pricing.Promotions.Promotion> { new Promotion { Id = 1, BusinessId = BUSINESS_ID, AssociatedRatePlanIds = new List<int> { RATEPLAN_ID, RATEPLAN_ID + 1 } }, new Promotion { Id = 2, BusinessId = BUSINESS_ID, AssociatedRatePlanIds = new List<int> { RATEPLAN_ID + 1 } }, new Promotion { Id = 3, BusinessId = BUSINESS_ID, AssociatedRatePlanIds = new List<int> { RATEPLAN_ID, RATEPLAN_ID + 2 } }, }; var ratePlan = new VariantRatePlan { BusinessId = BUSINESS_ID, Id = RATEPLAN_ID, AssociatedPromotions = new List<Model.Pricing.Promotions.Promotion> { new Promotion { Id = 2, BusinessId = BUSINESS_ID, AssociatedRatePlanIds = new List<int> { RATEPLAN_ID, RATEPLAN_ID + 1 } } } }; var promotionDaoMock = new Mock<IPromotionDao>(); promotionDaoMock.Setup(p => p.DeletePromoLinks(ratePlan.Id, It.Is<IEnumerable<int>>(i => i.Any(x => x == 1 || x == 3)))); promotionDaoMock.Setup(p => p.CreateRatePlanLinks(It.Is<List<PromotionRatePlanLink>>(prpl => prpl.Any(x => x.PromotionId == 2 && x.RatePlanId == RATEPLAN_ID)))); var promotionManager = new PromotionManager(); promotionManager.PromotionDao = promotionDaoMock.Object; Helpers.CacheHelper.StubPromoCacheWithPromotions(BUSINESS_ID, existingPromotions); Cache.PromoCache.Invalidate(); promotionManager.UpsertPromotionRatePlanLinks(ratePlan); promotionDaoMock.VerifyAll(); Helpers.CacheHelper.ReAssignPromotionDaoToPromoCache(); }
public void CreateEditVariantRatePlansWithInvalidVariantAmountThrowsException() { // Arrange const int variantRatePlanId = 1; const int variantRatePlanRateId = 0; const int roomTypeId = 1; const long businessId = 1; const int baseRatePlanId = 1; const decimal rackRate = 30; const decimal rate = 40; const decimal variantRate = -50; var baseRatePlanDao = new Mock<IBaseRatePlanDao>(); var baseRatePlanRatesDao = new Mock<IBaseRatePlanRatesDao>(); var variantRatePlan = new VariantRatePlan { Id = variantRatePlanId, VariantRatePlanRateId = variantRatePlanRateId, RoomTypeId = roomTypeId, BusinessId = businessId, VariantType = new VariantType { Type = VariantTypeEnum.Amount }, VariantAmount = variantRate }; var baseRatePlan = new BaseRatePlan { Id = baseRatePlanId, SellAtRackRate = true, RackRate = rackRate }; var ratePlanRate = new RatePlanRate { MonRate = rate, TueRate = rate, WedRate = rate, ThuRate = rate, FriRate = rate, SatRate = rate, SunRate = rate }; var ratePlanManager = new RatePlanManager { BaseRatePlanDao = baseRatePlanDao.Object, BaseRatePlanRatesDao = baseRatePlanRatesDao.Object }; baseRatePlanDao.Setup(brp => brp.GetByRoomTypeId(roomTypeId, businessId, string.Empty)).Returns(baseRatePlan); baseRatePlanRatesDao.Setup(brp => brp.GetByRatePlanId(baseRatePlanId)).Returns(new List<RatePlanRate> { ratePlanRate }); try { // Act ratePlanManager.CreateEditVariantRatePlans(new List<VariantRatePlan> { variantRatePlan }); // Assert Assert.Fail("Validation exception was not thrown"); } catch (ValidationException vex) { Assert.AreEqual(Errors.SRVEX30142.ToString(), vex.Code, "Incorrect validation exception was thrown"); } }
public void CreateEditVariantRatePlansForExistingRatePlanAndSelectedSeasonExpectRatePlanModified() { // Arrange const int variantRatePlanId = 1; const int variantRatePlanRateId = 0; const int roomTypeId = 1; const long businessId = 1; const int baseRatePlanId = 1; const decimal rackRate = 30; const decimal rate = 40; var eventTrackingManager = new Mock<IEventTrackingManager>(); var variantRatePlanDao = new Mock<IVariantRatePlanDao>(); var baseRatePlanDao = new Mock<IBaseRatePlanDao>(); var baseRatePlanRatesDao = new Mock<IBaseRatePlanRatesDao>(); var promotionManagerMock = new Mock<IPromotionManager>(); var variantRatePlan = new VariantRatePlan { Id = variantRatePlanId, VariantRatePlanRateId = variantRatePlanRateId, RoomTypeId = roomTypeId, BusinessId = businessId, VariantType = new VariantType { Type = VariantTypeEnum.Percentage } }; var baseRatePlan = new BaseRatePlan { Id = baseRatePlanId, SellAtRackRate = true, RackRate = rackRate }; var ratePlanRate = new RatePlanRate { MonRate = rate, TueRate = rate, WedRate = rate, ThuRate = rate, FriRate = rate, SatRate = rate, SunRate = rate }; var ratePlanManager = new RatePlanManager { EventTrackingManager = eventTrackingManager.Object, VariantRatePlanDao = variantRatePlanDao.Object, BaseRatePlanDao = baseRatePlanDao.Object, BaseRatePlanRatesDao = baseRatePlanRatesDao.Object, PromotionManager = promotionManagerMock.Object }; baseRatePlanDao.Setup(brp => brp.GetByRoomTypeId(roomTypeId, businessId, string.Empty)).Returns(baseRatePlan); baseRatePlanRatesDao.Setup(brp => brp.GetByRatePlanId(baseRatePlanId)).Returns(new List<RatePlanRate> { ratePlanRate }); promotionManagerMock.Setup(pr => pr.UpsertPromotionRatePlanLinks(It.IsAny<RatePlan>())); variantRatePlanDao.Setup(vrp => vrp.Modify(variantRatePlan)); eventTrackingManager.Setup(e => e.CreateBusinessEventAsync(It.IsAny<long>(), It.IsAny<BusinessEventTypesEnum>(), It.IsAny<string>(), null)); // Act ratePlanManager.CreateEditVariantRatePlans(new List<VariantRatePlan> { variantRatePlan }); // Assert variantRatePlanDao.VerifyAll(); eventTrackingManager.Verify(e => e.CreateBusinessEventAsync(It.IsAny<long>(), BusinessEventTypesEnum.VariantRatePlanModified, It.IsAny<string>(), null), Times.Once); baseRatePlanDao.VerifyAll(); promotionManagerMock.Verify(pr => pr.UpsertPromotionRatePlanLinks(It.IsAny<RatePlan>()), Times.AtLeastOnce()); }
/// <summary> /// Create default Adult or Child VariantRataPlans for PerPerson pricing /// </summary> /// <param name="variantRatePlan">VariantRatePlan</param> /// <param name="cultureCode">CultureCode</param> /// <param name="occupancyRateType">OccupancyRateType</param> /// <returns>VariantRatePlan</returns> private VariantRatePlan GetDefaultOccupantVariantPerPersonRatePlan(VariantRatePlan variantRatePlan, string cultureCode,OccupancyRateType occupancyRateType) { var createdRatePlan = CloneVariantRatePlan(variantRatePlan); createdRatePlan.UseOccupancyRates = true; createdRatePlan.VariantRatePlanRateId = 0; createdRatePlan.Rates.OccupancyRateType = occupancyRateType; SetVariantDefaultPeriod(createdRatePlan, cultureCode); return createdRatePlan; }
/// <summary> /// Creates just the variant rate plan /// </summary> /// <param name="ratePlan">Rate plan</param> /// <returns>created rate plan with id</returns> public VariantRatePlan CreateVariantRatePlan(VariantRatePlan ratePlan) { if (ratePlan == null) { return null; } using (var tx = new BusinessTransaction()) { variantRatePlanDao.Create(ratePlan); tx.Commit(); } eventTrackingManager.CreateBusinessEventAsync(ratePlan.BusinessId, BusinessEventTypesEnum.VariantRatePlanAdded, ratePlan.Id.ToString(CultureInfo.InvariantCulture)); // Invalidate the cache so it refreshes Cache.Cache.RatePlanViewCache.Invalidate(ratePlan.BusinessId); return ratePlan; }
public void CreateRatePlanWithInvalidRoomTypeIdThrowsException() { // Arrange // Create rate plan var ratePlan = new VariantRatePlan { Name = "Test", BusinessId = 1, RoomTypeId = 11, RatePlanType = new RatePlanType { Type = RatePlanTypeEnum.Base }, MaxOccupancy = 2, MaxAdults = 2, MaxChildren = 1, BoardBasis = new EnumEntity { Code = BoardBasisTypeEnum.BreakfastIncluded.GetCode() }, CancellationClass = new EnumEntity { Code = CancellationClassTypeEnum.NoRefund.GetCode() }, CurrencyCode = "GBP", VariantAmount = 10, VariantType = new VariantType { Type = VariantTypeEnum.Amount }, ApplicableDays = Constants.FULL_AVAILABILITY }; // Act variantRatePlanDao.Create(ratePlan); }
/// <summary> /// Creates variant rate plan and rates for a particular variant rate plan /// </summary> /// <param name="ratePlan">Rate plan</param> /// <returns>created rate plan with rates created</returns> public VariantRatePlan CreateVariantRatePlanAndRates(VariantRatePlan ratePlan) { if (ratePlan == null) { return null; } using (var tx = new BusinessTransaction()) { CreateVariantRatePlan(ratePlan); CreateVariantRatePlanRate(ratePlan); tx.Commit(); } return ratePlan; }
/// <summary> /// Create a copy of a specified VariantRatePlan /// </summary> /// <param name="variantRatePlan">Variant rate plan</param> /// <returns>Return copy of variant rate plan</returns> private static VariantRatePlan CloneVariantRatePlan(VariantRatePlan variantRatePlan) { if (variantRatePlan == null) { throw new ArgumentNullException("variantRatePlan"); } return new VariantRatePlan { Id = variantRatePlan.Id, RoomTypeId = variantRatePlan.RoomTypeId, RatePlanType = variantRatePlan.RatePlanType, MaxOccupancy = variantRatePlan.MaxOccupancy, MaxAdults = variantRatePlan.MaxAdults, MaxChildren = variantRatePlan.MaxChildren, BoardBasis = variantRatePlan.BoardBasis, CancellationClass = variantRatePlan.CancellationClass, RoomType = variantRatePlan.RoomType, CurrencyCode = variantRatePlan.CurrencyCode, BusinessId = variantRatePlan.BusinessId, ApplicableDays = variantRatePlan.ApplicableDays, ApplyToAllPeriods = variantRatePlan.ApplyToAllPeriods, Rates = variantRatePlan.Rates != null ? CloneRatePlanRates(variantRatePlan.Rates) : null, Name = variantRatePlan.Name, VariantType = variantRatePlan.VariantType, VariantAmount = variantRatePlan.VariantAmount, MinStay = variantRatePlan.MinStay, VariantRatePlanRateId = variantRatePlan.VariantRatePlanRateId, IsActive = variantRatePlan.IsActive, DisplayName = variantRatePlan.DisplayName }; }
public void ModifyVariantRatePlanIsSuccessful() { // Arrange const int ratePlanId = 1; const long businessId = 1; const int ratePlanRateId = 5; var eventTrackingManager = new Mock<IEventTrackingManager>(); var variantRatePlanDao = new Mock<IVariantRatePlanDao>(); var ratePlanManager = new RatePlanManager { EventTrackingManager = eventTrackingManager.Object, VariantRatePlanDao = variantRatePlanDao.Object }; var ratePlan = new VariantRatePlan { BusinessId = businessId, Id = ratePlanId, RatePlanType = new RatePlanType { Type = RatePlanTypeEnum.Variant }, Rates = new RatePlanRate { Id = ratePlanRateId, RatePlanId = ratePlanId } }; variantRatePlanDao.Setup(rp => rp.Modify(ratePlan)); eventTrackingManager.Setup(e => e.CreateBusinessEventAsync(It.IsAny<long>(), It.IsAny<BusinessEventTypesEnum>(), It.IsAny<string>(), null)); // Act ratePlanManager.ModifyVariantRatePlan(ratePlan); // Assert variantRatePlanDao.VerifyAll(); eventTrackingManager.Verify(e => e.CreateBusinessEventAsync(It.IsAny<long>(), BusinessEventTypesEnum.VariantRatePlanModified, It.IsAny<string>(), null), Times.Once); }
/// <summary> /// Get the default rates for evergreen period for variant rate plan /// </summary> /// <param name="variantRatePlan">VariantRatePlan</param> private static RatePlanRate GetDefaultVariantEvergreenBaseRates(VariantRatePlan variantRatePlan) { return new RatePlanRate { MonRate = 0, MonMinStay = MIN_STAY, TueRate = 0, TueMinStay = MIN_STAY, WedRate = 0, WedMinStay = MIN_STAY, ThuRate = 0, ThuMinStay = MIN_STAY, FriRate = 0, FriMinStay = MIN_STAY, SatRate = 0, SatMinStay = MIN_STAY, SunRate = 0, SunMinStay = MIN_STAY, RatePlanId = variantRatePlan.Id }; }
public void AssignAndGetPromotionsForVariantPlansGetsCorrectPromotions() { // Arrange VariantRatePlan variantOne = new VariantRatePlan { Id = RATEPLAN_ONE, BusinessId = BUSINESS_ONE }; VariantRatePlan variantTwo = new VariantRatePlan { Id = RATEPLAN_THREE, BusinessId = BUSINESS_ONE }; List<VariantRatePlan> ratePlans = new List<VariantRatePlan> { variantOne, variantTwo }; // Act promotionManager.AssignAndGetPromotionsForRatePlans(ratePlans, BUSINESS_ONE); // Assert Assert.NotNull(variantOne.AssociatedPromotions, "associated promos not set for first variant"); Assert.NotNull(variantTwo.AssociatedPromotions, "associated promos not set for second variant"); Assert.IsTrue(variantOne.AssociatedPromotions.Any(p => p.Id == PROMO_ONE), "promo one should be assigned to the first rateplan"); Assert.IsTrue(variantOne.AssociatedPromotions.Any(p => p.Id == PROMO_TWO) == false, "promo two should not be assigned to the first rateplan"); Assert.IsTrue(variantTwo.AssociatedPromotions.Any(p => p.Id == PROMO_TWO), "promo two should be assigned to the second rateplan"); Assert.IsTrue(variantTwo.AssociatedPromotions.Any(p => p.Id == PROMO_ONE) == false, "promo one should not be assigned to the second rateplan"); CacheHelper.ReAssignPromotionDaoToPromoCache(); }
/// <summary> /// Get null rates for a rate plan /// </summary> /// <param name="variantRatePlan">VariantRatePlan</param> private static RatePlanRate GetNulRates(VariantRatePlan variantRatePlan) { return new RatePlanRate { MonRate = null, MonMinStay = MIN_STAY, TueRate = null, TueMinStay = MIN_STAY, WedRate = null, WedMinStay = MIN_STAY, ThuRate = null, ThuMinStay = MIN_STAY, FriRate = null, FriMinStay = MIN_STAY, SatRate = null, SatMinStay = MIN_STAY, SunRate = null, SunMinStay = MIN_STAY, RatePlanId = variantRatePlan.Id }; }