Example #1
0
        /// <summary>
        /// Возвращает список всех отелей
        /// </summary>
        /// <param name="dc">Контекст базы данных</param>
        /// <returns></returns>
        public static List <HotelSmallClass> GetAllHotels(this MtSearchDbDataContext dc)
        {
            List <HotelSmallClass> hotels;

            if ((hotels = CacheHelper.GetCacheItem <List <HotelSmallClass> >(TableName)) != null)
            {
                return(hotels);
            }
            lock (LockHotels)
            {
                if ((hotels = CacheHelper.GetCacheItem <List <HotelSmallClass> >(TableName)) != null)
                {
                    return(hotels);
                }

                hotels = (from h in dc.HotelDictionaries
                          select new HotelSmallClass()
                {
                    Key = h.HD_KEY,
                    Name = h.HD_NAME,
                    RsKey = h.HD_RSKEY,
                    Http = h.HD_HTTP,
                    Stars = h.HD_STARS,
                    CtKey = h.HD_CTKEY,
                    CnKey = h.HD_CNKEY
                })
                         .ToList();

                CacheHelper.AddCacheData(TableName, hotels, TableName);
            }
            return(hotels);
        }
Example #2
0
        /// <summary>
        /// Возвращает список всех accomodation's
        /// </summary>
        /// <param name="dc">Контекст базы данных</param>
        /// <returns></returns>
        public static List <Description> GetAllDescriptions(this MtMainDbDataContext dc)
        {
            List <Description> descriptions;

            if ((descriptions = CacheHelper.GetCacheItem <List <Description> >(TableName)) != null)
            {
                return(descriptions);
            }

            lock (LockDescription)
            {
                if ((descriptions = CacheHelper.GetCacheItem <List <Description> >(TableName)) != null)
                {
                    return(descriptions);
                }
                var descTypes = new[] { AllowCharterBooking, CountryDescription };

                descriptions = (from desc in dc.Descriptions
                                where descTypes.Contains(desc.DS_DTKey.Value)
                                select desc)
                               .ToList <Description>();

                CacheHelper.AddCacheData(TableName, descriptions, TableName);
            }
            return(descriptions);
        }
Example #3
0
        /// <summary>
        /// Возвращает список расписаний
        /// </summary>
        /// <param name="dc">Контекст базы данных</param>
        /// <returns></returns>
        public static List <AirSeason> GetAllAirSeasons(this MtSearchDbDataContext dc)
        {
            List <AirSeason> airSeasons;

            if ((airSeasons = CacheHelper.GetCacheItem <List <AirSeason> >(TableName)) != default(List <AirSeason>))
            {
                return(airSeasons);
            }

            lock (LockAirSeasons)
            {
                if ((airSeasons = CacheHelper.GetCacheItem <List <AirSeason> >(TableName)) != default(List <AirSeason>))
                {
                    return(airSeasons);
                }

                airSeasons = (from a in dc.AirSeasons
                              where a.AS_DATETO >= DateTime.Now.Date
                              select a)
                             .ToList <AirSeason>();

                CacheHelper.AddCacheData(TableName, airSeasons, TableName);
            }

            return(airSeasons);
        }
Example #4
0
        /// <summary>
        /// Возвращает ключ и код национальной валюты
        /// </summary>
        /// <param name="dc"></param>
        /// <returns></returns>
        public static Tuple <int, string> GetNationalRateInfo(this MtSearchDbDataContext dc)
        {
            Tuple <int, string> result;

            var hash = String.Format("{0}", MethodBase.GetCurrentMethod().Name);

            if ((result = CacheHelper.GetCacheItem <Tuple <int, string> >(hash)) != null)
            {
                return(result);
            }

            var rates = dc.GetAllRatesList();

            result = (from r in rates
                      where r.RA_National == 1
                      select new Tuple <int, string>(r.ra_key, r.RA_CODE))
                     .SingleOrDefault();

            CacheHelper.AddCacheData(hash, result, new List <string>()
            {
                TableName
            }, Globals.Settings.Cache.LongCacheTimeout);

            return(result);
        }
Example #5
0
        /// <summary>
        /// Возвращает название тура и его URL
        /// </summary>
        /// <param name="dc">Контекст базы данных</param>
        /// <param name="tourKeys">Ключ тура</param>
        public static IList <Tuple <int, string, string> > GetTourStringsByKeys(this MtSearchDbDataContext dc, IEnumerable <int> tourKeys, out string hash)
        {
            List <Tuple <int, string, string> > result;

            hash = String.Format("{0}_{1}", MethodBase.GetCurrentMethod().Name, String.Join(",", tourKeys));
            if ((result = CacheHelper.GetCacheItem <List <Tuple <int, string, string> > >(hash)) != null)
            {
                return(result);
            }

            string hashOut;
            var    cacheDependencies = new List <string>();
            var    tours             = dc.GetTPToursByKeys(tourKeys, out hashOut);

            cacheDependencies.Add(hashOut);
            var tourList = dc.GetTurListsByKeys(tours.Select(t => t.TO_TRKey).Distinct().ToList(), out hashOut);

            cacheDependencies.Add(hashOut);

            result = (from tp in tours
                      join tl in tourList on tp.TO_TRKey equals tl.TL_KEY
                      select new Tuple <int, string, string>(tp.TO_Key, tl.TL_NAMEWEB, tl.TL_WEBHTTP))
                     .Distinct()
                     .ToList();

            CacheHelper.AddCacheData(hash, result, cacheDependencies.ToList(), Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
Example #6
0
        /// <summary>
        /// Возвращает список всех отелей
        /// </summary>
        /// <param name="dc">Контекст базы данных</param>
        /// <returns></returns>
        public static List <CityDictionary> GetAllCities(this MtSearchDbDataContext dc)
        {
            List <CityDictionary> cities;

            if ((cities = CacheHelper.GetCacheItem <List <CityDictionary> >(TableName)) != null)
            {
                return(cities);
            }
            lock (LockCities)
            {
                if ((cities = CacheHelper.GetCacheItem <List <CityDictionary> >(TableName)) != null)
                {
                    return(cities);
                }

                cities = (from c in dc.CityDictionaries
                          select c)
                         .ToList <CityDictionary>();
                cities.Add(new CityDictionary()
                {
                    CT_KEY  = 0,
                    CT_NAME = "-Без перелета-"
                });

                CacheHelper.AddCacheData(TableName, cities, TableName);
            }
            return(cities);
        }
Example #7
0
        /// <summary>
        /// Возвращает ключ валюты по ее коду
        /// </summary>
        /// <param name="dc">Контекст базы данных</param>
        /// <param name="rateCode">Код валюты</param>
        /// <returns></returns>
        public static int GetRateKeyByCode(this MtSearchDbDataContext dc, string rateCode)
        {
            int result;

            var hash = String.Format("{0}_{1}", MethodBase.GetCurrentMethod().Name, rateCode);

            if (CacheHelper.IsCacheKeyExists(hash))
            {
                result = CacheHelper.GetCacheItem <int>(hash);
                return(result);
            }

            var rates = dc.GetAllRatesList();

            result = (from r in rates
                      where r.RA_CODE == rateCode
                      select r.ra_key)
                     .SingleOrDefault();

            CacheHelper.AddCacheData(hash, result, new List <string>()
            {
                TableName
            }, Globals.Settings.Cache.LongCacheTimeout);

            return(result);
        }
Example #8
0
        /// <summary>
        /// Возвращает объект типа перелет по его ключу
        /// </summary>
        /// <param name="dc">Контекст БД</param>
        /// <param name="cityKeyFrom">Ключ города "туда"</param>
        /// <param name="cityKeyTo">Ключ города "обратно"</param>
        /// <returns></returns>
        public static IList <Charter> GetChartersByDirection(this MtSearchDbDataContext dc, int cityKeyFrom, int cityKeyTo)
        {
            List <Charter> result;
            var            hash = String.Format("{0}_{1}_{2}", MethodBase.GetCurrentMethod().Name, cityKeyFrom, cityKeyTo);

            if ((result = CacheHelper.GetCacheItem <List <Charter> >(hash)) != default(List <Charter>))
            {
                return(result);
            }

            var cacheDependencies = new List <string>
            {
                String.Format("{0}_{1}_{2}_{3}", CacheHelper.CharterHash, (int)ServiceClass.Flight, cityKeyFrom, cityKeyTo)
            };

            result = (from c in dc.GetAllCharters()
                      where c.CH_CITYKEYFROM == cityKeyFrom &&
                      c.CH_CITYKEYTO == cityKeyTo
                      select c)
                     .ToList();

            cacheDependencies.Add(TableName);

            CacheHelper.AddCacheData(hash, result, cacheDependencies, Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
Example #9
0
        ///// <summary>
        ///// Возвращает список всех hotel room's
        ///// </summary>
        ///// <param name="dc">Контекст базы данных</param>
        ///// <returns></returns>
        //public static List<HotelRoom> GetAllHotelRooms(this MtSearchDbDataContext dc)
        //{
        //    List<HotelRoom> hotelRooms;
        //    if ((hotelRooms = CacheHelper.GetCacheItem<List<HotelRoom>>(TableName)) != null) return hotelRooms;
        //    lock (LockHotelRooms)
        //    {
        //        if ((hotelRooms = CacheHelper.GetCacheItem<List<HotelRoom>>(TableName)) != null) return hotelRooms;

        //        hotelRooms = (from hr in dc.HotelRooms
        //                  select hr)
        //            .ToList<HotelRoom>();

        //        CacheHelper.AddCacheData(TableName, hotelRooms, TableName);
        //    }
        //    return hotelRooms;
        //}

        /// <summary>
        /// Возвращает hotel room по ключам
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="hotelRoomKeys">Ключи hotel room</param>
        /// <param name="hash">Хэш кэша</param>
        /// <returns></returns>
        public static List <HotelRoom> GetHotelRoomByKeys(this MtSearchDbDataContext dc, IEnumerable <int> hotelRoomKeys, out string hash)
        {
            List <HotelRoom> result;

            hash = String.Format("{0}_{1}", MethodBase.GetCurrentMethod().Name, String.Join("_", hotelRoomKeys));
            if ((result = CacheHelper.GetCacheItem <List <HotelRoom> >(hash)) != null)
            {
                return(result);
            }

            result = (from h in dc.HotelRooms
                      where hotelRoomKeys.Contains(h.HR_KEY)
                      select h)
                     .ToList();

            if (!CacheHelper.IsCacheKeyExists(TableName))
            {
                CacheHelper.AddCacheData(TableName, String.Empty, TableName);
            }

            CacheHelper.AddCacheData(hash, result, new List <string>()
            {
                TableName
            }, Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
Example #10
0
        /// <summary>
        /// Получаем направление по ключу перелета
        /// </summary>
        /// <param name="dc">Контекст базы данных</param>
        /// <param name="charterKey">Ключ перелета</param>
        /// <param name="cityKeyFrom">Город отправления</param>
        /// <param name="cityKeyTo">Город прилета</param>
        /// <exception cref="ArgumentNullException"></exception>
        public static void GetCharterCityDirection(this MtSearchDbDataContext dc, int charterKey, out int?cityKeyFrom, out int?cityKeyTo)
        {
            Tuple <int?, int?> result;

            var hash = String.Format("{0}_{1}", MethodBase.GetCurrentMethod().Name, charterKey);

            if ((result = CacheHelper.GetCacheItem <Tuple <int?, int?> >(hash)) != null)
            {
                cityKeyFrom = result.Item1;
                cityKeyTo   = result.Item2;
                return;
            }

            var cacheDependencies = new List <string>
            {
                String.Format("{0}_{1}_{2}", CacheHelper.CharterHash, (int)ServiceClass.Flight, charterKey)
            };

            var charter = dc.GetCharter(charterKey);

            if (charter == null)
            {
                cityKeyFrom = cityKeyTo = null;
            }
            else
            {
                cityKeyFrom = charter.CH_CITYKEYFROM;
                cityKeyTo   = charter.CH_CITYKEYTO;
            }

            var res = new Tuple <int?, int?>(cityKeyFrom, cityKeyTo);

            CacheHelper.AddCacheData(hash, res, cacheDependencies, Globals.Settings.Cache.LongCacheTimeout);
        }
Example #11
0
        /// <summary>
        /// Возвращает список стран
        /// </summary>
        /// <param name="searchDc"></param>
        /// <param name="sftDc"></param>
        /// <param name="countryKey">Ключ страны (опциональный)</param>
        /// <param name="hash"></param>
        /// <returns></returns>
        public static List <Country> GetCountries(this MtSearchDbDataContext searchDc, SftWebDbDataContext sftDc, int?countryKey, out string hash)
        {
            List <Country> result;

            hash = String.Format("{0}_{1}", MethodBase.GetCurrentMethod().Name, countryKey);
            if ((result = CacheHelper.GetCacheItem <List <Country> >(hash)) != null)
            {
                return(result);
            }

            string hashOut;
            var    cacheDependencies = new List <string>();
            var    countries         = searchDc.GetCountriesTo(sftDc, null, out hashOut);

            cacheDependencies.Add(hashOut);
            result = new List <Country>(countries.Count);

            result.AddRange(countryKey == null
                ? countries.Select(c => new Country {
                Id = c.Key, Name = c.Value
            }).ToList()
                : countries.Where(c => c.Key == countryKey.Value)
                            .Select(c => new Country {
                Id = c.Key, Name = c.Value
            })
                            .ToList());
            cacheDependencies.Add(CountriesExtension.TableName);

            CacheHelper.AddCacheData(hash, result, cacheDependencies.ToList(), Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
Example #12
0
        /// <summary>
        /// Питания
        /// </summary>
        /// <param name="searchDc"></param>
        /// <param name="pansionKey">Ключ питания</param>
        /// <param name="hash"></param>
        /// <returns></returns>
        public static List <Meal> GetMeals(this MtSearchDbDataContext searchDc, int?pansionKey, out string hash)
        {
            List <Meal> result;

            hash = String.Format("{0}_{1}", MethodBase.GetCurrentMethod().Name, pansionKey);
            if ((result = CacheHelper.GetCacheItem <List <Meal> >(hash)) != null)
            {
                return(result);
            }

            result = new List <Meal>();
            if (pansionKey == null)
            {
                result.AddRange(searchDc.GetAllPansions().Select(p => new Meal
                {
                    Id   = p.PN_KEY,
                    Name = p.PN_NAME
                }).ToList());
            }
            else
            {
                var pansion = searchDc.GetPansionByKey(pansionKey.Value);
                result.Add(new Meal
                {
                    Id   = pansion.PN_KEY,
                    Name = pansion.PN_NAME
                });
            }

            CacheHelper.AddCacheData(hash, result, new List <string>()
            {
                PansionsExtension.TableName
            }, Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
Example #13
0
        /// <summary>
        /// Возвращает список перелетов туда / обратно
        /// </summary>
        /// <param name="dc">Контекст поисковой БД</param>
        /// <param name="mainDc">Контекст основной БД</param>
        /// <param name="cityKeyFrom">Ключ города вылета</param>
        /// <param name="cityKeyTo">Ключ города прилета</param>
        /// <param name="hash">Хэш кэша</param>
        /// <returns></returns>
        public static IList <Tuple <DateTime, DateTime> > GetFlightDatesTwoWay(this MtSearchDbDataContext dc, MtMainDbDataContext mainDc, int cityKeyFrom, int cityKeyTo, out string hash)
        {
            List <Tuple <DateTime, DateTime> > result;

            hash = String.Format("{0}_{1}_{2}", MethodBase.GetCurrentMethod().Name, cityKeyFrom, cityKeyTo);
            if ((result = CacheHelper.GetCacheItem <List <Tuple <DateTime, DateTime> > >(hash)) != null)
            {
                return(result);
            }

            var    cacheDependencies = new List <string>();
            string hashOut;

            var packets = mainDc.GetFlightPackets(dc, out hashOut)
                          .Where(p => p.Item2 == PacketType.TwoWayCharters)
                          .ToList();

            cacheDependencies.Add(hashOut);

            var schedule = dc.GetFlightSchedules(mainDc, packets, out hashOut);

            cacheDependencies.Add(hashOut);

            result = schedule.Schedule.Where(s => s.FlightParamsFrom != null && s.FlightParamsTo != null &&
                                             s.FlightParamsTo.CityKeyFrom == cityKeyFrom &&
                                             s.FlightParamsTo.CityKeyTo == cityKeyTo &&
                                             s.FlightParamsFrom.CityKeyFrom == cityKeyTo &&
                                             s.FlightParamsFrom.CityKeyTo == cityKeyFrom)
                     .Select(s => new Tuple <DateTime, DateTime>(s.FlightParamsTo.DepartTime.Date, s.FlightParamsFrom.DepartTime.Date))
                     .Distinct()
                     .ToList();

            CacheHelper.AddCacheData(hash, result, cacheDependencies.ToList(), Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
Example #14
0
        /// <summary>
        /// Возвращает список стран прилета
        /// </summary>
        /// <param name="dc">Контекст поисковой БД</param>
        /// <param name="mainDc">Контекст основной БД</param>
        /// <param name="isOneWay">Является ли перелет в одну сторону или туда/обратно</param>
        /// <param name="cityKeyFrom">Ключ города вылета</param>
        /// <param name="hash">Хэш кэша</param>
        /// <returns></returns>
        public static IList <Tuple <int, string> > GetFlightCountriesTo(this MtSearchDbDataContext dc, MtMainDbDataContext mainDc, bool isOneWay, int cityKeyFrom, out string hash)
        {
            List <Tuple <int, string> > result;

            hash = String.Format("{0}_{1}_{2}", MethodBase.GetCurrentMethod().Name, isOneWay, cityKeyFrom);
            if ((result = CacheHelper.GetCacheItem <List <Tuple <int, string> > >(hash)) != null)
            {
                return(result);
            }

            var    cacheDependencies = new List <string>();
            string hashOut;
            var    cities = dc.GetFlightCitiesTo(mainDc, isOneWay, null, cityKeyFrom, out hashOut);

            cacheDependencies.Add(hashOut);

            result = (from cn in dc.GetAllCountries()
                      join ct in dc.GetAllCities() on cn.CN_KEY equals ct.CT_CNKEY
                      where cities.Select(c => c.Item1).ToList().Contains(ct.CT_KEY)
                      select new Tuple <int, string>(cn.CN_KEY, cn.CN_NAME))
                     .Distinct()
                     .OrderBy(c => c.Item2)
                     .ToList();
            cacheDependencies.Add(CitiesExtension.TableName);
            cacheDependencies.Add(CountriesExtension.TableName);

            CacheHelper.AddCacheData(hash, result, cacheDependencies.ToList(), Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
Example #15
0
        /// <summary>
        /// Категории отелей
        /// </summary>
        /// <param name="mainDc"></param>
        /// <param name="categoryKey">Ключ категории</param>
        /// <param name="hash"></param>
        /// <returns></returns>
        public static List <HotelCategory> GetHotelCategories(this MtMainDbDataContext mainDc, int?categoryKey, out string hash)
        {
            List <HotelCategory> result;

            hash = String.Format("{0}_{1}", MethodBase.GetCurrentMethod().Name, categoryKey);
            if ((result = CacheHelper.GetCacheItem <List <HotelCategory> >(hash)) != null)
            {
                return(result);
            }

            result = new List <HotelCategory>();
            if (categoryKey == null)
            {
                result.AddRange(mainDc.GetAllHotelCats().Select(c => new HotelCategory
                {
                    Id   = c.COH_Id,
                    Name = c.COH_Name
                }).ToList());
            }
            else
            {
                var hotelCat = mainDc.GetHotelCatByKey(categoryKey.Value);
                result.Add(new HotelCategory
                {
                    Id   = hotelCat.COH_Id,
                    Name = hotelCat.COH_Name
                });
            }

            CacheHelper.AddCacheData(hash, result, new List <string>()
            {
                HotelCategoriesExtension.TableName
            }, Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
        /// <summary>
        /// Возвращает список вариантов ответов по туристу
        /// </summary>
        /// <param name="dc">Контекст БД</param>
        /// <param name="touristKey">КЛюч туриста</param>
        /// <param name="hash">Хэш кэша</param>
        /// <returns></returns>
        public static IEnumerable <QuestionnaireTouristCase> GetQuestCasesByTourist(this MtMainDbDataContext dc, int touristKey, out string hash)
        {
            List <QuestionnaireTouristCase> result;

            hash = String.Format("{0}_{1}", MethodBase.GetCurrentMethod().Name, touristKey);
            if ((result = CacheHelper.GetCacheItem <List <QuestionnaireTouristCase> >(hash)) != null)
            {
                return(result);
            }

            result = (from q in dc.QuestionnaireTouristCases
                      where q.QTC_TUKey == touristKey
                      select q)
                     .ToList();

            if (!CacheHelper.IsCacheKeyExists(TableName))
            {
                CacheHelper.AddCacheData(TableName, String.Empty, TableName);
            }

            CacheHelper.AddCacheData(hash, result, new List <string>()
            {
                TableName
            }, Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
Example #17
0
        /// <summary>
        /// Получение списка параметров для квоты "мало" по классам услуг
        /// </summary>
        /// <param name="dc">Контекст базы данных</param>
        /// <returns></returns>
        public static Dictionary <uint, QuotaSmallServiceParams> GetQuotaSmallServiceParams(this MtSearchDbDataContext dc)
        {
            Dictionary <uint, QuotaSmallServiceParams> serviceSmallParams;
            const string hash = "ServiceSmallParams";

            if ((serviceSmallParams = CacheHelper.GetCacheItem <Dictionary <uint, QuotaSmallServiceParams> >(hash)) != default(Dictionary <uint, QuotaSmallServiceParams>))
            {
                return(serviceSmallParams);
            }

            serviceSmallParams = (from s in dc.GetAllServices()
                                  where (s.SV_KEY == 1 || s.SV_KEY == 3)
                                  select s
                                  )
                                 .ToDictionary(s => (uint)s.SV_KEY, s => new QuotaSmallServiceParams
            {
                AndParam     = s.SV_LittleAnd.HasValue && s.SV_LittleAnd.Value,
                PercentParam = (double?)s.SV_LittlePercent,
                PlaceParam   = (uint?)s.SV_LittlePlace
            });

            CacheHelper.AddCacheData(hash, serviceSmallParams, new List <string>()
            {
                TableName
            }, Globals.Settings.Cache.LongCacheTimeout);

            return(serviceSmallParams);
        }
Example #18
0
        /// <summary>
        /// Является ли значение типом мало
        /// </summary>
        /// <param name="dc">Контекст базы данных</param>
        /// <param name="serviceClass">Класс услуги</param>
        /// <param name="quotaExistCount">Число оставшихся квот</param>
        /// <param name="quotaAllCount">Число квот всего</param>
        /// <param name="hash">Хэш кэша</param>
        /// <returns></returns>
        public static bool IsSmallQuotaState(this MtSearchDbDataContext dc, ServiceClass serviceClass, uint quotaExistCount, uint quotaAllCount, out string hash)
        {
            hash = String.Format("{0}_{1}_{2}_{3}", MethodBase.GetCurrentMethod().Name, serviceClass, quotaExistCount, quotaAllCount);
            if (CacheHelper.IsCacheKeyExists(hash))
            {
                var result = CacheHelper.GetCacheItem <bool>(hash);
                return(result);
            }

            QuotaSmallServiceParams pars = dc.GetQuotaSmallServiceParams()[(uint)serviceClass];

            if (pars == null)
            {
                throw new ApplicationException("Ошибка метода: " + MethodBase.GetCurrentMethod().Name + "_" + serviceClass);
            }

            bool res;
            bool?placeCondition   = null;
            bool?percentCondition = null;

            if (pars.PlaceParam.HasValue)
            {
                placeCondition = quotaExistCount <= pars.PlaceParam.Value;
            }
            if (pars.PercentParam.HasValue)
            {
                percentCondition = (quotaExistCount / (double)quotaAllCount) * 100 <= pars.PercentParam.Value;
            }

            if (pars.AndParam)
            {
                if (placeCondition.HasValue && placeCondition.Value == false ||
                    percentCondition.HasValue && percentCondition.Value == false)
                {
                    res = false;
                }
                else
                {
                    res = true;
                }
            }
            else
            {
                if (placeCondition.HasValue && placeCondition.Value ||
                    percentCondition.HasValue && percentCondition.Value)
                {
                    res = true;
                }
                else
                {
                    res = false;
                }
            }
            CacheHelper.AddCacheData(hash, res, new List <string>()
            {
                TableName
            }, Globals.Settings.Cache.LongCacheTimeout);

            return(res);
        }
Example #19
0
        /// <summary>
        /// Возвращает список всех HotelRooms, по которым заведены цены с заданными параметрами
        /// </summary>
        /// <param name="mainDc">Контекст БД</param>
        /// <param name="serviceClass">Класс услуги</param>
        /// <param name="code">Code услуги</param>
        /// <param name="date">Дата услуги</param>
        /// <param name="packetKey">Ключ пакета</param>
        /// <param name="partnerKey">Ключ партнера</param>
        /// <param name="hash">Хэш кэша</param>
        /// <returns></returns>
        public static List <int> GetHotelRoomsFromCosts(this MtMainDbDataContext mainDc, ServiceClass serviceClass, int code, DateTime date, int packetKey, int partnerKey, out string hash)
        {
            List <int> result;

            hash = String.Format("{0}_{1}_{2}_{3}_{4}", MethodBase.GetCurrentMethod().Name, (int)serviceClass, code, date, packetKey);
            if ((result = CacheHelper.GetCacheItem <List <int> >(hash)) != null)
            {
                return(result);
            }

            result = (from c in mainDc.tbl_Costs
                      where c.CS_SVKEY == (int)serviceClass &&
                      c.CS_CODE == code &&
                      c.CS_PKKEY == packetKey &&
                      c.CS_PRKEY == partnerKey &&
                      c.CS_SUBCODE1.HasValue &&
                      (date >= c.CS_DATE.Value && date <= c.CS_DATEEND.Value || !c.CS_DATE.HasValue || !c.CS_DATEEND.HasValue) &&
                      (date >= c.CS_CHECKINDATEBEG.Value && date <= c.CS_CHECKINDATEEND.Value || !c.CS_CHECKINDATEBEG.HasValue || !c.CS_CHECKINDATEEND.HasValue) &&
                      (DateTime.Now >= c.cs_DateSellBeg.Value && DateTime.Now <= c.cs_DateSellEnd.Value || !c.cs_DateSellBeg.HasValue || !c.cs_DateSellEnd.HasValue)
                      select c.CS_SUBCODE1.Value)
                     .Distinct()
                     .ToList();

            CacheHelper.AddCacheData(hash, result, null, Globals.Settings.Cache.MediumCacheTimeout);
            return(result);
        }
Example #20
0
        public static List <Repository.MtSearch.tbl_Cost> GetFlightCostsByPacketKey(this MtSearchDbDataContext dc, int packetKey, out string hash)
        {
            List <Repository.MtSearch.tbl_Cost> result;

            hash = String.Format("{0}_{1}", MethodBase.GetCurrentMethod().Name, packetKey);
            if ((result = CacheHelper.GetCacheItem <List <Repository.MtSearch.tbl_Cost> >(hash)) != default(List <Repository.MtSearch.tbl_Cost>))
            {
                return(result);
            }

            var cacheDependencies = new List <string>
            {
                String.Format("{0}_{1}_{2}", CacheHelper.CostHash, (int)ServiceClass.Flight, packetKey)
            };

            result = dc.tbl_Costs
                     .Where(c => c.CS_SVKEY == (int)ServiceClass.Flight &&
                            c.CS_SUBCODE1 != null &&
                            c.CS_PKKEY.HasValue &&
                            c.CS_PKKEY == packetKey &&
                            (!c.CS_DATEEND.HasValue || DateTime.Now.Date <= c.CS_DATEEND.Value)
                            // todo: уточнить необходимость условия 14.08.2014
                            //&& (!c.CS_CHECKINDATEEND.HasValue || (DateTime.Now.Date >= c.CS_CHECKINDATEBEG.Value && DateTime.Now.Date <= c.CS_CHECKINDATEEND.Value))
                            )
                     .ToList();

            CacheHelper.AddCacheData(hash, result, cacheDependencies, Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
Example #21
0
        /// <summary>
        /// Возрвращает ключ
        /// </summary>
        /// <param name="mainDc">Контекст основной БД</param>
        /// <param name="priceKey">Ключ цены</param>
        /// <param name="hotelKey">Ключ отеля</param>
        /// <param name="hash">Хэш</param>
        /// <returns></returns>
        public static int GetHotelPacketKey(this MtMainDbDataContext mainDc, int priceKey, int hotelKey, out string hash)
        {
            hash = String.Format("{0}_{1}", MethodBase.GetCurrentMethod().Name, priceKey);
            if (CacheHelper.IsCacheKeyExists(hash))
            {
                return(CacheHelper.GetCacheItem <int>(hash));
            }

            var result         = -1;
            var commandBuilder = new StringBuilder();

            commandBuilder.AppendLine("select ts_oppacketkey ");
            commandBuilder.AppendLine("from tp_services ");
            commandBuilder.AppendLine(String.Format("where ts_key in (select tl_tskey from tp_servicelists where tl_tikey in (select tp_tikey from tp_prices where tp_key = {0})) ", priceKey));
            commandBuilder.AppendLine(String.Format("and ts_svkey = {0} and ts_code = {1} ", (int)ServiceClass.Hotel, hotelKey));

            using (var command = mainDc.Connection.CreateCommand())
            {
                command.CommandText    = commandBuilder.ToString();
                command.CommandTimeout = 100;

                mainDc.Connection.Open();
                using (var reader = command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        result = reader.GetInt32("ts_oppacketkey");
                    }
                }
                mainDc.Connection.Close();
            }

            CacheHelper.AddCacheData(hash, result, null, Globals.Settings.Cache.MediumCacheTimeout);
            return(result);
        }
Example #22
0
        /// <summary>
        /// Возвращает список ключей пакетов, в которых встречаются перечисленные перелеты
        /// </summary>
        /// <param name="dc">Контекст поисковой БД</param>
        /// <param name="charterKeys">Список ключей перелетов</param>
        /// <param name="hash">Хэш кэша</param>
        /// <returns></returns>
        public static IList <Tuple <int, PacketType> > GetPacketKeysByCarterKeys(this MtSearchDbDataContext dc, IEnumerable <int> charterKeys, out string hash)
        {
            List <Tuple <int, PacketType> > result;

            hash = String.Format("{0}_{1}", MethodBase.GetCurrentMethod().Name, String.Join("_", charterKeys));
            if ((result = CacheHelper.GetCacheItem <List <Tuple <int, PacketType> > >(hash)) != default(List <Tuple <int, PacketType> >))
            {
                return(result);
            }

            var cacheDependencies = new List <string>();
            var packetKeys        = (from c in dc.tbl_Costs
                                     where c.CS_SVKEY == (int)ServiceClass.Flight &&
                                     (!c.CS_DATEEND.HasValue || DateTime.Now.Date <= c.CS_DATEEND.Value) &&
                                     charterKeys.Contains(c.CS_CODE) &&
                                     c.CS_PKKEY.HasValue
                                     select c.CS_PKKEY.Value)
                                    .Distinct()
                                    .ToList();

            cacheDependencies.Add(QDSearch.Extensions.CostsExtension.TableName);

            CacheHelper.AddCacheData(hash, result, cacheDependencies, Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
Example #23
0
        /// <summary>
        /// Возвращает список классов перелетов
        /// </summary>
        /// <param name="dc">Контекст базы данных</param>
        /// <returns></returns>
        public static List <AirService> GetAllAirServices(this MtSearchDbDataContext dc)
        {
            List <AirService> airServices;

            if ((airServices = CacheHelper.GetCacheItem <List <AirService> >(TableName)) != null)
            {
                return(airServices);
            }

            lock (LockAirServices)
            {
                if ((airServices = CacheHelper.GetCacheItem <List <AirService> >(TableName)) != null)
                {
                    return(airServices);
                }

                airServices = (from a in dc.AirServices
                               select a)
                              .ToList <AirService>();

                CacheHelper.AddCacheData(TableName, airServices, TableName);
            }

            return(airServices);
        }
Example #24
0
        /// <summary>
        /// Возвращает список реальных курсов на сегодня
        /// </summary>
        /// <param name="dc">Контекст базы данных</param>
        /// <returns></returns>
        public static IList <CrossCourse> GetTodayCrossCourses(this MtSearchDbDataContext dc)
        {
            List <CrossCourse> crossCourses;
            const string       hash = "CrossCourses";

            if ((crossCourses = CacheHelper.GetCacheItem <List <CrossCourse> >(hash)) != null)
            {
                return(crossCourses);
            }

            lock (LockCrossCourses)
            {
                if ((crossCourses = CacheHelper.GetCacheItem <List <CrossCourse> >(hash)) != null)
                {
                    return(crossCourses);
                }

                crossCourses = (from rcourse in dc.RealCourses
                                join r1 in dc.Rates on rcourse.RC_RCOD1 equals r1.RA_CODE
                                join r2 in dc.Rates on rcourse.RC_RCOD2 equals r2.RA_CODE
                                where DateTime.Now.Date >= rcourse.RC_DATEBEG &&
                                DateTime.Now.Date <= rcourse.RC_DATEEND
                                select new CrossCourse
                {
                    Course = rcourse.RC_COURSE.Value,
                    RateCodeFrom = r2.RA_CODE,
                    RateCodeTo = r1.RA_CODE
                })
                               .ToList();

                CacheHelper.AddCacheData(hash, crossCourses, TableName);
            }

            return(crossCourses);
        }
Example #25
0
        /// <summary>
        /// Возвращает список пакетов, в которых лежат цены для бронирования авиабилетов
        /// </summary>
        /// <param name="dc">Контекст базы данных</param>
        /// <param name="searchDc">Контекст поисковой БД</param>
        /// <param name="hash">Хэш кэша</param>
        /// <returns>Tuple int, PacketType - ключ пакета, тип пакета (направление туда, обратно или туда/обратно)</returns>
        public static IList <Tuple <int, PacketType> > GetFlightPackets(this MtMainDbDataContext dc, MtSearchDbDataContext searchDc, out string hash)
        {
            List <Tuple <int, PacketType> > result;

            hash = String.Format("{0}", MethodBase.GetCurrentMethod().Name);
            if ((result = CacheHelper.GetCacheItem <List <Tuple <int, PacketType> > >(hash)) != null)
            {
                return(result);
            }

            var cacheDependencies = new List <string>();

            result = new List <Tuple <int, PacketType> >();

            string hashOut;
            var    packetKeys = dc.GetCharterBookingPackets(out hashOut);

            cacheDependencies.Add(hashOut);

            var packetKeysDates = dc.GetDatesByTours(packetKeys, out hashOut);

            cacheDependencies.Add(hashOut);

            var allPacketServices = dc.GetClassServicesByTurListKeys(ServiceClass.Flight, packetKeysDates.Select(p => p.Item1).Distinct().ToList(), out hashOut);

            cacheDependencies.Add(hashOut);

            var homeCountryKey = (from ct in searchDc.GetAllCities()
                                  where ct.CT_KEY == Globals.Settings.HomeCityKey
                                  select ct.CT_CNKEY)
                                 .Single();

            foreach (var packetKey in packetKeysDates.Select(p => p.Item1).Distinct().ToList())
            {
                var services = (from s in allPacketServices
                                where s.TS_PKKEY == packetKey
                                select s)
                               .ToList();

                if (services.Count > 1)
                {
                    result.Add(new Tuple <int, PacketType>(packetKey, PacketType.TwoWayCharters));
                }
                else if (services.Count == 1)
                {
                    var serviceCountryKey = (from cn in searchDc.GetAllCities()
                                             where cn.CT_KEY == services[0].TS_SUBCODE2
                                             select cn.CT_CNKEY)
                                            .FirstOrDefault();

                    result.Add(serviceCountryKey == homeCountryKey
                        ? new Tuple <int, PacketType>(packetKey, PacketType.DirectCharters)
                        : new Tuple <int, PacketType>(packetKey, PacketType.BackCharters));
                }
            }

            CacheHelper.AddCacheData(hash, result, cacheDependencies.ToList(), Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
Example #26
0
        /// <summary>
        /// Отели
        /// </summary>
        /// <param name="searchDc"></param>
        /// <param name="sftDc"></param>
        /// <param name="hotelKey">Ключ категории</param>
        /// <param name="mainDc"></param>
        /// <param name="hash"></param>
        /// <returns></returns>
        public static List <DataModel.Hotel> GetHotels(this MtMainDbDataContext mainDc, MtSearchDbDataContext searchDc, SftWebDbDataContext sftDc, int?hotelKey, out string hash)
        {
            List <DataModel.Hotel> result;

            hash = String.Format("{0}_{1}", MethodBase.GetCurrentMethod().Name, hotelKey);
            if ((result = CacheHelper.GetCacheItem <List <DataModel.Hotel> >(hash)) != null)
            {
                return(result);
            }

            result = new List <DataModel.Hotel>();
            var cacheDependencies = new List <string>();

            if (hotelKey == null)
            {
                string hashOut;
                var    hotelCities = (from r in searchDc.GetResorts(sftDc, null, out hashOut)
                                      select r.Id)
                                     .ToList();
                cacheDependencies.Add(hashOut);

                var hotels = (from h in searchDc.GetAllHotels()
                              join c in mainDc.GetAllHotelCats() on h.Stars equals c.COH_Name
                              where hotelCities.Contains(h.CtKey)
                              select
                              new DataModel.Hotel {
                    Id = h.Key, Name = h.Name, ResortId = h.CtKey, HotelCategoryId = c.COH_Id
                })
                             .ToList();

                result.AddRange(hotels);
            }
            else
            {
                string hashOut;
                var    hotel = searchDc.GetHotelByKey(hotelKey.Value, out hashOut);
                cacheDependencies.Add(hashOut);

                if (hotel != null)
                {
                    var cat = mainDc.GetAllHotelCats().SingleOrDefault(c => c.COH_Name == hotel.Stars);
                    if (cat != null)
                    {
                        result.Add(new DataModel.Hotel
                        {
                            HotelCategoryId = cat.COH_Id,
                            Id       = hotel.Key,
                            Name     = hotel.Name,
                            ResortId = hotel.CtKey
                        });
                    }
                }
            }

            cacheDependencies.Add(HotelsExtension.TableName);
            cacheDependencies.Add(HotelCategoriesExtension.TableName);
            CacheHelper.AddCacheData(hash, result, cacheDependencies.ToList(), Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
Example #27
0
        public void FlightState_No()
        {
            CacheHelper.AddCacheData("GetCharterCityDirection_Charter_1_3812", new Tuple <int, int>(227, 332), 0);
            CacheHelper.AddCacheData(StopAviaExtension.TableName, new List <StopAvia>(), 0);
            //CacheHelper.AddCacheData("GetPlainQuotasObjects_Quota_1_3812_뱢媘원̸ⷪ뉇靊", new List<QuotaPlain>()
            //GetPlainQuotasObjects_Quota_1_3812
            CacheHelper.AddCacheData("GetPlainQuotasObjects_1_3812_뱢媘원̸ⷪ뉇靊", new List <QuotaPlain>()
            {
                new QuotaPlain
                {
                    Busy                     = 180,
                    CheckInPlaces            = 180,
                    CheckInPlacesBusy        = 0,
                    Date                     = new DateTime(2014, 04, 27),
                    Duration                 = String.Empty,
                    IsAllotmentAndCommitment = false,
                    PartnerKey               = 7859,
                    Places                   = 180,
                    QdId                     = 31136542,
                    QoId                     = 112967,
                    Release                  = null,
                    SsId                     = 20152512,
                    SsQdId                   = 31136542,
                    SubCode1                 = 98,
                    SubCode2                 = -1,
                    Type                     = QuotaType.Commitment
                }
            }, 0);

            int?subCode2 = null;

            using (var searchDc = new MtSearchDbDataContext())
            {
                string hash;

                const ServiceClass serviceClass = ServiceClass.Flight;
                const int          code         = 3812;
                const int          subCode1     = 89;
                const int          partnerKey   = 7859;
                var       serviceDateFrom       = new DateTime(2014, 04, 27);
                var       serviceDateTo         = new DateTime(2014, 05, 22);
                const int requestedPlaces       = 2;

                var result = searchDc.CheckServiceQuota(serviceClass, code, subCode1, subCode2, partnerKey, serviceDateFrom,
                                                        serviceDateTo, requestedPlaces, out hash);

                Assert.AreEqual(result.QuotaState, QuotesStates.No);
                Assert.AreEqual(result.Places, (uint)0);

                Assert.AreEqual(result, new QuotaStatePlaces()
                {
                    IsCheckInQuota = false,
                    Places         = 0,
                    QuotaState     = QuotesStates.No
                });
            }
        }
Example #28
0
        public static PriceValue GetFlightPriceByParams(this MtSearchDbDataContext dc, int code, int subCode1, int partnerKey, int packetKey, DateTime date, int duration, out string hash)
        {
            PriceValue result;

            hash = String.Format("{0}_{1}", MethodBase.GetCurrentMethod().Name, CacheHelper.GetCacheKeyHashed(new[] { code.ToString(), subCode1.ToString(), partnerKey.ToString(), packetKey.ToString(), date.ToString("yyyy-MM-dd"), duration.ToString() }));
            if ((result = CacheHelper.GetCacheItem <PriceValue>(hash)) != null)
            {
                return(result);
            }

            string hashOut;
            var    dayOfWeek = ((int)date.DayOfWeek).ToString();

            //koshelev,сортировка как в хранимке GetServiceCost
            //CS_CheckInDateBEG Desc, CS_CheckInDateEnd, CS_Date Desc, CS_DATEEND, CS_LONGMIN desc,
            //CS_LONG, CS_DateSellBeg Desc, CS_DateSellEnd, CS_BYDAY,	CS_WEEK ASC
            var costsList = (from c in dc.GetFlightCostsByPacketKey(packetKey, out hashOut)
                             where c.CS_CODE == code &&
                             c.CS_SUBCODE1 == subCode1 &&
                             c.CS_PRKEY == partnerKey &&
                             c.CS_PKKEY == packetKey &&
                             (c.cs_DateSellBeg == null || c.cs_DateSellBeg <= DateTime.Now) &&
                             (c.cs_DateSellEnd == null || c.cs_DateSellEnd >= DateTime.Now) &&
                             (duration < 0 || c.CS_LONGMIN == null || c.CS_LONGMIN <= duration) &&
                             (duration < 0 || c.CS_LONG == null || c.CS_LONG >= duration) &&
                             (c.CS_DATE == null || c.CS_DATE <= date.Date) &&
                             (c.CS_DATEEND == null || c.CS_DATEEND >= date.Date) &&
                             (String.IsNullOrEmpty(c.CS_WEEK) || c.CS_WEEK.IndexOf(dayOfWeek) >= 0)
                             select c)
                            .OrderByDescending(c => c.CS_CHECKINDATEBEG)
                            .ThenBy(c => c.CS_CHECKINDATEEND)
                            .ThenByDescending(c => c.CS_DATE)
                            .ThenBy(c => c.CS_DATEEND)
                            .ThenByDescending(c => c.CS_LONGMIN)
                            .ThenBy(c => c.CS_LONG)
                            .ThenByDescending(c => c.cs_DateSellBeg)
                            .ThenBy(c => c.cs_DateSellEnd)
                            .ThenBy(c => c.CS_BYDAY)
                            .ThenBy(c => c.CS_WEEK)
                            .ToList();

            result = (from c in costsList
                      select new PriceValue {
                Price = c.CS_COST, Rate = c.CS_RATE
            })
                     .FirstOrDefault() ?? new PriceValue
            {
                Price = null,
                Rate  = String.Empty
            };

            CacheHelper.AddCacheData(hash, result, new List <string>()
            {
                hashOut
            }, Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }
Example #29
0
        /// <summary>
        /// Реальный курс на дату
        /// </summary>
        /// <param name="dc">Контекст базы данных</param>
        /// <param name="date">Дата курса</param>
        /// <param name="rateFrom">Валюта, из которой конвертируем</param>
        /// <param name="rateTo">Валюта, в которую конвертируем</param>
        /// <returns></returns>
        public static decimal GetRateRealCourse(this MtSearchDbDataContext dc, DateTime date, int rateFrom, int rateTo)
        {
            if (rateFrom == rateTo)
            {
                return(1);
            }

            var hash = String.Format("{0}_{1}_{2}_{3}", MethodBase.GetCurrentMethod().Name, date.ToString("dd.MM.yyyy"), rateFrom, rateTo);

            if (CacheHelper.IsCacheKeyExists(hash))
            {
                return(CacheHelper.GetCacheItem <decimal>(hash));
            }

            var realCourses = dc.GetActualRealCourses();

            var result = (from rc in realCourses
                          where date >= rc.DateFrom &&
                          date <= rc.DateTo &&
                          rc.RateKeyFrom == rateFrom &&
                          rc.RateKeyTo == rateTo
                          select rc.Course)
                         .FirstOrDefault();

            if (result == 0)
            {
                result = (from rc in realCourses
                          where date >= rc.DateFrom &&
                          date <= rc.DateTo &&
                          rc.RateKeyFrom == rateTo &&
                          rc.RateKeyTo == rateFrom
                          select rc.Course)
                         .FirstOrDefault();

                if (result != 0)
                {
                    result = 1 / result;
                }
            }

            if (result == 0)
            {
                throw new ApplicationException(MethodBase.GetCurrentMethod().Name + ". Отсутствует реальный курс на дату " + date.ToString("dd.MM.yyyy"));
            }

            CacheHelper.AddCacheData(hash, result, new List <string>()
            {
                TableName
            }, Globals.Settings.Cache.LongCacheTimeout);

            return(result);
        }
Example #30
0
        ///// <summary>
        ///// Возвращает список цен
        ///// </summary>
        ///// <param name="dc">Контекст базы данных</param>
        ///// <returns></returns>
        //public static List<Repository.MtSearch.tbl_Cost> GetAllFlightCosts(this MtSearchDbDataContext dc)
        //{
        //    List<Repository.MtSearch.tbl_Cost> costs;
        //    if ((costs = CacheHelper.GetCacheItem<List<Repository.MtSearch.tbl_Cost>>(TableName)) != default(List<Repository.MtSearch.tbl_Cost>)) return costs;

        //    lock (LockCosts)
        //    {
        //        if ((costs = CacheHelper.GetCacheItem<List<Repository.MtSearch.tbl_Cost>>(TableName)) != default(List<Repository.MtSearch.tbl_Cost>)) return costs;

        //        costs = (from c in dc.tbl_Costs
        //                 where (!c.CS_CHECKINDATEEND.HasValue || c.CS_CHECKINDATEEND.Value >= DateTime.Now.Date)
        //                 && (!c.CS_DATEEND.HasValue || c.CS_DATEEND.Value >= DateTime.Now.Date)
        //                 && (c.CS_SVKEY == (int)ServiceClass.Flight)
        //                      select c)
        //            .ToList<Repository.MtSearch.tbl_Cost>();

        //        CacheHelper.AddCacheData(TableName, costs, TableName);
        //    }

        //    return costs;
        //}

        /// <summary>
        /// Расчет цены по услуге через хранимку Мегатек
        /// </summary>
        /// <param name="dc">Контекст БД</param>
        /// <param name="svKey">Класс услуги</param>
        /// <param name="code">Code услуги</param>
        /// <param name="subCode1">SubCode1 услуги</param>
        /// <param name="subCode2">SubCode2 услуги</param>
        /// <param name="partnerKey">Ключ партнера</param>
        /// <param name="packetKey">Ключ пакета</param>
        /// <param name="startDate">Дата начала услуги</param>
        /// <param name="days">Продолжительность услуги</param>
        /// <param name="rate">Валюта, в которой должен быть произведен расчет</param>
        /// <param name="nmen">Число людей по услуге</param>
        /// <param name="hash">Хэш кэша</param>
        /// <returns></returns>
        public static decimal?GetServiceCost(this MtMainDbDataContext dc, int svKey, int code, int subCode1, int subCode2, int partnerKey,
                                             int packetKey, DateTime startDate, int days, string rate, int nmen, out string hash)
        {
            decimal?result;

            hash = String.Format("{0}_{1}_{2}_{3}_{4}_{5}_{6}_{7}_{8}_{9}_{10}", MethodBase.GetCurrentMethod().Name, svKey, code, subCode1, subCode2, partnerKey, packetKey, startDate, days, rate, nmen);
            if ((result = CacheHelper.GetCacheItem <decimal?>(hash)) != default(decimal?))
            {
                return(result);
            }

            var cacheDependencies = new List <string>
            {
                String.Format("{0}_{1}_{2}", CacheHelper.CostHash, svKey, code)
            };
            var commandBuilder = new StringBuilder();

            commandBuilder.AppendFormat(@"declare @nNetto decimal(14,2), @nBrutto decimal(14,2), @nDiscount decimal(14,2)
                        declare @nettoDetail varchar(100), @sBadRate varchar(2), @dtBadDate DateTime
		                declare @sDetailed varchar(100),  @nSPId int, @useDiscountDays int
		                declare @tourKey int, @turdate datetime, @tourDays int, @includeAddCost bit
						declare @saleDate DateTime
						set @saleDate = GetDate()
						set @includeAddCost = 1

                        exec GetServiceCost {0}, {1}, {2}, {3}, {4}, {5}, '{6:yyyy-MM-dd}', {7},
                        '{8}', {9}, 0, 0, 0,
                        @saleDate, @nNetto output, @nBrutto output, @nDiscount output,
						@nettoDetail output, @sBadRate output, @dtBadDate output,
						@sDetailed output, @nSPId output, 0, @tourKey, @turdate, @tourDays, @includeAddCost

                        select @nBrutto",
                                        svKey, code, subCode1, subCode2, partnerKey, packetKey, startDate, days, rate, nmen);

            using (var command = dc.Connection.CreateCommand())
            {
                command.CommandText = commandBuilder.ToString();

                dc.Connection.Open();
                var bruttoTemp = command.ExecuteScalar();
                if (bruttoTemp.ToString() != String.Empty)
                {
                    result = (decimal)bruttoTemp;
                }

                dc.Connection.Close();
            }

            CacheHelper.AddCacheData(hash, result, cacheDependencies.ToList(), Globals.Settings.Cache.LongCacheTimeout);
            return(result);
        }