/// <summary> /// Create RoomType /// </summary> /// <param name="roomType">The room type object to create</param> public void Create(RoomType roomType) { const string SQL_STATEMENT = @" INSERT INTO Room.RoomType ( BusinessId, Code, RoomClassCode, QualityTypeCode, BathroomTypeCode, AspectCode, Label, ServiceFrequencyCode, BaseOccupancy, UpdatedByUserId ) VALUES ( @BusinessId, Room.GetNextRoomTypeCode(@BusinessId), @RoomClass, @QualityType, @BathroomType, @Aspect, @Label, @ServiceFrequencyCode, @BaseOccupancy, @UpdatedByUserId ) SELECT @Id = SCOPE_IDENTITY()"; var parameters = new List<SqlParameter> { DbHelper.CreateParameter(RoomTypeMapper.Parameters.BusinessId, roomType.BusinessId), DbHelper.CreateParameter(RoomTypeMapper.Parameters.RoomClass, roomType.RoomClass.Code), DbHelper.CreateParameter(RoomTypeMapper.Parameters.QualityType, roomType.QualityType.Code), DbHelper.CreateParameter(RoomTypeMapper.Parameters.BathroomType, roomType.BathroomType.Code), DbHelper.CreateParameter(RoomTypeMapper.Parameters.Aspect, roomType.Aspect.Code), DbHelper.CreateParameter(RoomTypeMapper.Parameters.Label, roomType.Label), DbHelper.CreateParameter(RoomTypeMapper.Parameters.BaseOccupancy, roomType.BaseOccupancy), DbHelper.CreateParameter(RoomTypeMapper.Parameters.ServiceFrequencyCode, roomType.ServiceFrequency.Code) }; // Add auditing parameters AuditFieldsHelper.PopulateAuditFields(parameters); SqlParameter outputKey; parameters.Add(outputKey = DbHelper.CreateParameterOut<int>(RoomTypeMapper.Parameters.Id, SqlDbType.Int)); DbHelper.ExecuteNonQueryCommand(SQL_STATEMENT, parameters: parameters); roomType.Id = DbHelper.ParameterValue<int>(outputKey); }
public void SendRateAmountUpdateWithRatesListCallPPCGateway() { //Arrange const long businessId = 5002; const string businessShortname = "TestBus2"; const int baseRatePlanId = 1; RoomType roomType = new RoomType(); BaseRatePlan baseRatePlan = new BaseRatePlan(); baseRatePlan.Id = baseRatePlanId; baseRatePlan.MaxOccupancy = 1; roomType.BaseRatePlan = baseRatePlan; var ppcGatewayMock = new Mock<IPPCGateway>(); var roomTypeManagerStub = new Mock<IRoomTypeManager>(); var rateCacheManagerStub = new Mock<IRateCacheManager>(); rateCacheManagerStub.Setup(r => r.GetAllByRoomTypeAndRatePlanId(businessId, 1, baseRatePlanId, RatePlanTypeEnum.Unknown)) .Returns(new List<RateCache>() { new RateCache() { Rate = new decimal(1.0), Date = DateTime.Now, MinStay = 1 } }); roomTypeManagerStub.Setup(m => m.GetRoomType(1, businessId, "")) .Returns(roomType); var rateAmountUpdate = new RateAmountUpdate(); rateAmountUpdate.PPCGateway = ppcGatewayMock.Object; rateAmountUpdate.RateCacheManager = rateCacheManagerStub.Object; rateAmountUpdate.RoomTypeManager = roomTypeManagerStub.Object; //Act rateAmountUpdate.SendRateAmountUpdate(businessShortname, businessId, 1, baseRatePlanId); //Assert ppcGatewayMock.Verify(g => g.Publish(It.IsAny<IPartitionable>()), Times.AtLeastOnce); }
public void CreateRoomTypePopulatesRoomTypeId() { // Arrange // Create room type var roomType = new RoomType { BusinessId = 1, RoomClass = new RoomClass { Code = "TWN" }, QualityType = new QualityType { Code = "CTG" }, BathroomType = new BathroomType { Code = "PB" }, Aspect = new Aspect { Code = "CVW" }, ServiceFrequency = new EnumEntity { Code = ServiceFrequencyEnum.Daily.GetCode() } }; // Act roomTypeDao.Create(roomType); // Assert // Check if the room type id is attributed Assert.IsNotNull(roomType.Id, "The room type id was not attributed."); }
/// <summary> /// Modify RoomType /// </summary> /// <param name="roomType">The room type object to modify</param> public void Modify(RoomType roomType) { const string SQL_STATEMENT = @" UPDATE Room.RoomType SET RoomClassCode = @RoomClass, QualityTypeCode = @QualityType, BathroomTypeCode = @BathroomType, AspectCode = @Aspect, Label = @Label, BaseOccupancy = @BaseOccupancy, UpdatedByUserId = @UpdatedByUserId WHERE Id = @Id"; var parameters = new List<SqlParameter> { DbHelper.CreateParameter(RoomTypeMapper.Parameters.Id, roomType.Id), DbHelper.CreateParameter(RoomTypeMapper.Parameters.RoomClass, roomType.RoomClass.Code), DbHelper.CreateParameter(RoomTypeMapper.Parameters.QualityType, roomType.QualityType.Code), DbHelper.CreateParameter(RoomTypeMapper.Parameters.BathroomType, roomType.BathroomType.Code), DbHelper.CreateParameter(RoomTypeMapper.Parameters.Aspect, roomType.Aspect.Code), DbHelper.CreateParameter(RoomTypeMapper.Parameters.BaseOccupancy, roomType.BaseOccupancy), DbHelper.CreateParameter(RoomTypeMapper.Parameters.Label, roomType.Label) }; // Add auditing parameters AuditFieldsHelper.PopulateAuditFields(parameters); int rowsAffected = DbHelper.ExecuteNonQueryCommand(SQL_STATEMENT, parameters: parameters); // Check if the update was successful if (rowsAffected == 0) { throw new ExpectedResultException(ErrorFactory.CreateAndLogError(Errors.SRVEX30027, "RoomTypeDao.Modify", additionalDescriptionParameters: (new object[] { roomType.GetType().Name, roomType.Id }), arguments: new object[] { roomType.GetType().Name, roomType.Id })); } }
public void DoesRoomTypeExistWithoutExistingRoomTypeReturnsFalseIsSuccessful() { // Arrange var roomType = new RoomType { RoomClass = new RoomClass { Code = "SGL" }, QualityType = new QualityType { Code = "APT" }, BathroomType = new BathroomType { Code = "ES" }, Aspect = new Aspect { Code = "BAL" } }; // Act bool doesRoomTypeExist = roomTypeDao.DoesRoomTypeExist(roomType); // Assert Assert.IsFalse(doesRoomTypeExist, "Room type should not exist"); }
public void ModifyRoomTypeIsSuccessful() { // Arrange var roomType = new RoomType { Id = 1, BusinessId = 1, RoomClass = new RoomClass { Code = "TWN" }, QualityType = new QualityType { Code = "APT" }, BathroomType = new BathroomType { Code = "JC" }, Aspect = new Aspect { Code = "BAL" } }; // Act roomTypeDao.Modify(roomType); RoomType roomTypeToVerify = roomTypeDao.GetByKey(roomType.Id); // Assert // Check if the room type has been updated correctly Assert.AreEqual(roomType.BusinessId, roomTypeToVerify.BusinessId, "The business id was not updated."); Assert.AreEqual(roomType.RoomClass.Code, roomTypeToVerify.RoomClass.Code, "The room class was not updated."); Assert.AreEqual(roomType.QualityType.Code, roomTypeToVerify.QualityType.Code, "The quality type was not updated."); Assert.AreEqual(roomType.BathroomType.Code, roomTypeToVerify.BathroomType.Code, "The bathroom type was not updated."); Assert.AreEqual(roomType.Aspect.Code, roomTypeToVerify.Aspect.Code, "The aspect was not updated."); }
/// <summary> /// Create Inventory from Eagle room /// </summary> /// <param name="room">Room</param> /// <param name="roomType"></param> /// <returns>AIGInventory object</returns> private Inventory CreateInventoryFromRoom(Room room, RoomType roomType) { var visibility = Visibility.All; if (!room.IsAvailableOnline || room.RoomStatusCode != ACTIVE_ROOM_STATUS_CODE) { visibility = Visibility.Offline; } var interfaceRoom = new AIGInventory(room.Id.ToGuid(ROOM_PREFIX).ToString(), room.Name, visibility, null) { InventoryAvailabilityDiaryDateRange = ExtractAndCreateInventoryAvailability(room.Id, roomType) }; return interfaceRoom; }
/// <summary> /// Set Configuration on AIG product /// </summary> /// <param name="roomType">Room Type</param> /// <param name="interfaceProduct">AIG Product</param> private void SetAigProductConfiguration(RoomType roomType, ref AIGProduct interfaceProduct) { var rooms = ExtractProductsAndThierAvailabiltyByProductType(roomType); if (interfaceProduct == null) { interfaceProduct = AIGProduct.CreateProductInventoryConfigurationOnly(roomType.ProductId, rooms); } else { interfaceProduct.Inventory = rooms; } CheckAssociatedInventoryExists(interfaceProduct); }
/// <summary> /// Convert Room Type to AIG product /// </summary> /// <param name="roomType">Room Type</param> /// <param name="checkinTime">Checkin Time</param> /// <param name="checkoutTime">Checkout Time</param> /// <returns>AIGProduct</returns> private AIGProduct ConvertRoomTypeToAigProduct(RoomType roomType, string checkinTime, string checkoutTime) { var interfaceProduct = SetAigProductAttributes(roomType, checkinTime, checkoutTime); CheckValidMaximumOccupancyIsSet(interfaceProduct); SetAigProductConfiguration(roomType, ref interfaceProduct); return interfaceProduct; }
/// <summary> /// Set up booking for scenario given a row from feature table /// </summary> /// <param name="bookingType">booking type column cell</param> /// <param name="currentRoomType">room type</param> /// <param name="row">row from feature table</param> /// <param name="userId">user to use for created by</param> /// <returns>Booking to use</returns> private Booking SetUpBooking(string bookingType, RoomType currentRoomType, TableRow row, Guid userId) { int randomGuestId = TestSchemaHelper.LoadRandomGuest(businesses[row[HOTEL]], userId); EnumEntity bookingStatus = new EnumEntity { Code = bookingType.ToLower().IndexOf("confirmed") >= 0 ? BookingStatusType.CONFIRMED : BookingStatusType.PROVISIONAL }; return new Booking { BusinessId = businesses[row[HOTEL]], RoomId = currentRoomType.Rooms.Find(rm => rm.Name == row[ROOM_NAME]).Id, RoomTypeId = currentRoomType.Id, RatePlanId = currentRoomType.BaseRatePlans[0].Id, // Assume first rate plan for room type since not specified in given StartDate = GetDateFromFeatureString(row[START_DATE]), EndDate = GetDateFromFeatureString(row[END_DATE]), BookingStatus = bookingStatus, Guest = new Model.Customer.Guest { Id = randomGuestId }, BookingScenarioType = BookingScenarioTypeEnum.OnAccountBooking, CurrencyCode = "GBP", SourceType = new EnumEntity { Code = SourceType.ONLINE }, RateType = new EnumEntity { Code = RateType.BEST_AVAILABLE_RATE }, CheckinStatus = new EnumEntity { Code = CheckinStatusOptions.NOTCHECKEDIN }, Cost = 1 }; }
/// <summary> /// Modify a room type and its base rate plan /// </summary> /// <param name="roomType">The room type object to modify</param> public void ModifyRoomTypeAndBaseRatePlan(RoomType roomType) { // Validate data if (roomTypeDao.DoesRoomTypeExist(roomType)) { throw new ValidationException(ErrorFactory.CreateAndLogError(Errors.SRVEX30093, "RoomManager.ModifyRoomTypeAndBaseRatePlan", arguments: new object[] { roomType })); } using (var btx = new BusinessTransaction()) { var baseRatePlan = roomType.BaseRatePlan; if (roomType.IsValid() && baseRatePlan.IsValid()) { // Modify room type and subsequent business event roomTypeDao.Modify(roomType); baseRatePlan.RoomTypeId = roomType.Id; // Modify rate plan ratePlanManager.ModifyBaseRatePlan(baseRatePlan); btx.Commit(); eventTrackingManager.CreateBusinessEventAsync(roomType.BusinessId, BusinessEventTypesEnum.RoomTypeModified, roomType.Id.ToString(CultureInfo.InvariantCulture)); } } // Invalid this item in the cache so it is retrieved again // Needs to be after transaction so updated info is in db and readable. Cache.Cache.RoomType.Invalidate(roomType.Id); Cache.Cache.RatePlanViewCache.Invalidate(roomType.BusinessId); Cache.Cache.PromoCache.Invalidate(roomType.BusinessId); }
/// <summary> /// Create a record for room type and its base rate plan /// </summary> /// <param name="roomType">The room type object to create</param> public void CreateRoomTypeAndBaseRatePlan(RoomType roomType) { using (var btx = new BusinessTransaction()) { // determine if room type exists and is active bool activeRoomTypeExists = roomTypeDao.DoesRoomTypeExist(roomType); // if room type exists and is active, throw validation exception if (activeRoomTypeExists) { throw new ValidationException(ErrorFactory.CreateAndLogError(Errors.SRVEX30093, "RoomManager.CreateRoomTypeAndBaseRatePlan", arguments: new object[] { roomType })); } RoomType roomTypeReference = roomTypeDao.GetByRoomTypeInformation(roomType); // if room type exists and is not active, activate it if (roomTypeReference != null) { //set room type isActive flag to true roomTypeDao.ActivateRoomType(roomTypeReference.Id); // set rooms belonging to room type to active List<Model.Room.Room> rooms = roomManager.GetRoomsByBusinessRoomType(roomTypeReference.Id, roomTypeReference.BusinessId); // createRoom method detects existing rooms and set it to active rooms.ForEach(r => roomManager.CreateRoom(r.Name, r.RoomTypeId, r.BusinessId)); roomType.Id = roomTypeReference.Id; BaseRatePlan inputBaseRatePlan = roomType.BaseRatePlan; BaseRatePlan roomTypeBaseRatePlan = baseRatePlanDao.GetByRoomTypeId(roomTypeReference.Id, roomTypeReference.BusinessId); if (roomTypeBaseRatePlan == null) { throw new ValidationException(ErrorFactory.CreateAndLogError(Errors.SRVEX30062, "RoomManager.CreateRoomTypeAndBaseRatePlan", arguments: new object[] { roomType })); } if (inputBaseRatePlan == null) { throw new ValidationException(ErrorFactory.CreateAndLogError(Errors.SRVEX30062, "RoomManager.CreateRoomTypeAndBaseRatePlan", arguments: new object[] { roomType })); } roomTypeBaseRatePlan.RatePlanType = new RatePlanType { Type = RatePlanTypeEnum.Base }; roomTypeBaseRatePlan.RoomTypeId = roomTypeReference.Id; roomTypeBaseRatePlan.BusinessId = roomTypeReference.BusinessId; roomTypeBaseRatePlan.RackRate = inputBaseRatePlan.RackRate; roomTypeBaseRatePlan.MaxAdults = inputBaseRatePlan.MaxAdults; roomTypeBaseRatePlan.MaxChildren = inputBaseRatePlan.MaxChildren; roomTypeBaseRatePlan.MaxOccupancy = inputBaseRatePlan.MaxOccupancy; roomTypeBaseRatePlan.BoardBasis = inputBaseRatePlan.BoardBasis; roomTypeBaseRatePlan.CancellationClass = inputBaseRatePlan.CancellationClass; roomTypeBaseRatePlan.SellAtRackRate = inputBaseRatePlan.SellAtRackRate; roomTypeBaseRatePlan.UseOccupancyRates = inputBaseRatePlan.UseOccupancyRates; roomTypeBaseRatePlan.DisplayName = inputBaseRatePlan.DisplayName; ratePlanManager.ModifyBaseRatePlan(roomTypeBaseRatePlan); btx.Commit(); // set event for activation of room type eventTrackingManager.CreateBusinessEventAsync(roomTypeReference.BusinessId, BusinessEventTypesEnum.RoomTypeActivated, roomTypeReference.Id.ToString(), null); } else { BaseRatePlan baseRatePlan = roomType.BaseRatePlan; if (baseRatePlan == null) { throw new ValidationException(ErrorFactory.CreateAndLogError(Errors.SRVEX30062, "RoomManager.CreateRoomTypeAndBaseRatePlan", arguments: new object[] { roomType })); } // NOTE: ServiceFrequency isn't currently implemented so are hard coded here for the time being roomType.ServiceFrequency = new EnumEntity { Code = ServiceFrequencyEnum.Daily.GetCode() }; baseRatePlan.RatePlanType = new RatePlanType { Type = RatePlanTypeEnum.Base }; if (roomType.IsValid() && baseRatePlan.IsValid()) { // Create room type and subsequent business event roomTypeDao.Create(roomType); // Create rate plan and subsequent business event baseRatePlan.RoomTypeId = roomType.Id; baseRatePlanDao.Create(baseRatePlan); btx.Commit(); eventTrackingManager.CreateBusinessEventAsync(roomType.BusinessId, BusinessEventTypesEnum.RoomTypeAdded, roomType.Id.ToString(CultureInfo.InvariantCulture)); eventTrackingManager.CreateBusinessEventAsync(roomType.BusinessId, BusinessEventTypesEnum.RatePlanAdded, baseRatePlan.Id.ToString(CultureInfo.InvariantCulture)); } } } // Invalidate the cache so it refreshes Cache.Cache.RatePlanViewCache.Invalidate(roomType.BusinessId); }
///<summary> /// Converts RoomType to RoomTypeDto ///</summary> ///<param name="roomType">Room Type</param> ///<returns>Room Type DTO</returns> private static RoomTypeDto ConvertRoomTypeToDto(RoomType roomType) { RoomTypeDto dto = null; if (roomType != null) { dto = new RoomTypeDto { Id = roomType.Id, Code = roomType.Code, Name = roomType.Name, RoomIds = new List<int>(), RatePlans = roomType.RatePlans.ConvertAll(ConvertRatePlanToDto) }; foreach (Room room in roomType.Rooms) { dto.RoomIds.Add(room.Id); } foreach (CombinedRoom combinedRoom in roomType.CombinedRooms) { dto.RoomIds.Add(combinedRoom.Id); } } return dto; }
/// <summary> /// Get room type based on room class, quality and bathroom types /// </summary> /// <param name="roomType">RoomType</param> /// <returns>RoomType</returns> public RoomType GetByRoomTypeInformation(RoomType roomType) { string sqlQuery = ROOMTYPES_QUERY + @" WHERE BusinessId = @BusinessId AND RoomClassCode = @RoomClass AND BathroomTypeCode = @BathroomType"; var parameters = new List<SqlParameter> { DbHelper.CreateParameter(RoomTypeMapper.Parameters.BusinessId, roomType.BusinessId), DbHelper.CreateParameter(RoomTypeMapper.Parameters.RoomClass, roomType.RoomClass.Code), DbHelper.CreateParameter(RoomTypeMapper.Parameters.BathroomType, roomType.BathroomType.Code), DbHelper.CreateParameter(RoomMapper.Parameters.RoomStatus, RoomStatusCodes.ACTIVE) }; if (roomType.QualityType != null && !string.IsNullOrWhiteSpace(roomType.QualityType.Code)) { sqlQuery = sqlQuery + " AND QualityTypeCode = @QualityType "; parameters.Add(DbHelper.CreateParameter(RoomTypeMapper.Parameters.QualityType, roomType.QualityType.Code)); } else { sqlQuery = sqlQuery + " AND QualityTypeCode IS NULL "; } if (roomType.Aspect != null && !string.IsNullOrEmpty(roomType.Aspect.Code)) { sqlQuery = sqlQuery + " AND AspectCode = @Aspect "; parameters.Add(DbHelper.CreateParameter(RoomTypeMapper.Parameters.Aspect, roomType.Aspect.Code)); } else { sqlQuery = sqlQuery + " AND AspectCode IS NULL "; } if (!string.IsNullOrEmpty(roomType.Label)) { sqlQuery = sqlQuery + "AND Label = @Label "; parameters.Add(DbHelper.CreateParameter(RoomTypeMapper.Parameters.Label, roomType.Label)); } else { sqlQuery = sqlQuery + "AND Label IS NULL "; } if (roomType.Id != default(int)) { sqlQuery = sqlQuery + " AND Id = @Id "; parameters.Add(DbHelper.CreateParameter(RoomTypeMapper.Parameters.Id, roomType.Id)); } return DbHelper.CreateInstance(sqlQuery, RoomTypeMapper.MapReader, parameters: parameters); }
/// <summary> /// Check if room type already exists /// </summary> /// <param name="roomType">Room type to check</param> /// <returns>True if room type exists</returns> public bool DoesRoomTypeExist(RoomType roomType) { string sqlSelect = @" SELECT count(id) FROM Room.RoomType WHERE BusinessId = @BusinessId AND RoomClassCode = @RoomClass AND BathroomTypeCode = @BathroomType AND IsActive = 1 "; var parameters = new List<SqlParameter> { DbHelper.CreateParameter(RoomTypeMapper.Parameters.BusinessId, roomType.BusinessId), DbHelper.CreateParameter(RoomTypeMapper.Parameters.RoomClass, roomType.RoomClass.Code), DbHelper.CreateParameter(RoomTypeMapper.Parameters.BathroomType, roomType.BathroomType.Code) }; if (roomType.QualityType != null && !string.IsNullOrWhiteSpace(roomType.QualityType.Code)) { sqlSelect = sqlSelect + "AND QualityTypeCode = @QualityType "; parameters.Add(DbHelper.CreateParameter(RoomTypeMapper.Parameters.QualityType, roomType.QualityType.Code)); } else { sqlSelect = sqlSelect + "AND QualityTypeCode IS NULL "; } if (roomType.Aspect != null && !string.IsNullOrEmpty(roomType.Aspect.Code)) { sqlSelect = sqlSelect + "AND AspectCode = @Aspect "; parameters.Add(DbHelper.CreateParameter(RoomTypeMapper.Parameters.Aspect, roomType.Aspect.Code)); } else { sqlSelect = sqlSelect + "AND AspectCode IS NULL "; } if (!string.IsNullOrEmpty(roomType.Label)) { sqlSelect = sqlSelect + "AND Label = @Label "; parameters.Add(DbHelper.CreateParameter(RoomTypeMapper.Parameters.Label, roomType.Label)); } else { sqlSelect = sqlSelect + "AND Label IS NULL "; } // Only return true if there's a match for the room type being modified if (roomType.Id != default(int)) { sqlSelect = sqlSelect + "AND Id != @Id "; parameters.Add(DbHelper.CreateParameter(RoomTypeMapper.Parameters.Id, roomType.Id)); } return DbHelper.ExecuteScalar<bool>(sqlSelect, CommandType.Text, parameters); }
/// <summary> /// Stubs the Room Type Cache with a room type /// </summary> /// <param name="roomType">The room type</param> /// <returns>Stubbed BusinessDao</returns> public static IRoomTypeDao StubRoomTypeCacheWithRoomType(RoomType roomType) { var roomTypeDao = new Mock<IRoomTypeDao>(); roomTypeDao.Setup(rt => rt.GetByKey(roomType.Id)).Returns(roomType); Cache.RoomType.RoomTypeDao = roomTypeDao.Object; return roomTypeDao.Object; }
protected override void RunBeforeAllTests() { base.RunBeforeAllTests(); var businessManager = new BusinessManager(); var roomTypeManager = new RoomTypeManager(); var roomManager = new RoomManager(); var orderManager = new OrderManager(); //Create a business var paymentMethod = new BusinessPaymentMethod { BusinessId = BUSINESS_ID, CurrencyCode = CURRENCY, PaymentMethodCode = PaymentMethodEnum.Cash.GetCode() }; var provider = new Provider { RoomCount = ROOM_COUNT, ContentId = BUSINESS_ID.ToString(), ProviderTypeCode = PROVIDER_TYPE, }; var business = new Model.Business.Business { BusinessStatusCode = "A", BusinessTypeCode = "P", Name = "Test Business", ShortName = "Test", ReferenceCode = "B001", IsTaxRegistered = true, TaxRegistrationNumber = "12345", BusinessRegistrationNumber = "12345", AddressLine1 = "5 Main Road", AddressLine2 = "Twickenham", City = "London", StateProvinceId = 386, PostCode = "TW2 5SE", CountryId = 16, BusinessTelephoneNumber = "07448752114", TimeZoneId = 36, DefaultCultureCode = CULTURE, WorkingCurrencyCode = CURRENCY, UpdatedByUserId = new Guid("11111111-1111-1111-1111-111111111111"), Provider = provider, BusinessPaymentMethods = new List<BusinessPaymentMethod> {paymentMethod} }; var businessId = businessManager.CreateBusiness(business); // Create a room type var ratePlan = new BaseRatePlan { BusinessId = businessId, CurrencyCode = CURRENCY, MaxAdults = 2, MaxChildren = 2, MaxOccupancy = 3, BoardBasis = new EnumEntity {Code = "BK"}, CancellationClass = new EnumEntity {Code = "FR"}, RackRate = new decimal(120.0), SellAtRackRate = true, RatePlanType = new RatePlanType {Type = RatePlanTypeEnum.Base}, Rates = new RatePlanRate{BusinessId = businessId, MonRate = 120, MonMinStay = 120}, UpdatedByUserId = new Guid("11111111-1111-1111-1111-111111111111"), }; var roomType = new RoomType { BusinessId = businessId, RoomClass = roomTypeManager.GetRoomClasses(CULTURE).FirstOrDefault(), //new RoomClass { Code = "DBL" }, QualityType = roomTypeManager.GetQualityTypes(CULTURE).FirstOrDefault(), //new QualityType { Code = "APT" }, BathroomType = roomTypeManager.GetBathroomTypes(CULTURE).FirstOrDefault(), //new BathroomType { Code = "SP" }, Code = "DBL99", ServiceFrequency = new EnumEntity { Code = "B" }, UpdatedByUserId = new Guid("11111111-1111-1111-1111-111111111111"), BaseRatePlan = ratePlan, BaseRatePlanId = ratePlan.Id, Aspect = new Aspect { Code = "BAL"}, }; roomTypeManager.CreateRoomTypeAndBaseRatePlan(roomType); roomType = roomTypeManager.GetRoomTypesAndBaseRatePlans(businessId, CULTURE).First(); ratePlan = roomType.BaseRatePlan; //Create a room var roomId = roomManager.CreateRoom("TestRoom", roomType.Id, businessId); //Create an order var booking = new Booking { BusinessId = businessId, Guest = new Guest { DefaultCultureCode = CULTURE, Surname = "TestSurname", BusinessId = businessId }, StartDate = new DateTime(2014, 2, 10, 0, 0, 0, DateTimeKind.Utc), EndDate = new DateTime(2014, 2, 12, 0, 0, 0, DateTimeKind.Utc), NumberOfAdults = 2, NumberOfChildren = 1, Cost = new decimal(120.5), BookingStatus = new EnumEntity { Code = BookingStatusType.CONFIRMED }, RoomTypeId = roomType.Id, RoomId = roomId, RatePlanId = ratePlan.Id, Notes = "Testing note", BookingScenarioType = BookingScenarioTypeEnum.OnAccountBooking, RateType = new EnumEntity { Code = RateType.BEST_AVAILABLE_RATE }, CheckinStatus = new EnumEntity { Code = CheckinStatusOptions.NOTCHECKEDIN }, IsAvailabilityIgnored = true, BoardBasis = BoardBasisTypeEnum.BreakfastIncluded, CancellationDetails = new CancellationDetail() }; var order = new Order { OfflineSourceEnum = OfflineSourceEnum.Web, OrderSourceCode = SourceType.Pms.GetCode(), CustomerCurrencyCode = CURRENCY, Bookings = new List<Booking> { booking }, CustomerCultureCode = "en-GB" }; // Mock email manager so it doesn't send emails var emailManager = new Mock<IEmailManager>(); orderManager.EmailManager = emailManager.Object; emailManager.Setup(x => x.SendConfirmationEmails(order)).Returns(true); orderManager.CreateOrder(businessId, order); }
public void CreateRoomTypeWithoutRoomClassThrowsValidationException() { // Arrange const long BUSINESS_ID = 1; var roomTypeManager = new RoomTypeManager(); var ratePlan = new BaseRatePlan { RoomTypeId = 1, MaxOccupancy = 4, MaxAdults = 4, MaxChildren = 2, }; var roomType = new RoomType { BusinessId = BUSINESS_ID, RoomClass = new RoomClass(), QualityType = new QualityType { Code = "CTG" }, BathroomType = new BathroomType { Code = "PB" }, Aspect = new Aspect { Code = "CVW" }, ServiceFrequency = new EnumEntity { Code = ServiceFrequencyEnum.Daily.GetCode() }, BaseRatePlan = ratePlan }; try { // Act roomTypeManager.CreateRoomTypeAndBaseRatePlan(roomType); // Assert Assert.Fail("An exception SRVEX30063 of type ValidationException should have been thrown"); } catch (ValidationException ex) { // Assert Assert.AreEqual(Errors.SRVEX30063.ToString(), ex.Code, "The Validation exception is not returning the right error code"); } }
/// <summary> /// Set Attributes on AIG product /// </summary> /// <param name="roomType">Room Type</param> /// <param name="checkinTime">Checkin Time</param> /// <param name="checkoutTime">Checkout Time</param> /// <returns>AIGProduct</returns> private static AIGProduct SetAigProductAttributes(RoomType roomType, string checkinTime, string checkoutTime) { var checkInTime = string.IsNullOrEmpty(checkinTime) ? DEFAULT_CHECKIN_TIME : Int32.Parse(checkinTime); var checkOutTime = string.IsNullOrEmpty(checkoutTime) ? DEFAULT_CHECKOUT_TIME : Int32.Parse(checkoutTime); return AIGProduct.CreateProductAttributesOnly(roomType.ProductId, ProductCategoryType.ServicedAccomodation, roomType.Name, roomType.MaxOccupancy, roomType.MaxAdults, 1, roomType.MaxChildren, checkInTime, checkOutTime, null); }
public void ModifyRoomTypeAndBaseRatePlanPopulatedRoomTypeIdAndRatePlanId() { // Arrange const long BUSINESS_ID = 1; var roomTypeDao = new Mock<IRoomTypeDao>(); var ratePlanManager = new Mock<IRatePlanManager>(); var eventTrackingManager = new Mock<IEventTrackingManager>(); var roomTypeManager = new RoomTypeManager { RoomTypeDao = roomTypeDao.Object, RatePlanManager = ratePlanManager.Object, EventTrackingManager = eventTrackingManager.Object }; var ratePlan = new BaseRatePlan { MaxOccupancy = 4, MaxAdults = 2, MaxChildren = 2, RatePlanType = new RatePlanType { Type = RatePlanTypeEnum.Base }, BoardBasis = new BoardBasis { Code = "BK" }, CancellationClass = new CancellationClass { Code = "FR" } }; var roomType = new RoomType { Id = 1, BusinessId = BUSINESS_ID, RoomClass = new RoomClass { Code = "DBL" }, QualityType = new QualityType { Code = "CTG" }, BathroomType = new BathroomType { Code = "PB" }, Aspect = new Aspect { Code = "CVW" }, BaseRatePlan = ratePlan }; CacheHelper.StubRoomTypeCacheWithRoomType(roomType); roomTypeDao.Setup(rt => rt.DoesRoomTypeExist(roomType)).Returns(false); roomTypeDao.Setup(rt => rt.Modify(roomType)); ratePlanManager.Setup(rp => rp.ModifyBaseRatePlan(roomType.BaseRatePlan)); eventTrackingManager.Setup(be => be.CreateBusinessEventAsync(BUSINESS_ID, BusinessEventTypesEnum.RoomTypeModified, roomType.Id.ToString(CultureInfo.InvariantCulture), null)); // Act roomTypeManager.ModifyRoomTypeAndBaseRatePlan(roomType); // Assert roomTypeDao.VerifyAll(); ratePlanManager.VerifyAll(); eventTrackingManager.VerifyAll(); // Make sure these are reset for future tests roomTypeManager.RoomTypeDao = new RoomTypeDao(); roomTypeManager.RatePlanManager = new RatePlanManager(); roomTypeManager.EventTrackingManager = new EventTrackingManager(); CacheHelper.ReAssignRoomTypeDaoToRoomTypeCache(); }
/// <summary> /// Get all Rooms for a Room Type /// </summary> /// <param name="roomType">Room Type</param> /// <returns>Array of AIGInventory</returns> private AIGInventory[] ExtractProductsAndThierAvailabiltyByProductType(RoomType roomType) { var roomList = roomManager.GetRoomsByBusinessRoomType(roomType.Id, roomType.BusinessId); IList<AIGInventory> roomsList = new List<AIGInventory>(); if (roomList != null && roomList.Count != default (int)) { foreach (var interfaceRoom in from room in roomList where room.IsAvailableOnline select CreateInventoryFromRoom(room, roomType)) { roomsList.Add(interfaceRoom); } } return roomsList.ToArray(); }
public void ModifyRoomTypeWhereRoomTypeExistsThrowsValidationException() { // Arrange var roomTypeDao = MockRepository.GenerateMock<IRoomTypeDao>(); var roomTypeManager = new RoomTypeManager { RoomTypeDao = roomTypeDao }; var roomType = new RoomType(); roomTypeDao.Expect(x => x.DoesRoomTypeExist(roomType)).Return(true); try { // Act roomTypeManager.ModifyRoomTypeAndBaseRatePlan(roomType); // Assert Assert.Fail("An exception SRVEX30093 of type ValidationException should have been thrown"); } catch (ValidationException ex) { // Assert Assert.AreEqual(Errors.SRVEX30093.ToString(), ex.Code, "The Validation exception is not returning the right error code"); } }
/// <summary> /// Extract and Create Inventory Availability for a room /// </summary> /// <param name="roomId"></param> /// <param name="roomType"></param> /// <returns>InventoryAvailabilityDiaryDateRange object</returns> private InventoryAvailabilityDiaryDateRange ExtractAndCreateInventoryAvailability(int roomId, RoomType roomType) { //always get 1 years worth of availability data var startDate = DateTime.Now.Date; var endDate = startDate.AddYears(1); var extractedRoomAvailability = roomManager.GetAllRoomInventoryByRoomIdBetweenDates(roomId, startDate, endDate); if (extractedRoomAvailability == null || extractedRoomAvailability.Count == default(int)) { Logger.Info(String.Format("No availability found for room {0} for room type {1}", roomId, roomType.Id)); return null; } var inventoryAvailabilityDiaryEntryList = new List<InventoryAvailabilityDiaryEntry>(); foreach (var roomAvailability in extractedRoomAvailability) { var availabilityStatus = roomAvailability.Available ? AvailablilityDiaryEntryType.Available : AvailablilityDiaryEntryType.Unavailable; inventoryAvailabilityDiaryEntryList.Add(new InventoryAvailabilityDiaryEntry(roomAvailability.Date, roomAvailability.Date, availabilityStatus)); } return new InventoryAvailabilityDiaryDateRange(startDate, endDate, inventoryAvailabilityDiaryEntryList.ToArray()); }
public void CreateRoomTypeAndBaseRatePlanPopulatedRoomTypeIdAndRatePlanId() { // Arrange const long BUSINESS_ID = 1; var roomTypeDao = new Mock<IRoomTypeDao>(); var ratePlanDao = new Mock<IBaseRatePlanDao>(); var eventTrackingManager = new Mock<IEventTrackingManager>(); var roomTypeManager = new RoomTypeManager { RoomTypeDao = roomTypeDao.Object, BaseRatePlanDao = ratePlanDao.Object, EventTrackingManager = eventTrackingManager.Object }; var ratePlan = new BaseRatePlan { RoomTypeId = 1, MaxOccupancy = 4, MaxAdults = 2, MaxChildren = 2, RatePlanType = new RatePlanType { Type = RatePlanTypeEnum.Base }, BoardBasis = new BoardBasis { Code = "BK" }, CancellationClass = new CancellationClass { Code = "FR" } }; var roomType = new RoomType { BusinessId = BUSINESS_ID, RoomClass = new RoomClass { Code = "DBL" }, QualityType = new QualityType { Code = "CTG" }, BathroomType = new BathroomType { Code = "PB" }, Aspect = new Aspect { Code = "CVW" }, ServiceFrequency = new EnumEntity { Code = ServiceFrequencyEnum.Daily.GetCode() }, BaseRatePlan = ratePlan }; roomTypeDao.Setup(rt => rt.Create(roomType)).Callback(delegate { roomType.Id = 1; }); ratePlanDao.Setup(rp => rp.Create(roomType.BaseRatePlan)).Callback(delegate { ratePlan.Id = 1; }); eventTrackingManager.Setup(be => be.CreateBusinessEventAsync(BUSINESS_ID, BusinessEventTypesEnum.RoomTypeAdded, roomType.Id.ToString(CultureInfo.InvariantCulture), null)); eventTrackingManager.Setup(be => be.CreateBusinessEventAsync(BUSINESS_ID, BusinessEventTypesEnum.RatePlanAdded, ratePlan.Id.ToString(CultureInfo.InvariantCulture), null)); CacheHelper.StubRatePlanViewCacheWithRatePlanViews(BUSINESS_ID, new List<RatePlanView>()); // Act roomTypeManager.CreateRoomTypeAndBaseRatePlan(roomType); // Assert Assert.AreNotEqual(default(int), roomType.Id, "The room type id was not attributed."); Assert.AreNotEqual(default(int), ratePlan.Id, "The rate plan id was not attributed."); roomTypeDao.VerifyAll(); ratePlanDao.VerifyAll(); eventTrackingManager.VerifyAll(); // Make sure these are reset for future tests roomTypeManager.RoomTypeDao = new RoomTypeDao(); CacheHelper.ReAssignRatePlanDaoToRatePlanViewCache(); }
public void ModifyRoomTypeWithInvalidIdThrowsException() { // Arrange var roomType = new RoomType { Id = 2, BusinessId = 2, RoomClass = new RoomClass { Code = "DBL" }, QualityType = new QualityType { Code = "CTG" }, BathroomType = new BathroomType { Code = "PB" }, Aspect = new Aspect { Code = "CVW" } }; // Act roomTypeDao.Modify(roomType); }
public void GetRoomTypesAndBaseRatePlansIsSuccessful() { // Arrange const string CULTURE_CODE = "en-GB"; const long BUSINESS_ID = 1; var roomTypeDao = MockRepository.GenerateMock<IRoomTypeDao>(); var baseRatePlanDao = MockRepository.GenerateMock<IBaseRatePlanDao>(); var roomDao = MockRepository.GenerateMock<IRoomDao>(); var roomTypeManager = new RoomTypeManager { RoomTypeDao = roomTypeDao, BaseRatePlanDao = baseRatePlanDao, RoomDao = roomDao }; var roomType = new RoomType { Id = 1 }; roomTypeDao.Expect(x => x.GetAllActiveForBusiness(BUSINESS_ID)).Return(new List<RoomType> { roomType }); baseRatePlanDao.Expect(x => x.GetByRoomTypeId(roomType.Id, BUSINESS_ID, CULTURE_CODE)).Return(new BaseRatePlan()); roomDao.Expect(x => x.GetByRoomTypeId(roomType.Id, BUSINESS_ID)).Return(new List<Room>()); // Act roomTypeManager.GetRoomTypesAndBaseRatePlans(BUSINESS_ID, CULTURE_CODE); // Assert roomTypeDao.VerifyAllExpectations(); baseRatePlanDao.VerifyAllExpectations(); roomDao.VerifyAllExpectations(); }
public void DoesRoomTypeExistWithExistingRoomTypeReturnsTrueIsSuccessful() { // Arrange var roomType = new RoomType { BusinessId = 1, RoomClass = new RoomClass { Code = "DBL" }, QualityType = new QualityType { Code = "CTG" }, BathroomType = new BathroomType { Code = "PB" }, Aspect = new Aspect { Code = "CVW" } }; // Act bool doesRoomTypeExist = roomTypeDao.DoesRoomTypeExist(roomType); // Assert Assert.IsTrue(doesRoomTypeExist, "Room type should exist"); }
public void GetRoomTypeIsSuccessful() { // Arrange const string CULTURE_CODE = "en-GB"; const long BUSINESS_ID = 1; var roomTypeDao = new Mock<IRoomTypeDao>(); var baseRatePlanDao = new Mock<IBaseRatePlanDao>(); var variantRatePlanDao = new Mock<IVariantRatePlanDao>(); var promotionManager = new Mock<IPromotionManager>(); var roomTypeManager = new RoomTypeManager { RoomTypeDao = roomTypeDao.Object, BaseRatePlanDao = baseRatePlanDao.Object, VariantRatePlanDao = variantRatePlanDao.Object, PromotionManager = promotionManager.Object }; var roomType = new RoomType { Id = 1 }; roomTypeDao.Setup(x => x.GetByKey(roomType.Id)).Returns(roomType); var mockBaseRate = new BaseRatePlan(); var mockVariants = new List<VariantRatePlan>(); baseRatePlanDao.Setup(x => x.GetByRoomTypeId(roomType.Id, BUSINESS_ID, CULTURE_CODE)).Returns(mockBaseRate); variantRatePlanDao.Setup(x => x.GetByRoomTypeId(roomType.Id, BUSINESS_ID, CULTURE_CODE)) .Returns(mockVariants); promotionManager.Setup(x => x.AssignAndGetPromotionsForBaseRatePlan(mockBaseRate, BUSINESS_ID)); promotionManager.Setup(x => x.AssignAndGetPromotionsForRatePlans(mockVariants, BUSINESS_ID)); // Act roomTypeManager.GetRoomType(roomType.Id, BUSINESS_ID, CULTURE_CODE); // Assert roomTypeDao.VerifyAll(); baseRatePlanDao.VerifyAll(); variantRatePlanDao.VerifyAll(); promotionManager.VerifyAll(); }
public void CreateRoomTypeWithInvalidBusinessIdThrowsException() { // Arrange // Create room type var roomType = new RoomType { BusinessId = 2, RoomClass = new RoomClass { Code = "DBL" }, QualityType = new QualityType { Code = "CTG" }, BathroomType = new BathroomType { Code = "PB" }, Aspect = new Aspect { Code = "CVW" }, ServiceFrequency = new EnumEntity { Code = ServiceFrequencyEnum.Daily.GetCode() } }; // Act roomTypeDao.Create(roomType); }
/// <summary> /// Finds the max occupancy (OTA NumberOfGuests) for a given rate plan. /// /// Note this takes into account that 'same as base' setting on variant /// rate plans need to be determined from the base rate plan. /// </summary> /// <param name="roomType">containing the base and variant rate plans.</param> /// <param name="ratePlanId">to find the number of guests for.</param> /// <returns></returns> private int FindNumberOfGuests(RoomType roomType, int ratePlanId) { try { RatePlan baseRatePlan = roomType.BaseRatePlan; if (baseRatePlan != null && baseRatePlan.Id == ratePlanId) { return baseRatePlan.MaxOccupancy.Value; } foreach (RatePlan plan in roomType.VariantRatePlans) { if (plan.Id != ratePlanId) continue; if (plan.MaxOccupancy == null) return baseRatePlan.MaxOccupancy.Value; return plan.MaxOccupancy.Value; } throw new Exception(String.Format("Failed to find the MaxOccupancy for rate plan: '{0}' and room type: '{1}'", ratePlanId, roomType.Id)); } catch(Exception ex) { throw new Exception(String.Format("Failed to determine the MaxOccupancy for rate plan: '{0}' and room type: '{1}'", ratePlanId, roomType.Id), ex); } }