private ceDomainConfig EnsureDomainConfigExists() { SqlQuery<ceDomainConfig> query = new SqlQuery<ceDomainConfig>(); ceDomainConfig config = query.SelectByKey(DomainManager.CurrentDomainID); if (config == null) { var domains = DomainManager.GetDomains(); var domain = domains.First(d => d.DomainID == DomainManager.CurrentDomainID); config = new ceDomainConfig() { ID = DomainManager.CurrentDomainID, DomainID = DomainManager.CurrentDomainID, ApiUsername = Regex.Replace( domain.Name, @"[^a-zA-Z0-9]", "_", RegexOptions.Compiled), ApiWhitelistIP = "", TopWinnersDaysBack = 30, TopWinnersMaxRecords = 50, TopWinnersMinAmount = 10.00M, TopWinnersExcludeOtherOperators = false, ScalableThumbnailWidth = 376, ScalableThumbnailHeight = 250, GameLoaderDomain = string.Empty, GameResourceDomain = string.Empty, Ins = DateTime.Now, }; query.Insert(config); } return config; }
public bool Delete(ceDomainConfig domain, long id, List <string> languages, out string error) { error = null; //var path = string.Format("/casino/games/{0}.game-information", id.ToString(CultureInfo.InvariantCulture)); string path = string.Format("{0}/{1}.{2}", METADATA_PATH, id.ToString(CultureInfo.InvariantCulture), _metadataItemName); using (var sw = new StringWriter()) using (var writer = new JsonTextWriter(sw)) { writer.WriteStartArray(); foreach (var language in languages) { writer.WriteValue(language); } writer.WriteEndArray(); var ret = MetadataClient.DeleteTranslation(domain, path, sw.ToString()); if (ret == "success") { return(true); } error = ret; return(false); } }
public JsonResult SavePlayerCasinoConfigurationDefaultSetting( int lastPlayedGamesMaxRecords , bool lastPlayedGamesIsDuplicated , int lastPlayedGamesLastDayNum , int mostPlayedGamesLastDayNum , int mostPlayedGamesMinRoundCounts , bool playerBiggestWinGamesIsDuplicated , int playerBiggestWinGamesLastDayNum , decimal playerBiggestWinGamesMinWinEURAmounts ) { if (!DomainManager.AllowEdit()) { throw new Exception("Data modified is not allowed"); } SqlQuery<ceDomainConfig> query = new SqlQuery<ceDomainConfig>(); ceDomainConfig config = EnsureDomainConfigExists(); config.LastPlayedGamesMaxRecords = lastPlayedGamesMaxRecords; config.LastPlayedGamesIsDuplicated = lastPlayedGamesIsDuplicated; config.LastPlayedGamesLastDayNum = lastPlayedGamesLastDayNum; config.MostPlayedGamesLastDayNum = mostPlayedGamesLastDayNum; config.MostPlayedGamesMinRoundCounts = mostPlayedGamesMinRoundCounts; config.PlayerBiggestWinGamesIsDuplicated = playerBiggestWinGamesIsDuplicated; config.PlayerBiggestWinGamesLastDayNum = playerBiggestWinGamesLastDayNum; config.PlayerBiggestWinGamesMinWinEURAmounts = playerBiggestWinGamesMinWinEURAmounts; query.Update(config); CacheManager.ClearCache(Constant.DomainCacheKey); return this.Json(new { @success = true }); }
public bool Update(ceDomainConfig domain, long id, Dictionary <string, string> translations, out string error) { error = null; //var path = string.Format("/casino/games/{0}.game-information", id.ToString(CultureInfo.InvariantCulture)); string path = string.Format("{0}/{1}.{2}", METADATA_PATH, id.ToString(CultureInfo.InvariantCulture), _metadataItemName); using (var sw = new StringWriter()) using (var writer = new JsonTextWriter(sw)) { writer.WriteStartObject(); foreach (var translation in translations) { writer.WritePropertyName(translation.Key); writer.WriteValue(translation.Value); } writer.WriteEndObject(); var ret = MetadataClient.UpdateTranslation(domain, path, sw.ToString()); if (ret == "success") { return(true); } error = ret; return(false); } }
public static string GetDumpedTranslation(ceDomainConfig domain, string lang) { string url = string.Format(DUMP_TRANSLATION_URL , domain.MetadataUrl.DefaultIfNullOrWhiteSpace(DEFAULT_URL) , domain.TemplateID , lang ); return(Download(url)); }
public static string GetPendingWithdrawalCfg(ceDomainConfig domain) { string url = string.Format(GET_METADATA_URL , domain.MetadataUrl.DefaultIfNullOrWhiteSpace(DEFAULT_URL) , domain.TemplateID , WebUtility.UrlEncode("/config/pending-withdrawal") ); return(Download(url)); }
public static string GetExternalAuthCfg(ceDomainConfig domain) { string url = string.Format(GET_METADATA_URL , domain.MetadataUrl.DefaultIfNullOrWhiteSpace(DEFAULT_URL) , domain.TemplateID , WebUtility.UrlEncode("/config/external-authentication") ); return(Download(url)); }
public static string GetBonuses(ceDomainConfig domain, GamMatrixAPI.VendorID vendor) { string url = string.Format(GET_METADATA_URL , domain.MetadataUrl.DefaultIfNullOrWhiteSpace(DEFAULT_URL) , domain.TemplateID , WebUtility.UrlEncode(string.Format("/config/gaming-accounts/{0}/bonus/*", vendor.ToString())) ); return(Download(url)); }
public static string GetRegions(ceDomainConfig domain, string country) { string url = string.Format(GET_METADATA_URL , domain.MetadataUrl.DefaultIfNullOrWhiteSpace(DEFAULT_URL) , domain.TemplateID , WebUtility.UrlEncode(string.Format("/config/countries/{0}/*", country)) ); return(Download(url)); }
public static string GetTranslation(ceDomainConfig domain, string path) { string url = string.Format(GET_TRANSLATION_URL , domain.MetadataUrl.DefaultIfNullOrWhiteSpace(DEFAULT_URL) , domain.TemplateID , WebUtility.UrlEncode(path) ); return(Download(url)); }
public static string DeleteTranslation(ceDomainConfig domain, string path, string translation) { string url = string.Format(DELETE_TRANSLATION_URL , domain.MetadataUrl.DefaultIfNullOrWhiteSpace(DEFAULT_URL) , domain.TemplateID , WebUtility.UrlEncode(path) ); return(Upload(url, translation)); }
public static string GetCurrencies(ceDomainConfig domain) { string url = string.Format(GET_METADATA_URL , domain.MetadataUrl.DefaultIfNullOrWhiteSpace(DEFAULT_URL) , domain.TemplateID , WebUtility.UrlEncode("/config/currencies/*") ); return(Download(url)); }
public static string GetPaymentMethodsInCategory(ceDomainConfig domain, string catetory) { string url = string.Format(GET_METADATA_URL , domain.MetadataUrl.DefaultIfNullOrWhiteSpace(DEFAULT_URL) , domain.TemplateID , WebUtility.UrlEncode(string.Format("/config/payment-method-categories/{0}/*", catetory)) ); return(Download(url)); }
internal static Dictionary <ulong, string> Get(ceDomainConfig domain, string lang, bool reloadCache = false) { string cacheFile = MetadataFileCache.GetPathWithRegion <Translation>(domain.DomainID.ToString(CultureInfo.InvariantCulture), lang); if (reloadCache) { DelayUpdateCache <Dictionary <ulong, string> > .SetExpired(cacheFile); } Func <Dictionary <ulong, string> > func = () => { Dictionary <ulong, string> dic = new Dictionary <ulong, string>(); // {"6883073332696432216":"Immediately","8464306736891375262":"Visa Credit Card","11378931541622277876":"Free","15079650489870782597":""} string json = MetadataClient.GetDumpedTranslation(domain, lang); using (StringReader sr = new StringReader(json)) using (JsonTextReader reader = new JsonTextReader(sr)) { if (!reader.Read() || reader.TokenType != JsonToken.StartObject) { throw new Exception("Unknown format from metadata"); } while (reader.Read()) { if (reader.TokenType == JsonToken.PropertyName && reader.ValueType == typeof(string)) { ulong hash; if (!ulong.TryParse(reader.Value as string, out hash)) { throw new Exception("Unknown format from metadata"); } if (!reader.Read() || reader.TokenType != JsonToken.String) { throw new Exception("Unknown format from metadata"); } dic[hash] = reader.Value as string; } } } return(dic); }; Dictionary <ulong, string> cache = null; bool ret = DelayUpdateCache <Dictionary <ulong, string> > .TryGetValue(cacheFile, out cache, func, 3600); if (ret) { return(cache); } return(func()); }
public JsonResult SaveVendors(VendorID[] enabledVendors , VendorID[] liveCasinoVendors , string cashierUrl , string lobbyUrl , string accountHistoryUrl , string mobileCashierUrl , string mobileLobbyUrl , string mobileAccountHistoryUrl , string domainDefaultCurrencyCode , string googleAnalyticsAccount , string gameLoaderDomain , string gameResourceDomain , short newStatusCasinoGameExpirationDays , short newStatusLiveCasinoGameExpirationDays ) { if (!DomainManager.AllowEdit()) { throw new Exception("Data modified is not allowed"); } CasinoVendorAccessor.SetEnabledVendors(DomainManager.CurrentDomainID , Constant.SystemDomainID , enabledVendors , liveCasinoVendors ); if (enabledVendors != null && enabledVendors.Length > 0) { SqlQuery<ceDomainConfig> query = new SqlQuery<ceDomainConfig>(); ceDomainConfig config = EnsureDomainConfigExists(); config.MobileCashierUrl = mobileCashierUrl; config.MobileLobbyUrl = mobileLobbyUrl; config.MobileAccountHistoryUrl = mobileAccountHistoryUrl; config.CashierUrl = cashierUrl; config.LobbyUrl = lobbyUrl; config.AccountHistoryUrl = accountHistoryUrl; config.DomainDefaultCurrencyCode = domainDefaultCurrencyCode; config.GoogleAnalyticsAccount = googleAnalyticsAccount; config.GameLoaderDomain = gameLoaderDomain; config.GameResourceDomain = gameResourceDomain; config.NewStatusCasinoGameExpirationDays = newStatusCasinoGameExpirationDays; config.NewStatusLiveCasinoGameExpirationDays = newStatusLiveCasinoGameExpirationDays; query.Update(config); } //CacheManager.ClearCache(Constant.GameListCachePrefix); //CacheManager.ClearCache(Constant.JackpotListCachePrefix); //CacheManager.ClearCache(Constant.VendorListCachePrefix); //CacheManager.ClearCache(Constant.DomainCacheKey); return this.Json(new { @success = true }); }
public static string GetGameInformation(ceDomainConfig domain, long id, string lang) { Dictionary <long, CasinoGame> casinoGames = GetAll(domain); CasinoGame casinoGame; if (casinoGames.TryGetValue(id, out casinoGame)) { return(casinoGame.GetGameInformation(lang)); } return(null); }
public JsonResult SaveWcfApiCredentials(string wcfApiUsername, string wcfApiPassword) { if (!DomainManager.AllowEdit()) { throw new Exception("Data modified is not allowed"); } SqlQuery<ceDomainConfig> query = new SqlQuery<ceDomainConfig>(); ceDomainConfig config = EnsureDomainConfigExists(); config.WcfApiUsername = wcfApiUsername; config.WcfApiPassword = wcfApiPassword; query.Update(config); CacheManager.ClearCache(Constant.DomainCacheKey); return this.Json(new { @success = true }); }
public JsonResult SaveRecommendationConfig(string recommendationExcludeGames ,int recommendationMaxPlayerRecords , int recommendationMaxGameRecords) { if (!DomainManager.AllowEdit()) { throw new Exception("Data modified is not allowed"); } SqlQuery<ceDomainConfig> query = new SqlQuery<ceDomainConfig>(); ceDomainConfig config = EnsureDomainConfigExists(); config.RecommendationExcludeGames = recommendationExcludeGames; config.RecommendationMaxPlayerRecords = recommendationMaxPlayerRecords; config.RecommendationMaxGameRecords = recommendationMaxGameRecords; query.Update(config); CE.BackendThread.ScalableThumbnailProcessor.Begin(); CacheManager.ClearCache(Constant.DomainCacheKey); return this.Json(new { @success = true }); }
public JsonResult SaveScalableThumbnailSetting(bool enableScalableThumbnail , int scalableThumbnailWidth , int scalableThumbnailHeight ) { if (!DomainManager.AllowEdit()) { throw new Exception("Data modified is not allowed"); } SqlQuery<ceDomainConfig> query = new SqlQuery<ceDomainConfig>(); ceDomainConfig config = EnsureDomainConfigExists(); config.EnableScalableThumbnail = enableScalableThumbnail; config.ScalableThumbnailWidth = scalableThumbnailWidth; config.ScalableThumbnailHeight = scalableThumbnailHeight; query.Update(config); CE.BackendThread.ScalableThumbnailProcessor.Begin(); CacheManager.ClearCache(Constant.DomainCacheKey); return this.Json(new { @success = true }); }
public JsonResult SaveRecentWinnersDefaultSetting(int recentWinnersMaxRecords , decimal recentWinnersMinAmount , bool recentWinnersExcludeOtherOperators , bool recentWinnersReturnDistinctUserOnly ) { if (!DomainManager.AllowEdit()) { throw new Exception("Data modified is not allowed"); } SqlQuery<ceDomainConfig> query = new SqlQuery<ceDomainConfig>(); ceDomainConfig config = EnsureDomainConfigExists(); config.RecentWinnersExcludeOtherOperators = recentWinnersExcludeOtherOperators; config.RecentWinnersMaxRecords = recentWinnersMaxRecords; config.RecentWinnersMinAmount = recentWinnersMinAmount; config.RecentWinnersReturnDistinctUserOnly = recentWinnersReturnDistinctUserOnly; query.Update(config); CacheManager.ClearCache(Constant.DomainCacheKey); return this.Json(new { @success = true }); }
public List <Translation> Get(ceDomainConfig domain, long id) { //var path = string.Format("/casino/games/{0}.game-information", id.ToString(CultureInfo.InvariantCulture)); string path = string.Format("{0}/{1}.{2}", METADATA_PATH, id.ToString(CultureInfo.InvariantCulture), _metadataItemName); var json = MetadataClient.GetTranslation(domain, path); var translations = new List <Translation>(); using (var sr = new StringReader(json)) using (var reader = new JsonTextReader(sr)) { if (!reader.Read() || reader.TokenType != JsonToken.StartArray) { throw new Exception("Unknown format from metadata"); } while (reader.Read()) { if (reader.TokenType == JsonToken.StartObject) { var translation = Read(reader); if (translation != null) { translations.Add(translation); } } else if (reader.TokenType == JsonToken.EndArray) { break; } else { throw new Exception("Unknown format from metadata"); } } } return(translations); }
public JsonResult SaveTopWinnersDefaultSetting(int topWinnersDaysBack , int topWinnersMaxRecords , decimal topWinnersMinAmount , bool topWinnersExcludeOtherOperators ) { if (!DomainManager.AllowEdit()) { throw new Exception("Data modified is not allowed"); } SqlQuery<ceDomainConfig> query = new SqlQuery<ceDomainConfig>(); ceDomainConfig config = EnsureDomainConfigExists(); config.TopWinnersDaysBack = topWinnersDaysBack; config.TopWinnersExcludeOtherOperators = topWinnersExcludeOtherOperators; config.TopWinnersMaxRecords = topWinnersMaxRecords; config.TopWinnersMinAmount = topWinnersMinAmount; query.Update(config); CacheManager.ClearCache(Constant.TopWinnersCachePrefix); CacheManager.ClearCache(Constant.DomainCacheKey); return this.Json(new { @success = true }); }
public static string GetByHash(ceDomainConfig domain, string lang, ulong hash) { Dictionary <ulong, string> dic = Get(domain, lang); string value = string.Empty; if (dic.TryGetValue(hash, out value)) { // get the dic for domain ConcurrentDictionary <ulong, int> domainDic = null; while (!_dic.TryGetValue(domain.TemplateID, out domainDic)) { _dic.TryAdd(domain.TemplateID, new ConcurrentDictionary <ulong, int>()); } for (; ;) { int count = 0; while (!domainDic.TryGetValue(hash, out count)) { domainDic.TryAdd(hash, 0); } if (domainDic.TryUpdate(hash, count + 1, count)) { break; } } if ((Interlocked.Increment(ref _count) % 100) == 0) { _count = 0; ConcurrentDictionary <int, ConcurrentDictionary <ulong, int> > currentDic = _dic; _dic = new ConcurrentDictionary <int, ConcurrentDictionary <ulong, int> >(); UploadStatistic(currentDic); } return(value); } return(string.Empty); }
public JsonResult SavePopularitySetting(bool popularityExcludeOtherOperators , PopularityCalculationMethod popularityCalculationMethod , int popularityDaysBack , bool popularityNotByCountry , string popularityConfigurationByCountry ) { if (!DomainManager.AllowEdit()) { throw new Exception("Data modified is not allowed"); } SqlQuery<ceDomainConfig> query = new SqlQuery<ceDomainConfig>(); ceDomainConfig config = EnsureDomainConfigExists(); config.PopularityExcludeOtherOperators = popularityExcludeOtherOperators; config.PopularityCalculationMethod = popularityCalculationMethod; config.PopularityDaysBack = popularityDaysBack; config.PopularityNotByCountry = popularityNotByCountry; config.PopularityConfigurationByCountry = popularityConfigurationByCountry; query.Update(config); CacheManager.ClearCache(Constant.DomainCacheKey); return this.Json(new { @success = true }); }
public JsonResult SaveApiCredentials(string apiUsername , string apiPassword , string apiWhitelistIP , string gameListChangedNotificationUrl ) { if (!DomainManager.AllowEdit()) { throw new Exception("Data modified is not allowed"); } SqlQuery<ceDomainConfig> query = new SqlQuery<ceDomainConfig>(); ceDomainConfig config = EnsureDomainConfigExists(); config.ApiUsername = apiUsername; if( !string.IsNullOrWhiteSpace(apiPassword) ) config.ApiPassword = apiPassword.MD5Hash(); config.ApiWhitelistIP = apiWhitelistIP; config.GameListChangedNotificationUrl = gameListChangedNotificationUrl; query.Update(config); CacheManager.ClearCache(Constant.DomainCacheKey); return this.Json(new { @success = true }); }
public static Dictionary <string, JackpotInfo> GetBetSoftJackpots(ceDomainConfig domain, string customUrl = null) { string filepath = Path.Combine(FileSystemUtility.GetWebSiteTempDirectory() , domain == null ? "BetSoftJackpotsFeeds.cache" : string.Format("BetSoftJackpotsFeeds.{0}.cache", domain.GetCfg(BetSoft.BankID)) ); Dictionary <string, JackpotInfo> cached = HttpRuntime.Cache[filepath] as Dictionary <string, JackpotInfo>; if (cached != null && string.IsNullOrEmpty(customUrl)) { return(cached); } string url = "http://lobby.everymatrix.betsoftgaming.com/jackpots/jackpots_218.xml"; if (domain != null && domain.DomainID != Constant.SystemDomainID) { url = string.Format(CultureInfo.InvariantCulture, BetSoft_URL, domain.GetCfg(BetSoft.BankID)); } else { url = ConfigurationManager.AppSettings["SystemJackpotListUrl"]; } url = customUrl ?? url; Func <Dictionary <string, JackpotInfo> > func = () => { try { Dictionary <string, JackpotInfo> jackpots = new Dictionary <string, JackpotInfo>(StringComparer.InvariantCultureIgnoreCase); XDocument xDoc = XDocument.Load(url); IEnumerable <XElement> elements = xDoc.Root.Elements("jackpotGame"); foreach (XElement elem in elements) { string id = elem.Element("gameId").Value; JackpotInfo jackpot; if (!jackpots.TryGetValue(id, out jackpot)) { jackpot = new JackpotInfo() { ID = elem.Element("gameId").Value, Name = elem.Element("gameName").Value, VendorID = VendorID.BetSoft, }; } string currency = elem.Element("currencyCode").Value; decimal amout = decimal.Parse(elem.Element("jackpotAmount").Value, CultureInfo.InvariantCulture); jackpot.Amounts[currency] = amout; jackpots[jackpot.ID] = jackpot; } Dictionary <string, CurrencyExchangeRateRec> currencies = GamMatrixClient.GetCurrencyRates(Constant.SystemDomainID); foreach (JackpotInfo jackpotInfo in jackpots.Values) { if (jackpotInfo.Amounts.Count == 0) { continue; } decimal amount = 0.00M; if (jackpotInfo.Amounts.ContainsKey("EUR")) { amount = jackpotInfo.Amounts["EUR"]; } else { amount = jackpotInfo.Amounts.First().Value; } foreach (string key in currencies.Keys) { if (!jackpotInfo.Amounts.ContainsKey(key)) { jackpotInfo.Amounts[key] = amount; } } } if (jackpots.Count > 0 && string.IsNullOrEmpty(customUrl)) { ObjectHelper.BinarySerialize <Dictionary <string, JackpotInfo> >(jackpots, filepath); } return(jackpots); } catch (Exception ex) { Logger.Exception(ex); throw; } }; if (!string.IsNullOrEmpty(customUrl)) { cached = func(); } else if (!DelayUpdateCache <Dictionary <string, JackpotInfo> > .TryGetValue(filepath, out cached, func, 120)) { cached = ObjectHelper.BinaryDeserialize <Dictionary <string, JackpotInfo> >(filepath, new Dictionary <string, JackpotInfo>()); } return(cached); }
/// <summary> /// Get all the casino games for a specific vendor /// </summary> /// <param name="domain"></param> /// <param name="reloadCache"></param> /// <returns></returns> public static Dictionary <long, CasinoGame> GetAll(ceDomainConfig domain, bool reloadCache = false) { string cacheFile = MetadataFileCache.GetPath <CasinoGame>(domain.DomainID.ToString(CultureInfo.InvariantCulture)); if (reloadCache) { DelayUpdateCache <Dictionary <long, CasinoGame> > .SetExpired(cacheFile); } Func <Dictionary <long, CasinoGame> > func = () => { var dic = new Dictionary <long, CasinoGame>(); try { // {"8101":{"game-information":"12027250142368842869"},"8102":{"game-information":"5380242421959168179"}} string json = MetadataClient.GetCasinoGames(domain); using (StringReader sr = new StringReader(json)) using (JsonTextReader reader = new JsonTextReader(sr)) { if (!reader.Read() || reader.TokenType != JsonToken.StartObject) { throw new Exception("Unknown format from metadata"); } CasinoGame casinoGame = null; while (reader.Read()) { if (casinoGame == null) { if (reader.TokenType == JsonToken.PropertyName) { casinoGame = new CasinoGame() { Domain = domain }; dic[ConvertHelper.ToInt64(reader.Value)] = casinoGame; if (!reader.Read() || reader.TokenType != JsonToken.StartObject) { throw new Exception("Unknown format from metadata"); } } else if (reader.TokenType == JsonToken.EndObject) { break; } else { throw new Exception("Unknown format from metadata"); } } else { if (reader.TokenType == JsonToken.EndObject) { casinoGame = null; } else if (reader.TokenType == JsonToken.PropertyName) { string propertyName = reader.Value.ToString().ToLowerInvariant(); reader.Read(); switch (propertyName) { case "game-information": casinoGame.GameInformationHash = ConvertHelper.ToUInt64(reader.Value); break; default: break; } } else { throw new Exception("Unknown format from metadata"); } } } } } catch { } return(dic); }; Dictionary <long, CasinoGame> cache = null; bool ret = DelayUpdateCache <Dictionary <long, CasinoGame> > .TryGetValue(cacheFile, out cache, func, 36000); if (ret) { return(cache); } return(func()); }
public static Dictionary <string, JackpotInfo> GetSheriffJackpots(ceDomainConfig domain) { string filepath = Path.Combine(FileSystemUtility.GetWebSiteTempDirectory() , domain == null ? "SheriffJackpotsFeeds.cache" : string.Format("SheriffJackpotsFeeds.{0}.cache", domain.GetCfg(Sheriff.JackpotJsonURL).GetHashCode()) ); Dictionary <string, JackpotInfo> cached = HttpRuntime.Cache[filepath] as Dictionary <string, JackpotInfo>; if (cached != null) { return(cached); } // http://jetbull.nl1.gamingclient.com/jackpot/retrieve/{0} string urlFormat = null; if (domain != null) { urlFormat = domain.GetCfg(Sheriff.JackpotJsonURL); } if (string.IsNullOrWhiteSpace(urlFormat)) { urlFormat = ConfigurationManager.AppSettings["DefaultSheriffJackpotJsonUrl"]; } Func <Dictionary <string, JackpotInfo> > func = () => { try { Dictionary <string, JackpotInfo> jackpots = new Dictionary <string, JackpotInfo>(StringComparer.InvariantCultureIgnoreCase); //List<ceCasinoGameBaseEx> games = CasinoGameAccessor.GetDomainGames(domain == null ? Constant.SystemDomainID : domain.DomainID) // .Where(g => g.VendorID == VendorID.Sheriff) // .ToList(); List <ceCasinoGameBaseEx> games = CacheManager.GetGameList(domain == null ? Constant.SystemDomainID : domain.DomainID, false, false) .Where(g => g.VendorID == VendorID.Sheriff) .ToList(); using (WebClient client = new WebClient()) { JavaScriptSerializer jss = new JavaScriptSerializer(); Dictionary <string, CurrencyExchangeRateRec> currencies = GamMatrixClient.GetCurrencyRates(Constant.SystemDomainID); foreach (ceCasinoGameBaseEx game in games) { string url = string.Format(CultureInfo.InvariantCulture, urlFormat, HttpUtility.UrlEncode(game.GameCode)); string json = client.DownloadString(url); if (!string.IsNullOrWhiteSpace(json)) { try { Dictionary <string, SheriffJackpot> j = jss.Deserialize <Dictionary <string, SheriffJackpot> >(json); if (j.Count > 0) { JackpotInfo jackpot = new JackpotInfo(); jackpot.ID = game.GameCode; jackpot.Name = game.GameName; jackpot.VendorID = VendorID.Sheriff; // For Sheriff jackpors, the amount is always the same for all currencies foreach (string key in currencies.Keys) { SheriffJackpot sj = j.First().Value; if (sj.totalAmount.HasValue) { jackpot.Amounts[key] = sj.totalAmount.Value / 100.00M; } else { jackpot.Amounts[key] = sj.amount / 100.00M; } } jackpots[jackpot.ID] = jackpot; } } catch (Exception ex) { Logger.Exception(ex, string.Format(@" Sheriff - Jackpots URL : {0}", url)); } } } } if (jackpots.Count > 0) { ObjectHelper.BinarySerialize <Dictionary <string, JackpotInfo> >(jackpots, filepath); } return(jackpots); } catch (Exception ex) { Logger.Exception(ex); throw; } }; if (!DelayUpdateCache <Dictionary <string, JackpotInfo> > .TryGetValue(filepath, out cached, func, 120)) { cached = ObjectHelper.BinaryDeserialize <Dictionary <string, JackpotInfo> >(filepath, new Dictionary <string, JackpotInfo>()); } return(cached); }// GetSheriffJackpots
public static Dictionary <string, JackpotInfo> GetOMIJackpots(ceDomainConfig domain) { string omiOperatorID = ConfigurationManager.AppSettings["DefaultOMIOperatorID"]; if (domain != null && !string.IsNullOrEmpty(domain.GetCfg(OMI.OperatorID))) { omiOperatorID = domain.GetCfg(OMI.OperatorID); } string filepath = Path.Combine(FileSystemUtility.GetWebSiteTempDirectory() , string.Format(CultureInfo.InvariantCulture, "OMIJackpotsFeeds.{0}.cache", omiOperatorID) ); Dictionary <string, JackpotInfo> cached = HttpRuntime.Cache[filepath] as Dictionary <string, JackpotInfo>; if (cached != null) { return(cached); } // https://vegasinstallation.com/gserver/api/game/slot Func <Dictionary <string, JackpotInfo> > func = () => { try { string str = "ARS,AUD,BRL,BGN,CAD,CHF,CNY,CZK,DKK,EUR,GBP,GEL,HKD,HUF,HRK,IDR,ISK,JPY,LTL,LVL,MXN,MYR,NGN,NOK,NZD,PLN,RON,RUB,SEK,SGD,THB,TRY,TWD,UAH,USD,VEF,ZAR"; string[] omiSupportCurrencies = str.ToUpperInvariant().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); Dictionary <string, CurrencyExchangeRateRec> currencies = GamMatrixClient.GetCurrencyRates(Constant.SystemDomainID); Dictionary <string, JackpotInfo> jackpots = new Dictionary <string, JackpotInfo>(StringComparer.InvariantCultureIgnoreCase); // hard-coded jackpotId: // The jackpot id. For Jungle Fruits:"201", For Benny The Panda: "202" for maxi, "203" for mini string[] jackpotIDs = new string[] { "201", "202", "203" }; string strFailed = ""; foreach (string jackpotID in jackpotIDs) { OMIJackpot omiJackpot = QueryOMIJackpot("EUR", jackpotID, omiOperatorID); JackpotInfo jackpot; jackpot = new JackpotInfo() { ID = jackpotID, Name = jackpotID, VendorID = VendorID.OMI, }; jackpot.Amounts[omiJackpot.currencyCode] = omiJackpot.currentValue; foreach (string key in currencies.Keys) { if (key.ToUpperInvariant() == "EUR" || !omiSupportCurrencies.Contains(key.ToUpperInvariant())) { continue; } omiJackpot = QueryOMIJackpot(key, jackpotID, omiOperatorID); if (omiJackpot != null) { jackpot.Amounts[omiJackpot.currencyCode] = omiJackpot.currentValue; } else { strFailed += string.Format("jackpotID: {0}, currency: {1} /n", jackpotID, key); } } jackpots[jackpot.ID] = jackpot; }// foreach if (!string.IsNullOrWhiteSpace(strFailed)) { Logger.Information("OMI jackpots /n" + strFailed); } if (jackpots.Count > 0) { ObjectHelper.BinarySerialize <Dictionary <string, JackpotInfo> >(jackpots, filepath); } return(jackpots); } catch (Exception ex) { Logger.Exception(ex, string.Format(" OMI - omiOperatorID : {0}", omiOperatorID)); throw; } };// Func if (!DelayUpdateCache <Dictionary <string, JackpotInfo> > .TryGetValue(filepath, out cached, func, 300)) { cached = ObjectHelper.BinaryDeserialize <Dictionary <string, JackpotInfo> >(filepath, new Dictionary <string, JackpotInfo>()); } return(cached); }// GetOMIJackpots
/// <summary> /// Get All the languages for the current domain /// </summary> /// <param name="domain"></param> /// <param name="reloadCache"></param> /// <returns></returns> public static Language[] GetAll(ceDomainConfig domain, bool reloadCache = false) { string cacheFile = MetadataFileCache.GetPath <Language>(domain.DomainID.ToString(CultureInfo.InvariantCulture)); if (reloadCache) { DelayUpdateCache <Dictionary <string, Language> > .SetExpired(cacheFile); } Func <Language[]> func = () => { List <Language> list = new List <Language>(); // {"ar":{"name":"\u0627\u0644\u0639\u0631\u0628\u064A\u0629"},"cs":{"name":"\u010Ce\u0161tina"},"en":{"name":"English"}} string json = MetadataClient.GetLanguages(domain); using (StringReader sr = new StringReader(json)) using (JsonTextReader reader = new JsonTextReader(sr)) { if (!reader.Read() || reader.TokenType != JsonToken.StartObject) { throw new Exception("Unknown format from metadata"); } Language lang = null; while (reader.Read()) { if (lang == null) { if (reader.TokenType == JsonToken.PropertyName && reader.ValueType == typeof(string)) { lang = new Language() { RFC1766 = reader.Value as string }; if (!reader.Read() || reader.TokenType != JsonToken.StartObject) { throw new Exception("Unknown format from metadata"); } } else if (reader.TokenType == JsonToken.EndObject) { break; } else { throw new Exception("Unknown format from metadata"); } } else { if (reader.TokenType == JsonToken.EndObject) { list.Add(lang); lang = null; } else if (reader.TokenType == JsonToken.PropertyName) { if (reader.ValueType == typeof(string) && reader.Value as string == "name") { if (!reader.Read() || reader.TokenType != JsonToken.String) { throw new Exception("Unknown format from metadata"); } lang.DisplayName = reader.Value as string; } } else { throw new Exception("Unknown format from metadata"); } } } } return(list.ToArray()); }; Language[] cache = null; bool ret = DelayUpdateCache <Language[]> .TryGetValue(cacheFile, out cache, func, 36000); if (ret) { return(cache); } return(func()); }