public List <Dictionary <RoomOccupationRequest, List <Room> > > GetGroupedAvailableRooms(AvailabilityRequest availabilityRequest, List <Accommodation> accommodations)
        {
            var occupationRequest         = availabilityRequest.Rooms;
            var groupedAccommodationRooms = new List <Dictionary <RoomOccupationRequest, List <Room> > >();

            foreach (var accommodation in accommodations)
            {
                var groupedRooms = GroupAccommodationRooms(accommodation);
                if (groupedRooms.Any())
                {
                    groupedAccommodationRooms.Add(groupedRooms);
                }
            }

            return(groupedAccommodationRooms);


            Dictionary <RoomOccupationRequest, List <Room> > GroupAccommodationRooms(Accommodation accommodation)
            {
                var roomsGroupedByOccupationRequest = new Dictionary <RoomOccupationRequest, List <Room> >();

                var availableRooms = accommodation.Rooms
                                     .Where(room => AvailabilityHelper.IsRoomAvailableByAllotment(availabilityRequest, room))
                                     .Where(room => !DoesRoomHaveStopSaleAvailabilityRestriction(room))
                                     .Where(room => room.RoomRates.Any()).ToList();

                foreach (var occupationRequestItem in occupationRequest)
                {
                    foreach (var room in availableRooms)
                    {
                        if (IsRoomCompatibleWithOccupancyRequestItem(room, occupationRequestItem))
                        {
                            AddRoomToOccupationRequestGroup(occupationRequestItem, room);
                        }
                    }
                }

                return(roomsGroupedByOccupationRequest);


                void AddRoomToOccupationRequestGroup(RoomOccupationRequest occupationRequestItem, Room room)
                {
                    if (!roomsGroupedByOccupationRequest.ContainsKey(occupationRequestItem))
                    {
                        roomsGroupedByOccupationRequest.Add(occupationRequestItem, new List <Room> {
                            room
                        });
                    }
                    else
                    {
                        roomsGroupedByOccupationRequest[occupationRequestItem].Add(room);
                    }
                }
            }
        }
示例#2
0
        public List <List <RateDetails> > GenerateSets(AvailabilityRequest availabilityRequest, Dictionary <RoomOccupationRequest, List <RateDetails> > availableRateDetails)
        {
            var rateDetailsSet = ListHelper.GetCombinations(availableRateDetails.Select(rateDetails => rateDetails.Value).ToList())
                                 .Distinct()
                                 .ToList();

            FilterRoomDuplicatesByAllotment();
            rateDetailsSet = OrderByMinTotalPrice();

            return(rateDetailsSet);


            void FilterRoomDuplicatesByAllotment()
            {
                ListHelper.RemoveIfNot(rateDetailsSet, IsRateDetailsAvailableByAllotment);
            }

            bool IsRateDetailsAvailableByAllotment(List <RateDetails> rateDetails)
            {
                foreach (var roomGroup in rateDetails.GroupBy(rd => rd.Room))
                {
                    var roomsNumber = roomGroup.ToList().Count;
                    if (roomsNumber == 1)
                    {
                        continue;
                    }
                    if (!AvailabilityHelper.IsRoomAvailableByAllotment(availabilityRequest, roomGroup.Key, roomsNumber))
                    {
                        return(false);
                    }
                }

                return(true);
            }

            List <List <RateDetails> > OrderByMinTotalPrice()
            => rateDetailsSet.OrderBy(rds => rds.Sum(rd => rd.PaymentDetails.TotalAmount.Amount)).ToList();
        }