コード例 #1
0
ファイル: BunkCollection.cs プロジェクト: 842549829/Pool
 /// <summary>
 /// 查询舱位信息
 /// </summary>
 /// <param name="airline">航空公司</param>
 /// <param name="departure">出发</param>
 /// <param name="arrival">到达</param>
 /// <param name="flightDate">航班日期</param>
 /// <param name="code">舱位代码</param>
 /// <param name="itineraryType">行程类型</param>
 /// <param name="travelType">旅行类型</param>
 /// <param name="passengerType">旅客类型</param>
 public IEnumerable <Bunk> QueryBunk(UpperString airline, UpperString departure, UpperString arrival, DateTime flightDate, UpperString code,
                                     VoyageTypeValue itineraryType, TravelTypeValue travelType, PassengerTypeValue passengerType)
 {
     return(QueryBunk(airline, departure, arrival, flightDate, code).Where(bunk => bunk != null &&
                                                                           (bunk.VoyageType & itineraryType) == itineraryType &&
                                                                           (bunk.PassengerType & passengerType) == passengerType &&
                                                                           (bunk.TravelType & travelType) == travelType).ToList());
     //var bunk = QueryBunk(airline, departure, arrival, flightDate, code);
     //if(bunk != null
     //    && (bunk.VoyageType & itineraryType) == itineraryType
     //    && (bunk.PassengerType & passengerType) == passengerType
     //    && (bunk.TravelType & travelType) == travelType) {
     //    return bunk;
     //}
     //return null;
 }
コード例 #2
0
        private static Bunk chooseBunk(IEnumerable <Bunk> bunks, VoyageTypeValue voyageType, decimal YBPrice, PriceView price)
        {
            if (bunks.Any(b => b is Service.Foundation.Domain.GeneralBunk) &&
                bunks.Any(b => b is Service.Foundation.Domain.PromotionBunk))
            {
                var generalBunk = bunks.FirstOrDefault(b => b is GeneralBunk) as GeneralBunk;
                if (price == null)
                {
                    return(generalBunk);
                }
                decimal nomalPrice = Utility.Calculator.Round(generalBunk.GetDiscount(generalBunk.Code.Value) * YBPrice, 1);
                if (price.Fare >= nomalPrice)
                {
                    return(generalBunk);
                }
                return(bunks.FirstOrDefault(b => b is PromotionBunk));
            }
            if (bunks.Count() < 2)
            {
                return(bunks.FirstOrDefault());
            }
            switch (voyageType)
            {
            case VoyageTypeValue.OneWay:
                var generalBunk = bunks.FirstOrDefault(b => b is Service.Foundation.Domain.GeneralBunk);
                if (generalBunk == null)
                {
                    return(bunks.First());
                }
                return(generalBunk);

            case VoyageTypeValue.RoundTrip:
                var productionBunk = bunks.FirstOrDefault(b => b is Service.Foundation.Domain.ProductionBunk);
                if (productionBunk == null)
                {
                    return(bunks.First());
                }
                return(productionBunk);

            default:
                return(bunks.First());
            }
        }
コード例 #3
0
        //private IEnumerable<string> QueryTeamBunks(string airline, DateTime startTime, DateTime endTime, DateTime startEtdzDate)
        //{
        //    var result = new List<string>();

        //    var list = (from item in FoundationService.Bunks
        //                where item.Valid
        //                    && item.AirlineCode.Value == airline
        //                    && item.FlightBeginDate.Date <= startTime.Date
        //                    && (!item.FlightEndDate.HasValue || item.FlightEndDate.Value.Date >= endTime.Date)
        //                    && item.ETDZDate.Date <= startEtdzDate.Date
        //                    && item is TeamBunk
        //                select new
        //                {
        //                    Bunk = item.Code.Value
        //                }).OrderBy(item => item.Bunk);
        //    foreach (var item in list)
        //    {
        //        if (!result.Contains(item.Bunk))
        //        {
        //            result.Add(item.Bunk);
        //        }
        //    }
        //    return result;
        //}
        private IEnumerable <string> QueryTeamBunks(string airline, DateTime startTime, DateTime endTime, DateTime startETDZDate, VoyageTypeValue voyage)
        {
            var bunkslist = FoundationService.Bunks;

            if (voyage != VoyageTypeValue.TransitWay)
            {
                var result  = new Dictionary <string, decimal>();
                var result1 = new List <string>();
                var bunks   = (from item in bunkslist
                               let normalBunk = item as GeneralBunk
                                                where normalBunk != null &&
                                                normalBunk.Valid &&
                                                (normalBunk.AirlineCode.IsNullOrEmpty() || normalBunk.AirlineCode.Value == airline) &&
                                                normalBunk.FlightBeginDate.Date <= startTime.Date &&
                                                (!normalBunk.FlightEndDate.HasValue || normalBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                                normalBunk.ETDZDate.Date <= startETDZDate.Date &&
                                                ((normalBunk.VoyageType & voyage) == voyage) &&
                                                ((normalBunk.TravelType & TravelTypeValue.Team) == TravelTypeValue.Team) &&
                                                ((normalBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                                orderby normalBunk.Discount descending
                                                select normalBunk).ToList();
                foreach (var bunk in bunks)
                {
                    if (!result.ContainsKey(bunk.Code.Value))
                    {
                        result.Add(bunk.Code.Value, bunk.Discount);
                    }
                    foreach (var extend in bunk.Extended)
                    {
                        if (!result.ContainsKey(extend.Code.Value))
                        {
                            result.Add(extend.Code.Value, extend.Discount);
                        }
                    }
                }
                if (voyage == VoyageTypeValue.OneWay)
                {
                    var bunks1 = (from item in bunkslist
                                  let bargainBunk = item as PromotionBunk
                                                    where bargainBunk != null &&
                                                    (bargainBunk.Valid &&
                                                     bargainBunk.AirlineCode.Value == airline &&
                                                     bargainBunk.FlightBeginDate.Date <= startTime.Date &&
                                                     (!bargainBunk.FlightEndDate.HasValue || bargainBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                                     bargainBunk.ETDZDate.Date <= startETDZDate.Date) &&
                                                    ((bargainBunk.TravelType & TravelTypeValue.Team) == TravelTypeValue.Team) &&
                                                    ((bargainBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                                    select bargainBunk);
                    foreach (var item in bunks1)
                    {
                        if (!result1.Contains(item.Code.Value))
                        {
                            result1.Add(item.Code.Value);
                        }
                        foreach (var extended in item.Extended)
                        {
                            if (!result1.Contains(extended))
                            {
                                result1.Add(extended);
                            }
                        }
                    }
                }
                else if (voyage == VoyageTypeValue.RoundTrip)
                {
                    var bunks1 = (from item in bunkslist
                                  let bargainBunk = item as ProductionBunk
                                                    where bargainBunk != null &&
                                                    (bargainBunk.Valid &&
                                                     bargainBunk.AirlineCode.Value == airline &&
                                                     bargainBunk.FlightBeginDate.Date <= startTime.Date &&
                                                     (!bargainBunk.FlightEndDate.HasValue || bargainBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                                     bargainBunk.ETDZDate.Date <= startETDZDate.Date) &&
                                                    ((bargainBunk.TravelType & TravelTypeValue.Team) == TravelTypeValue.Team) &&
                                                    ((bargainBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                                    select bargainBunk);
                    foreach (var item in bunks1)
                    {
                        if (!result1.Contains(item.Code.Value))
                        {
                            result1.Add(item.Code.Value);
                        }
                    }
                }
                var result2 = (from bunk in result
                               orderby bunk.Value descending
                               select bunk.Key).ToList();
                foreach (var item in result1)
                {
                    if (!result2.Contains(item))
                    {
                        result2.Add(item);
                    }
                }
                return(result2);
            }
            else
            {
                var result  = new Dictionary <string, decimal>();
                var result1 = new List <string>();
                var bunks   = (from item in bunkslist
                               let normalBunk = item as GeneralBunk
                                                where normalBunk != null &&
                                                normalBunk.Valid &&
                                                (normalBunk.AirlineCode.IsNullOrEmpty() || normalBunk.AirlineCode.Value == airline) &&
                                                normalBunk.FlightBeginDate.Date <= startTime.Date &&
                                                (!normalBunk.FlightEndDate.HasValue || normalBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                                normalBunk.ETDZDate.Date <= startETDZDate.Date &&
                                                ((normalBunk.VoyageType & VoyageTypeValue.TransitWay) == VoyageTypeValue.TransitWay) &&
                                                ((normalBunk.TravelType & TravelTypeValue.Team) == TravelTypeValue.Team) &&
                                                ((normalBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                                orderby normalBunk.Discount descending
                                                select normalBunk).ToList();
                foreach (var bunk in bunks)
                {
                    if (!result.ContainsKey(bunk.Code.Value))
                    {
                        result.Add(bunk.Code.Value, bunk.Discount);
                    }
                    foreach (var extend in bunk.Extended)
                    {
                        if (!result.ContainsKey(extend.Code.Value))
                        {
                            result.Add(extend.Code.Value, extend.Discount);
                        }
                    }
                }
                bunks = (from item in bunkslist
                         let normalBunk = item as GeneralBunk
                                          where normalBunk != null &&
                                          normalBunk.Valid &&
                                          (normalBunk.AirlineCode.IsNullOrEmpty() || normalBunk.AirlineCode.Value == airline) &&
                                          normalBunk.FlightBeginDate.Date <= startTime.Date &&
                                          (!normalBunk.FlightEndDate.HasValue || normalBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                          normalBunk.ETDZDate.Date <= startETDZDate.Date &&
                                          ((normalBunk.VoyageType & VoyageTypeValue.OneWayOrRound) == VoyageTypeValue.OneWayOrRound) &&
                                          ((normalBunk.TravelType & TravelTypeValue.Team) == TravelTypeValue.Team) &&
                                          ((normalBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                          orderby normalBunk.Discount descending
                                          select normalBunk).ToList();
                foreach (var bunk in bunks)
                {
                    if (!result.ContainsKey(bunk.Code.Value))
                    {
                        result.Add(bunk.Code.Value, bunk.Discount);
                    }
                    foreach (var extend in bunk.Extended)
                    {
                        if (!result.ContainsKey(extend.Code.Value))
                        {
                            result.Add(extend.Code.Value, extend.Discount);
                        }
                    }
                }
                var bunks1 = (from item in bunkslist
                              let bargainBunk = item as TransferBunk
                                                where bargainBunk != null &&
                                                (bargainBunk.Valid &&
                                                 bargainBunk.AirlineCode.Value == airline &&
                                                 bargainBunk.FlightBeginDate.Date <= startTime.Date &&
                                                 (!bargainBunk.FlightEndDate.HasValue || bargainBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                                 bargainBunk.ETDZDate.Date <= startETDZDate.Date) &&
                                                ((bargainBunk.VoyageType & VoyageTypeValue.TransitWay) == VoyageTypeValue.TransitWay) &&
                                                ((bargainBunk.TravelType & TravelTypeValue.Team) == TravelTypeValue.Team) &&
                                                ((bargainBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                                select bargainBunk);
                foreach (var item in bunks1)
                {
                    if (!result1.Contains(item.Code.Value))
                    {
                        result1.Add(item.Code.Value);
                    }
                }
                bunks1 = (from item in bunkslist
                          let bargainBunk = item as TransferBunk
                                            where bargainBunk != null &&
                                            (bargainBunk.Valid &&
                                             bargainBunk.AirlineCode.Value == airline &&
                                             bargainBunk.FlightBeginDate.Date <= startTime.Date &&
                                             (!bargainBunk.FlightEndDate.HasValue || bargainBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                             bargainBunk.ETDZDate.Date <= startETDZDate.Date) &&
                                            ((bargainBunk.VoyageType & VoyageTypeValue.OneWayOrRound) == VoyageTypeValue.OneWayOrRound) &&
                                            ((bargainBunk.TravelType & TravelTypeValue.Team) == TravelTypeValue.Team) &&
                                            ((bargainBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                            select bargainBunk);
                foreach (var item in bunks1)
                {
                    if (!result1.Contains(item.Code.Value))
                    {
                        result1.Add(item.Code.Value);
                    }
                }

                var result2 = (from bunk in result
                               orderby bunk.Value descending
                               select bunk.Key).ToList();

                foreach (var item in result1)
                {
                    if (!result2.Contains(item))
                    {
                        result2.Add(item);
                    }
                }
                return(result2);
            }
        }
コード例 #4
0
 /// <summary>
 /// 查询舱位信息
 /// </summary>
 /// <param name="airline">航空公司代码</param>
 /// <param name="departure">出发机场代码</param>
 /// <param name="arrival">到达机场代码</param>
 /// <param name="flightDate">航班日期</param>
 /// <param name="bunkCode">舱位代码</param>
 /// <param name="itineraryType">行程类型</param>
 /// <param name="travelType">旅行类型</param>
 /// <param name="passengerType">旅客类型</param>
 public static IEnumerable <Bunk> QueryBunk(string airline, string departure, string arrival, DateTime flightDate, string bunkCode,
                                            VoyageTypeValue itineraryType, TravelTypeValue travelType, PassengerTypeValue passengerType)
 {
     return(BunkCollection.Instance.QueryBunk(airline, departure, arrival, flightDate, bunkCode, itineraryType, travelType, passengerType));
 }
コード例 #5
0
        /// <summary>
        /// 普通政策发布和修改获取舱位查询
        /// </summary>
        /// <returns></returns>
        public object QueryNormalBunksPolicy(string airline, DateTime startTime, DateTime endTime, DateTime startETDZDate, VoyageTypeValue voyage, bool isOneWay)
        {
            if (isOneWay && voyage != VoyageTypeValue.OneWayOrRound)
            {
                var result = new Dictionary <string, decimal>();
                var bunks  = (from item in FoundationService.Bunks
                              let normalBunk = item as GeneralBunk
                                               where normalBunk != null &&
                                               normalBunk.Valid &&
                                               (normalBunk.AirlineCode.IsNullOrEmpty() || normalBunk.AirlineCode.Value == airline) &&
                                               normalBunk.FlightBeginDate.Date <= startTime.Date &&
                                               (!normalBunk.FlightEndDate.HasValue || normalBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                               normalBunk.ETDZDate.Date <= startETDZDate.Date &&
                                               ((normalBunk.VoyageType & voyage) == voyage) &&
                                               ((normalBunk.TravelType & TravelTypeValue.Individual) == TravelTypeValue.Individual) &&
                                               ((normalBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                               orderby normalBunk.Discount descending
                                               select normalBunk).ToList();
                foreach (var bunk in bunks)
                {
                    if (!result.ContainsKey(bunk.Code.Value))
                    {
                        result.Add(bunk.Code.Value, bunk.Discount);
                    }
                    foreach (var extend in bunk.Extended)
                    {
                        if (!result.ContainsKey(extend.Code.Value))
                        {
                            result.Add(extend.Code.Value, extend.Discount);
                        }
                    }
                }
                return((from bunk in result
                        orderby bunk.Value descending
                        select bunk.Key).ToList());
            }
            else if (isOneWay && voyage == VoyageTypeValue.OneWayOrRound)
            {
                var result = new Dictionary <string, decimal>();
                var bunks  = (from item in FoundationService.Bunks
                              let normalBunk = item as GeneralBunk
                                               where normalBunk != null &&
                                               normalBunk.Valid &&
                                               (normalBunk.AirlineCode.IsNullOrEmpty() || normalBunk.AirlineCode.Value == airline) &&
                                               normalBunk.FlightBeginDate.Date <= startTime.Date &&
                                               (!normalBunk.FlightEndDate.HasValue || normalBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                               normalBunk.ETDZDate.Date <= startETDZDate.Date &&
                                               ((normalBunk.VoyageType & VoyageTypeValue.TransitWay) == VoyageTypeValue.TransitWay) &&
                                               ((normalBunk.TravelType & TravelTypeValue.Individual) == TravelTypeValue.Individual) &&
                                               ((normalBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                               orderby normalBunk.Discount descending
                                               select normalBunk).ToList();
                foreach (var bunk in bunks)
                {
                    if (!result.ContainsKey(bunk.Code.Value))
                    {
                        result.Add(bunk.Code.Value, bunk.Discount);
                    }
                    foreach (var extend in bunk.Extended)
                    {
                        if (!result.ContainsKey(extend.Code.Value))
                        {
                            result.Add(extend.Code.Value, extend.Discount);
                        }
                    }
                }
                bunks = (from item in FoundationService.Bunks
                         let normalBunk = item as GeneralBunk
                                          where normalBunk != null &&
                                          normalBunk.Valid &&
                                          (normalBunk.AirlineCode.IsNullOrEmpty() || normalBunk.AirlineCode.Value == airline) &&
                                          normalBunk.FlightBeginDate.Date <= startTime.Date &&
                                          (!normalBunk.FlightEndDate.HasValue || normalBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                          normalBunk.ETDZDate.Date <= startETDZDate.Date &&
                                          ((normalBunk.VoyageType & VoyageTypeValue.OneWayOrRound) == VoyageTypeValue.OneWayOrRound) &&
                                          ((normalBunk.TravelType & TravelTypeValue.Individual) == TravelTypeValue.Individual) &&
                                          ((normalBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                          orderby normalBunk.Discount descending
                                          select normalBunk).ToList();
                foreach (var bunk in bunks)
                {
                    if (!result.ContainsKey(bunk.Code.Value))
                    {
                        result.Add(bunk.Code.Value, bunk.Discount);
                    }
                    foreach (var extend in bunk.Extended)
                    {
                        if (!result.ContainsKey(extend.Code.Value))
                        {
                            result.Add(extend.Code.Value, extend.Discount);
                        }
                    }
                }
                return((from bunk in result
                        orderby bunk.Value descending
                        select bunk.Key).ToList());
            }
            else
            {
                var result = new Dictionary <string, decimal>();

                var bunks = (from item in FoundationService.Bunks
                             let normalBunk = item as GeneralBunk
                                              where normalBunk != null &&
                                              normalBunk.Valid &&
                                              (normalBunk.AirlineCode.IsNullOrEmpty() || normalBunk.AirlineCode.Value == airline) &&
                                              normalBunk.FlightBeginDate.Date <= startTime.Date &&
                                              (!normalBunk.FlightEndDate.HasValue || normalBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                              normalBunk.ETDZDate.Date <= startETDZDate.Date &&
                                              ((normalBunk.VoyageType & VoyageTypeValue.OneWay) == VoyageTypeValue.OneWay) &&
                                              ((normalBunk.TravelType & TravelTypeValue.Individual) == TravelTypeValue.Individual) &&
                                              ((normalBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                              orderby normalBunk.Discount descending
                                              select normalBunk).ToList();
                foreach (var bunk in bunks)
                {
                    if (!result.ContainsKey(bunk.Code.Value))
                    {
                        result.Add(bunk.Code.Value, bunk.Discount);
                    }
                    foreach (var extend in bunk.Extended)
                    {
                        if (!result.ContainsKey(extend.Code.Value))
                        {
                            result.Add(extend.Code.Value, extend.Discount);
                        }
                    }
                }
                bunks = (from item in FoundationService.Bunks
                         let normalBunk = item as GeneralBunk
                                          where normalBunk != null &&
                                          normalBunk.Valid &&
                                          (normalBunk.AirlineCode.IsNullOrEmpty() || normalBunk.AirlineCode.Value == airline) &&
                                          normalBunk.FlightBeginDate.Date <= startTime.Date &&
                                          (!normalBunk.FlightEndDate.HasValue || normalBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                          normalBunk.ETDZDate.Date <= startETDZDate.Date &&
                                          ((normalBunk.VoyageType & VoyageTypeValue.RoundTrip) == VoyageTypeValue.RoundTrip) &&
                                          ((normalBunk.TravelType & TravelTypeValue.Individual) == TravelTypeValue.Individual) &&
                                          ((normalBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                          orderby normalBunk.Discount descending
                                          select normalBunk).ToList();
                foreach (var bunk in bunks)
                {
                    if (!result.ContainsKey(bunk.Code.Value))
                    {
                        result.Add(bunk.Code.Value, bunk.Discount);
                    }
                    foreach (var extend in bunk.Extended)
                    {
                        if (!result.ContainsKey(extend.Code.Value))
                        {
                            result.Add(extend.Code.Value, extend.Discount);
                        }
                    }
                }
                return((from bunk in result
                        orderby bunk.Value descending
                        select bunk.Key).ToList());
            }
        }
コード例 #6
0
        /// <summary>
        /// 团队政策发布和修改获取舱位查询
        /// </summary>
        /// <returns></returns>
        public object QueryTeamBunksPolicy(string airline, DateTime startTime, DateTime endTime, DateTime startETDZDate, VoyageTypeValue voyage)
        {
            var bunkslist = FoundationService.Bunks;

            if (voyage == VoyageTypeValue.TransitWay)
            {
                var result = new List <string>();

                var list = (from item in bunkslist
                            where item.Valid &&
                            item.AirlineCode.Value == airline &&
                            item.FlightBeginDate.Date <= startTime.Date &&
                            (!item.FlightEndDate.HasValue || item.FlightEndDate.Value.Date >= endTime.Date) &&
                            item.ETDZDate.Date <= startETDZDate.Date &&
                            item is TeamBunk &&
                            ((item.VoyageType & VoyageTypeValue.TransitWay) == VoyageTypeValue.TransitWay) &&
                            ((item.TravelType & TravelTypeValue.Team) == TravelTypeValue.Team) &&
                            ((item.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                            select item);
                foreach (var item in list)
                {
                    if (!result.Contains(item.Code.Value))
                    {
                        result.Add(item.Code.Value);
                    }
                }
                list = (from item in bunkslist
                        where item.Valid &&
                        item.AirlineCode.Value == airline &&
                        item.FlightBeginDate.Date <= startTime.Date &&
                        (!item.FlightEndDate.HasValue || item.FlightEndDate.Value.Date >= endTime.Date) &&
                        item.ETDZDate.Date <= startETDZDate.Date &&
                        item is TeamBunk &&
                        ((item.VoyageType & VoyageTypeValue.OneWayOrRound) == VoyageTypeValue.OneWayOrRound) &&
                        ((item.TravelType & TravelTypeValue.Team) == TravelTypeValue.Team) &&
                        ((item.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                        select item);
                foreach (var item in list)
                {
                    if (!result.Contains(item.Code.Value))
                    {
                        result.Add(item.Code.Value);
                    }
                }
                return(result);
            }
            else
            {
                var result = new List <string>();

                var list = (from item in bunkslist
                            where item.Valid &&
                            item.AirlineCode.Value == airline &&
                            item.FlightBeginDate.Date <= startTime.Date &&
                            (!item.FlightEndDate.HasValue || item.FlightEndDate.Value.Date >= endTime.Date) &&
                            item.ETDZDate.Date <= startETDZDate.Date &&
                            item is TeamBunk &&
                            ((item.VoyageType & voyage) == voyage) &&
                            ((item.TravelType & TravelTypeValue.Team) == TravelTypeValue.Team) &&
                            ((item.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                            select item);
                foreach (var item in list)
                {
                    if (!result.Contains(item.Code.Value))
                    {
                        result.Add(item.Code.Value);
                    }
                }
                return(result);
            }
        }
コード例 #7
0
        /// <summary>
        /// 特价政策发布和修改获取舱位查询
        /// </summary>
        /// <returns></returns>
        public object QueryBargainBunksPolicy(string airline, DateTime startTime, DateTime endTime, DateTime startETDZDate, VoyageTypeValue voyageType)
        {
            var bunkslist = FoundationService.Bunks;
            var result    = new List <string>();

            if (voyageType == VoyageTypeValue.OneWay)
            {
                var bunks = (from item in bunkslist
                             let bargainBunk = item as PromotionBunk
                                               where bargainBunk != null &&
                                               (bargainBunk.Valid &&
                                                bargainBunk.AirlineCode.Value == airline &&
                                                bargainBunk.FlightBeginDate.Date <= startTime.Date &&
                                                (!bargainBunk.FlightEndDate.HasValue || bargainBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                                bargainBunk.ETDZDate.Date <= startETDZDate.Date) &&
                                               ((bargainBunk.VoyageType & voyageType) == voyageType) &&
                                               ((bargainBunk.TravelType & TravelTypeValue.Individual) == TravelTypeValue.Individual) &&
                                               ((bargainBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                               select bargainBunk);
                foreach (var item in bunks)
                {
                    if (!result.Contains(item.Code.Value))
                    {
                        result.Add(item.Code.Value);
                    }
                    foreach (var extended in item.Extended)
                    {
                        if (!result.Contains(extended))
                        {
                            result.Add(extended);
                        }
                    }
                }
            }
            else if (voyageType == VoyageTypeValue.RoundTrip)
            {
                var bunks = (from item in bunkslist
                             let bargainBunk = item as PromotionBunk
                                               where bargainBunk != null &&
                                               (bargainBunk.Valid &&
                                                bargainBunk.AirlineCode.Value == airline &&
                                                bargainBunk.FlightBeginDate.Date <= startTime.Date &&
                                                (!bargainBunk.FlightEndDate.HasValue || bargainBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                                bargainBunk.ETDZDate.Date <= startETDZDate.Date) &&
                                               ((bargainBunk.VoyageType & voyageType) == voyageType) &&
                                               ((bargainBunk.TravelType & TravelTypeValue.Individual) == TravelTypeValue.Individual) &&
                                               ((bargainBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                               select bargainBunk);
                foreach (var item in bunks)
                {
                    if (!result.Contains(item.Code.Value))
                    {
                        result.Add(item.Code.Value);
                    }
                    foreach (var extended in item.Extended)
                    {
                        if (!result.Contains(extended))
                        {
                            result.Add(extended);
                        }
                    }
                }
                var bunks1 = (from item in bunkslist
                              let bargainBunk = item as ProductionBunk
                                                where bargainBunk != null &&
                                                (bargainBunk.Valid &&
                                                 bargainBunk.AirlineCode.Value == airline &&
                                                 bargainBunk.FlightBeginDate.Date <= startTime.Date &&
                                                 (!bargainBunk.FlightEndDate.HasValue || bargainBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                                 bargainBunk.ETDZDate.Date <= startETDZDate.Date) &&
                                                ((bargainBunk.VoyageType & voyageType) == voyageType) &&
                                                ((bargainBunk.TravelType & TravelTypeValue.Individual) == TravelTypeValue.Individual) &&
                                                ((bargainBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                                select bargainBunk);
                foreach (var item in bunks1)
                {
                    if (!result.Contains(item.Code.Value))
                    {
                        result.Add(item.Code.Value);
                    }
                }
            }
            else if (voyageType == VoyageTypeValue.TransitWay)
            {
                var bunks = (from item in bunkslist
                             let bargainBunk = item as PromotionBunk
                                               where bargainBunk != null &&
                                               (bargainBunk.Valid &&
                                                bargainBunk.AirlineCode.Value == airline &&
                                                bargainBunk.FlightBeginDate.Date <= startTime.Date &&
                                                (!bargainBunk.FlightEndDate.HasValue || bargainBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                                bargainBunk.ETDZDate.Date <= startETDZDate.Date) &&
                                               ((bargainBunk.VoyageType & VoyageTypeValue.TransitWay) == VoyageTypeValue.TransitWay) &&
                                               ((bargainBunk.TravelType & TravelTypeValue.Individual) == TravelTypeValue.Individual) &&
                                               ((bargainBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                               select bargainBunk);
                foreach (var item in bunks)
                {
                    if (!result.Contains(item.Code.Value))
                    {
                        result.Add(item.Code.Value);
                    }
                    foreach (var extended in item.Extended)
                    {
                        if (!result.Contains(extended))
                        {
                            result.Add(extended);
                        }
                    }
                }
                bunks = (from item in bunkslist
                         let bargainBunk = item as PromotionBunk
                                           where bargainBunk != null &&
                                           (bargainBunk.Valid &&
                                            bargainBunk.AirlineCode.Value == airline &&
                                            bargainBunk.FlightBeginDate.Date <= startTime.Date &&
                                            (!bargainBunk.FlightEndDate.HasValue || bargainBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                            bargainBunk.ETDZDate.Date <= startETDZDate.Date) &&
                                           ((bargainBunk.VoyageType & VoyageTypeValue.OneWayOrRound) == VoyageTypeValue.OneWayOrRound) &&
                                           ((bargainBunk.TravelType & TravelTypeValue.Individual) == TravelTypeValue.Individual) &&
                                           ((bargainBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                           select bargainBunk);
                foreach (var item in bunks)
                {
                    if (!result.Contains(item.Code.Value))
                    {
                        result.Add(item.Code.Value);
                    }
                    foreach (var extended in item.Extended)
                    {
                        if (!result.Contains(extended))
                        {
                            result.Add(extended);
                        }
                    }
                }
                var bunks1 = (from item in bunkslist
                              let bargainBunk = item as TransferBunk
                                                where bargainBunk != null &&
                                                (bargainBunk.Valid &&
                                                 bargainBunk.AirlineCode.Value == airline &&
                                                 bargainBunk.FlightBeginDate.Date <= startTime.Date &&
                                                 (!bargainBunk.FlightEndDate.HasValue || bargainBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                                 bargainBunk.ETDZDate.Date <= startETDZDate.Date) &&
                                                ((bargainBunk.VoyageType & VoyageTypeValue.TransitWay) == VoyageTypeValue.TransitWay) &&
                                                ((bargainBunk.TravelType & TravelTypeValue.Individual) == TravelTypeValue.Individual) &&
                                                ((bargainBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                                select bargainBunk);
                foreach (var item in bunks1)
                {
                    if (!result.Contains(item.Code.Value))
                    {
                        result.Add(item.Code.Value);
                    }
                }
                bunks1 = (from item in bunkslist
                          let bargainBunk = item as TransferBunk
                                            where bargainBunk != null &&
                                            (bargainBunk.Valid &&
                                             bargainBunk.AirlineCode.Value == airline &&
                                             bargainBunk.FlightBeginDate.Date <= startTime.Date &&
                                             (!bargainBunk.FlightEndDate.HasValue || bargainBunk.FlightEndDate.Value.Date >= endTime.Date) &&
                                             bargainBunk.ETDZDate.Date <= startETDZDate.Date) &&
                                            ((bargainBunk.VoyageType & VoyageTypeValue.OneWayOrRound) == VoyageTypeValue.OneWayOrRound) &&
                                            ((bargainBunk.TravelType & TravelTypeValue.Individual) == TravelTypeValue.Individual) &&
                                            ((bargainBunk.PassengerType & PassengerTypeValue.Adult) == PassengerTypeValue.Adult)
                                            select bargainBunk);
                foreach (var item in bunks1)
                {
                    if (!result.Contains(item.Code.Value))
                    {
                        result.Add(item.Code.Value);
                    }
                }
            }
            return((from bunk in result
                    orderby bunk
                    select bunk).ToList());
        }
コード例 #8
0
        private static void setBunkInfo(FlightView flightView, VoyageTypeValue voyageType, PassengerTypeValue passengerType, TravelTypeValue travelType, PriceView patPrice)
        {
            var bunks = Service.FoundationService.QueryBunk(flightView.AirlineCode,
                                                            flightView.Departure.Code, flightView.Arrival.Code,
                                                            flightView.Departure.Time.Date, flightView.BunkCode,
                                                            voyageType, travelType, passengerType);
            //更改退改签规定数据源
            var    pattern           = new Regex("^[a-zA-Z\\d/]+$");
            var    refundDetail      = FoundationService.QueryDetailList(flightView.AirlineCode, flightView.BunkCode).Where(item => pattern.IsMatch(item.Bunks));
            string refundRegulation  = string.Empty;
            string changeRegulation  = string.Empty;
            string endorseRegulation = string.Empty;
            string remark            = string.Empty;

            foreach (var item in refundDetail)
            {
                refundRegulation  += ("航班起飞前:" + item.ScrapBefore + ";航班起飞后:" + item.ScrapAfter).Replace("<br/>", "").Replace("\r", "").Replace("\n", "").Replace("\t", "");
                changeRegulation  += ("航班起飞前:" + item.ChangeBefore + ";航班起飞后:" + item.ChangeAfter).Replace("<br/>", "").Replace("\r", "").Replace("\n", "").Replace("\t", "");
                endorseRegulation += item.Endorse.Replace("<br/>", "").Replace("\r", "").Replace("\n", "").Replace("\t", "");
                remark             = item.Remark.Replace(" ", "").Replace("<br/>", "").Replace("\r", "").Replace("\n", "").Replace("\t", "");
            }
            if (string.IsNullOrWhiteSpace(refundRegulation))
            {
                refundRegulation = "以航司具体规定为准";
            }
            if (string.IsNullOrWhiteSpace(changeRegulation))
            {
                changeRegulation = "以航司具体规定为准";
            }
            foreach (var item in bunks)
            {
                item.RefundRegulation  = refundRegulation;
                item.ChangeRegulation  = changeRegulation;
                item.EndorseRegulation = endorseRegulation;
                item.Remarks           = remark;
            }
            var bunk = chooseBunk(bunks, voyageType, flightView.YBPrice, patPrice);

            if (bunk != null)
            {
                flightView.EI       = bunk.EI;
                flightView.BunkType = bunk.Type;
                // 明折明扣舱
                var generalBunk = bunk as Service.Foundation.Domain.GeneralBunk;
                if (generalBunk != null)
                {
                    var adultDiscount = generalBunk.GetDiscount(flightView.BunkCode);
                    var adultFare     = Utility.Calculator.Round(flightView.YBPrice * adultDiscount, 1);
                    if (passengerType == PassengerTypeValue.Child)
                    {
                        flightView.Discount = Utility.Calculator.Round(adultDiscount / 2, -3);
                        flightView.Fare     = Utility.Calculator.Round(adultFare / 2, 1);
                    }
                    else
                    {
                        flightView.Discount = adultDiscount;
                        flightView.Fare     = adultFare;
                    }
                    var firstBusinessBunk = generalBunk as Service.Foundation.Domain.FirstBusinessBunk;
                    if (firstBusinessBunk != null)
                    {
                        flightView.BunkDescription = firstBusinessBunk.Description;
                    }
                    return;
                }
                // 特价舱
                var promotionBunk = bunk as Service.Foundation.Domain.PromotionBunk;
                if (promotionBunk != null)
                {
                    flightView.BunkDescription = promotionBunk.Description;
                    return;
                }
                // 免票舱
                var freeBunk = bunk as Service.Foundation.Domain.FreeBunk;
                if (freeBunk != null)
                {
                    flightView.BunkDescription = freeBunk.Description;
                    return;
                }
                // 往返产品舱、联程舱、团队舱
                if (bunk is Service.Foundation.Domain.ProductionBunk || bunk is Service.Foundation.Domain.TransferBunk || bunk is Service.Foundation.Domain.TeamBunk)
                {
                    return;
                }
                throw new CustomException("不支持该舱位导入");
            }
            throw new CustomException("未获取到支持该行程的相关舱位信息");
        }
コード例 #9
0
        private static Service.Foundation.Domain.Bunk chooseBunk(IEnumerable <Service.Foundation.Domain.Bunk> bunks, VoyageTypeValue voyageType)
        {
            if (bunks.Count() < 2)
            {
                return(bunks.FirstOrDefault());
            }
            switch (voyageType)
            {
            case VoyageTypeValue.OneWay:
                var generalBunk = bunks.FirstOrDefault(b => b is Service.Foundation.Domain.GeneralBunk);
                if (generalBunk == null)
                {
                    return(bunks.First());
                }
                return(generalBunk);

            case VoyageTypeValue.RoundTrip:
                var productionBunk = bunks.FirstOrDefault(b => b is Service.Foundation.Domain.ProductionBunk);
                if (productionBunk == null)
                {
                    return(bunks.First());
                }
                return(productionBunk);

            default:
                return(bunks.First());
            }
        }