public async Task TestCodeGeneration(string resourceBaseName, Language language)
{
var inputResourceName = "BrightstarDB.CodeGeneration.Tests.GeneratorTestsResources." + resourceBaseName + "Input_" + language.ToString() + ".txt";
var outputResourceName = "BrightstarDB.CodeGeneration.Tests.GeneratorTestsResources." + resourceBaseName + "Output_" + language.ToString() + ".txt";
using (var inputStream = this.GetType().Assembly.GetManifestResourceStream(inputResourceName))
using (var outputStream = this.GetType().Assembly.GetManifestResourceStream(outputResourceName))
using (var outputStreamReader = new StreamReader(outputStream))
{
var workspace = new AdhocWorkspace();
var projectId = ProjectId.CreateNewId();
var versionStamp = VersionStamp.Create();
var projectInfo = ProjectInfo.Create(
projectId,
versionStamp,
"AdhocProject",
"AdhocProject",
language.ToSyntaxGeneratorLanguageName(),
metadataReferences: new[]
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Uri).Assembly.Location),
MetadataReference.CreateFromFile(typeof(BrightstarException).Assembly.Location)
});
var project = workspace.AddProject(projectInfo);
workspace.AddDocument(projectId, "Source.cs", SourceText.From(inputStream));
var solution = workspace.CurrentSolution;
var results = await Generator
.GenerateAsync(
language,
solution,
"BrightstarDB.CodeGeneration.Tests",
interfacePredicate: x => true);
var result = results
.Aggregate(
new StringBuilder(),
(current, next) => current.AppendLine(next.ToString()),
x => x.ToString());
var expectedCode = outputStreamReader.ReadToEnd();
// make sure version changes don't break the tests
expectedCode = expectedCode.Replace("$VERSION$", typeof(BrightstarException).Assembly.GetName().Version.ToString());
//// useful when converting generated code to something that can be pasted into an expectation file
//var sanitisedResult = result.Replace("1.10.0.0", "$VERSION$");
//System.Diagnostics.Debug.WriteLine(sanitisedResult);
Assert.AreEqual(expectedCode, result);
}
}
// TODO: VB is totally borked - calls to syntaxGenerator.WithStatements don't seem to add the statements! Will need to look into this at a later date
//[InlineData("SimpleInterface", Language.VisualBasic)]
//[InlineData("InterfaceWithGenericMethods", Language.VisualBasic)]
//[InlineData("GenericInterface", Language.VisualBasic)]
//[InlineData("InterfaceWithNonMockableMembers", Language.VisualBasic)]
//[InlineData("PartialInterface", Language.VisualBasic)]
//[InlineData("InheritingInterface", Language.VisualBasic)]
public async Task can_generate_simple_mock(string resourceBaseName, Language language)
{
var inputResourceName = "PCLMock.UnitTests.CodeGeneration.GeneratorFixtureResources." + resourceBaseName + "Input_" + language.ToString() + ".txt";
var outputResourceName = "PCLMock.UnitTests.CodeGeneration.GeneratorFixtureResources." + resourceBaseName + "Output_" + language.ToString() + ".txt";
using (var inputStream = this.GetType().Assembly.GetManifestResourceStream(inputResourceName))
using (var outputStream = this.GetType().Assembly.GetManifestResourceStream(outputResourceName))
using (var outputStreamReader = new StreamReader(outputStream))
{
var workspace = new AdhocWorkspace();
var projectId = ProjectId.CreateNewId();
var versionStamp = VersionStamp.Create();
var projectInfo = ProjectInfo.Create(
projectId,
versionStamp,
"AdhocProject",
"AdhocProject",
language.ToSyntaxGeneratorLanguageName(),
metadataReferences: new[]
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Uri).Assembly.Location),
MetadataReference.CreateFromFile(typeof(MockBase<>).Assembly.Location)
});
var project = workspace.AddProject(projectInfo);
workspace.AddDocument(projectId, "Source.cs", SourceText.From(inputStream));
var solution = workspace.CurrentSolution;
var results =
(await Generator.GenerateMocksAsync(
language,
solution,
x => true,
x => "The.Namespace",
x => "Mock"));
var result = results
.Single()
.ToString();
var expectedCode = outputStreamReader.ReadToEnd();
// make sure version changes don't break the tests
expectedCode = expectedCode.Replace("$VERSION$", typeof(MockBase<>).Assembly.GetName().Version.ToString());
// useful when converting generated code to something that can be pasted into an expectation file
var sanitisedResult = result.Replace(typeof(MockBase<>).Assembly.GetName().Version.ToString(), "$VERSION$");
Assert.Equal(expectedCode, result);
}
}
public static void SetLanguage(Language language)
{
GlobalData.Current.Language = language;
RegistryKey regKey = Registry.CurrentUser.OpenSubKey(GlobalData.RegPathBase, true);
regKey.SetValue(GlobalData.RegValueLanguage, language.ToString());
}
internal static string Get(Language lang)
{
var type = typeof(Language);
var member = type.GetField(lang.ToString());
var attr = member.GetCustomAttributes(typeof(CountryCodeAttribute), false)[0] as CountryCodeAttribute;
return attr.Code;
}
/// <summary>
/// 字符资源
/// </summary>
/// <param name="currentLanguage">当前语言</param>
public void InitLanguage(Language currentLanguage)
{
string tag = string.Empty;
string text = string.Empty;
string fileName = string.Format("Language\\{0}.xml", currentLanguage.ToString());
XmlTextReader reader = new XmlTextReader(fileName);
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element: // The node is an element.
if (reader.Name == "Language")
{
continue;
}
tag = reader.Name.Trim();
text = reader.ReadInnerXml().Trim();
if (!string.IsNullOrEmpty(tag) && !string.IsNullOrEmpty(text))
{
_stringDic.Add(tag, text);
//System.Diagnostics.Debug.WriteLine(tag + ",");
}
break;
}
}
}
public static FunctionTree BuildFunctionTree(Guid userId,Language language)
{
FunctionTree tree = new FunctionTree();
using (SqlConnection sqlConnection = DataAccess.GetSqlConnection())
{
SqlCommand command = sqlConnection.CreateCommand();
command.CommandText = "[dbo].[FunctionTree_GetData]";
command.CommandType = System.Data.CommandType.StoredProcedure;
command.Parameters.Add(new SqlParameter("@userId", userId));
command.Parameters.Add(new SqlParameter("@language", language.ToString()));
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
Category category = new Category();
category.CategoryType = (ModuleCategoryType)reader.GetValue(0);
category.CategoryDescription = reader.GetValue(1).ToString();
tree.Categories.Add(category);
}
reader.NextResult();
while (reader.Read())
{
Module module = new Module();
module.Type = (ModuleType)reader.GetValue(0);
module.ModuleDescription = reader.GetValue(1).ToString();
module.Category = (ModuleCategoryType)reader.GetValue(2);
tree.Modules.Add(module);
}
}
return tree;
}
public static string GetLanguageFileExtension(Language language)
{
var type = typeof(Language);
var memInfo = type.GetMember(language.ToString());
var attributes = memInfo[0].GetCustomAttributes(typeof(FileExtensionAttribute), false);
return ((FileExtensionAttribute)attributes[0]).Extension;
}
public static void RunLocalBacktest(string algorithm, Dictionary<string, string> expectedStatistics, Language language)
{
var statistics = new Dictionary<string, string>();
Composer.Instance.Reset();
try
{
// set the configuration up
Config.Set("algorithm-type-name", algorithm);
Config.Set("live-mode", "false");
Config.Set("environment", "");
Config.Set("messaging-handler", "QuantConnect.Messaging.Messaging");
Config.Set("job-queue-handler", "QuantConnect.Queues.JobQueue");
Config.Set("api-handler", "QuantConnect.Api.Api");
Config.Set("result-handler", "QuantConnect.Lean.Engine.Results.BacktestingResultHandler");
Config.Set("algorithm-language", language.ToString());
Config.Set("algorithm-location", "QuantConnect.Algorithm." + language + ".dll");
var debugEnabled = Log.DebuggingEnabled;
var logHandlers = new ILogHandler[] {new ConsoleLogHandler(), new FileLogHandler("regression.log", false)};
using (Log.LogHandler = new CompositeLogHandler(logHandlers))
using (var algorithmHandlers = LeanEngineAlgorithmHandlers.FromConfiguration(Composer.Instance))
using (var systemHandlers = LeanEngineSystemHandlers.FromConfiguration(Composer.Instance))
{
Log.DebuggingEnabled = true;
Log.LogHandler.Trace("");
Log.LogHandler.Trace("{0}: Running " + algorithm + "...", DateTime.UtcNow);
Log.LogHandler.Trace("");
// run the algorithm in its own thread
var engine = new Lean.Engine.Engine(systemHandlers, algorithmHandlers, false);
Task.Factory.StartNew(() =>
{
string algorithmPath;
var job = systemHandlers.JobQueue.NextJob(out algorithmPath);
engine.Run(job, algorithmPath);
}).Wait();
var backtestingResultHandler = (BacktestingResultHandler)algorithmHandlers.Results;
statistics = backtestingResultHandler.FinalStatistics;
Log.DebuggingEnabled = debugEnabled;
}
}
catch (Exception ex)
{
Log.LogHandler.Error("{0} {1}", ex.Message, ex.StackTrace);
}
foreach (var stat in expectedStatistics)
{
Assert.AreEqual(true, statistics.ContainsKey(stat.Key), "Missing key: " + stat.Key);
Assert.AreEqual(stat.Value, statistics[stat.Key], "Failed on " + stat.Key);
}
}
/// <summary>
/// 获取用户信息
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <param name="openId">普通用户的标识，对当前公众号唯一</param>
/// <param name="lang">返回国家地区语言版本，zh_CN 简体，zh_TW 繁体，en 英语</param>
/// <returns></returns>
public static UserInfoJson Info(string accessToken, string openId, Language lang = Language.zh_CN)
{
//微信公众平台获取用户信息接口地址
string urlFormat = "https://api.weixin.qq.com/cgi-bin/user/info?access_token={0}&openid={1}&lang={2}";
return ApiHelper.Get<UserInfoJson>(accessToken, urlFormat, openId, lang.ToString());
//错误时微信会返回错误码等信息，JSON数据包示例如下（该示例为AppID无效错误）:
//{"errcode":40013,"errmsg":"invalid appid"}
}
public override string Get(Language from, Language to, string text)
{
string res;
if (_cache.TryGetValue(from.ToString() + "|" + to.ToString() + "|" + text, out res))
{
return res;
}
return null;
}
/// <summary>
/// 获取用户信息
/// </summary>
/// <param name="accessToken">调用接口凭证</param>
/// <param name="openId">普通用户的标识，对当前公众号唯一</param>
/// <param name="lang">返回国家地区语言版本，zh_CN 简体，zh_TW 繁体，en 英语</param>
/// <returns></returns>
public static UserInfoJson Info(string accessToken, string openId, Language lang = Language.zh_CN)
{
string url = string.Format("https://api.weixin.qq.com/cgi-bin/user/info?access_token={0}&openid={1}&lang={2}",
accessToken, openId, lang.ToString());
return HttpUtility.Get.GetJson<UserInfoJson>(url);
//错误时微信会返回错误码等信息，JSON数据包示例如下（该示例为AppID无效错误）:
//{"errcode":40013,"errmsg":"invalid appid"}
}
public static string FormatLanguageEnum(Language? lang)
{
if (lang == Language.xpiglatin)
{
return "x-pig-latin";
}
if (lang == Language.zhtw)
{
return "zh-tw";
}
return lang.ToString();
}
public string GetPathToDocumentationSamplesDirectory(Language language, string documentationVersion)
{
switch (language)
{
case Language.Csharp:
return Path.Combine(PathToDocumentationDirectory, documentationVersion, "Samples", "csharp", "Raven.Documentation.Samples");
case Language.Java:
return Path.Combine(PathToDocumentationDirectory, documentationVersion, "Samples", "java", "src", "test", "java", "net", "ravendb");
default:
throw new NotSupportedException(language.ToString());
}
}
// methods
public void fetchAndSave(Language lng)
{
words = (lng == Language.Lazca) ? getLazcaWords ("A","B","C","C1","C2","D","E","F","G","Gy","G1","H","I","J","K","K1","Ky","Ky1","L","M","N","O","P","P1","R","S","S1","T","T1","U","V","X","X1","Y","Z","Z1","3","31") : getTurckeWords("A-C","D-J","K-R","S-Z");
// null check
if(words==null) {
Console.WriteLine ("HATA: {0} hic bir kelime bulunamadi",lng.ToString());
return;
}
StringBuilder wordlistHTML = new StringBuilder ("{\"wordlist\":[");
int counter=0;
foreach (var item in words) {
if(item.Key==null || item.Value==null){
Console.WriteLine ("HATA: Bir kelimede terslik var");
break;
}
wordlistHTML.Append ("\""+ Regex.Replace(item.Key.Trim(), @"\t|\n|\r", " ").Trim() +"\",");
writeToDisk(lng.ToString() + "_" + counter + ".html" , item.Value);
counter++;
}
wordlistHTML.Append ("\"END\"]}");
writeToDisk("datalist"+lng.ToString()+".json" , wordlistHTML.ToString());
}
private static string ConvertLanguageToCssClass(Language language)
{
switch (language)
{
case Language.Csharp:
return "language-csharp";
case Language.Java:
return "language-java";
case Language.Http:
return "language-javascript";
default:
throw new NotSupportedException(language.ToString());
}
}
private static string ConvertLanguageToDisplayName(Language language)
{
switch (language)
{
case Language.Csharp:
return "C#";
case Language.Java:
return "Java";
case Language.Http:
return "HTTP";
default:
throw new NotSupportedException(language.ToString());
}
}
/// <summary>
/// Get a list of all champions synchronously.
/// </summary>
/// <param name="region">Region from which to retrieve the data.</param>
/// <param name="championData">Data to retrieve.</param>
/// <param name="language">Language of the data to be retrieved.</param>
/// <returns>A ChampionListStatic object containing all champions.</returns>
public ChampionListStatic GetChampions(Region region, ChampionData championData = ChampionData.none
, Language language = Language.en_US)
{
var wrapper = Cache.Get<ChampionListStaticWrapper>(ChampionsCacheKey);
if (wrapper == null || language != wrapper.Language || championData != wrapper.ChampionData)
{
var json = requester.CreateRequest(string.Format(ChampionRootUrl, region.ToString())
, new List<string>() { string.Format("locale={0}", language.ToString())
, championData == ChampionData.none ? string.Empty
: string.Format("champData={0}", championData.ToString()) });
var champs = JsonConvert.DeserializeObject<ChampionListStatic>(json);
wrapper = new ChampionListStaticWrapper(champs, language, championData);
Cache.Add<ChampionListStaticWrapper>(ChampionsCacheKey, wrapper);
}
return wrapper.ChampionListStatic;
}
/// <summary>
/// Main function used to translate words
/// </summary>
/// <param name="destinationLanguage">Which language to use fro translation</param>
/// <returns>Return the translated string mathcing destination language or an error string</returns>
public string Translate (Language destinationLanguage)
{
if (m_LocalizedStrings != null)
{
for (int i = 0; i < m_LocalizedStrings.Count; i++)
{
XmlTranslatorLocalizedElement CurrentElement = (XmlTranslatorLocalizedElement)m_LocalizedStrings.Items[i];
if (CurrentElement.LanguageUsed.Language == destinationLanguage)
{
return CurrentElement.TranslatedString.String;
}
}
}
return string.Format (CultureInfo.InvariantCulture, "NOT_FOUND_{0}_{1}", this.InternalName, destinationLanguage.ToString());
}
/// <summary>
/// 初始化方法
/// </summary>
/// <param name="textXML">指定xml</param>
/// <param name="language">设定从xml中加载的语言</param>
public static void Init(XElement textXML, Language language)
{
string Lname = language.ToString();
var collection = from node in textXML.Elements("Item")
where node.Attribute("ID") != null
select new
{
ID = int.Parse(node.Attribute("ID").Value),
Content = node.Attribute(Lname) == null ? null : node.Attribute(Lname).Value
};
foreach (var item in collection)
{
if (item.Content == null)
{
continue;
}
text[item.ID] = item.Content;
}
}
/// <summary>
/// Get a list of all summoner spells asynchronously.
/// </summary>
/// <param name="region">Region from which to retrieve the data.</param>
/// <param name="summonerSpellData">Data to retrieve.</param>
/// <param name="language">Language of the data to be retrieved.</param>
/// <returns>A SummonerSpellListStatic object containing all summoner spells.</returns>
public async Task<SummonerSpellListStatic> GetSummonerSpellsAsync(Region region
, SummonerSpellData summonerSpellData = SummonerSpellData.none, Language language = Language.en_US)
{
var wrapper = Cache.Get<SummonerSpellListStaticWrapper>(SummonerSpellsCacheKey);
if (wrapper == null || wrapper.Language != language || wrapper.SummonerSpellData != summonerSpellData)
{
var json = await requester.CreateRequestAsync(string.Format(SummonerSpellRootUrl, region.ToString())
, new List<string>() { string.Format("locale={0}", language.ToString())
, summonerSpellData == SummonerSpellData.none ? string.Empty
: string.Format("spellData={0}", summonerSpellData.ToString()) });
var spells = await JsonConvert.DeserializeObjectAsync<SummonerSpellListStatic>(json);
wrapper = new SummonerSpellListStaticWrapper(spells, language, summonerSpellData);
Cache.Add<SummonerSpellListStaticWrapper>(SummonerSpellsCacheKey, wrapper);
}
return wrapper.SummonerSpellListStatic;
}
/// <summary>
/// Get a rune asynchronously.
/// </summary>
/// <param name="region">Region from which to retrieve the data.</param>
/// <param name="runeId">Id of the rune to retrieve.</param>
/// <param name="runeData">Data to retrieve.</param>
/// <param name="language">Language of the data to be retrieved.</param>
/// <returns>A rune.</returns>
public async Task<RuneStatic> GetRuneAsync(Region region, int runeId, RuneData runeData = RuneData.none
, Language language = Language.en_US)
{
var wrapper = Cache.Get<RuneStaticWrapper>(RuneCacheKey + runeId);
if (wrapper != null && wrapper.Language == language && wrapper.RuneData == RuneData.all)
{
return wrapper.RuneStatic;
}
else
{
var listWrapper = Cache.Get<RuneListStaticWrapper>(RunesCacheKey);
if (listWrapper != null && listWrapper.Language == language && listWrapper.RuneData == runeData)
{
if (listWrapper.RuneListStatic.Runes.ContainsKey(runeId))
{
return listWrapper.RuneListStatic.Runes[runeId];
}
else
{
return null;
}
}
else
{
var json = await requester.CreateRequestAsync(string.Format(RuneRootUrl, region.ToString())
+ string.Format(IdUrl, runeId)
, new List<string>() { string.Format("locale={0}", language.ToString())
, runeData == RuneData.none ? string.Empty
: string.Format("runeData={0}", runeData.ToString()) });
var rune = await JsonConvert.DeserializeObjectAsync<RuneStatic>(json);
Cache.Add<RuneStaticWrapper>(RuneCacheKey + runeId, new RuneStaticWrapper(rune, language, runeData));
return rune;
}
}
}
/// <summary>
/// Get a list of all runes asynchronously.
/// </summary>
/// <param name="region">Region from which to retrieve the data.</param>
/// <param name="runeData">Data to retrieve.</param>
/// <param name="language">Language of the data to be retrieved.</param>
/// <returns>A RuneListStatic object containing all runes.</returns>
public async Task<RuneListStatic> GetRunesAsync(Region region, RuneData runeData = RuneData.none
, Language language = Language.en_US)
{
var wrapper = Cache.Get<RuneListStaticWrapper>(RunesCacheKey);
if (wrapper == null || language != wrapper.Language | runeData != wrapper.RuneData)
{
var json = await requester.CreateRequestAsync(string.Format(RuneRootUrl, region.ToString())
, new List<string>() { string.Format("locale={0}", language.ToString())
, runeData == RuneData.none ? string.Empty
: string.Format("runeListData={0}", runeData.ToString()) });
var runes = await JsonConvert.DeserializeObjectAsync<RuneListStatic>(json);
wrapper = new RuneListStaticWrapper(runes, language, runeData);
Cache.Add<RuneListStaticWrapper>(RunesCacheKey, wrapper);
}
return wrapper.RuneListStatic;
}
/// <summary>
/// Get a mastery asynchronously.
/// </summary>
/// <param name="region">Region from which to retrieve the data.</param>
/// <param name="masteryId">Id of the mastery to retrieve.</param>
/// <param name="masteryData">Data to retrieve.</param>
/// <param name="language">Language of th data to be retrieved.</param>
/// <returns>A mastery.</returns>
public async Task<MasteryStatic> GetMasteryAsync(Region region, int masteryId
, MasteryData masteryData = MasteryData.none, Language language = Language.en_US)
{
var wrapper = Cache.Get<MasteryStaticWrapper>(MasteryCacheKey + masteryId);
if (wrapper != null && wrapper.Language == language && wrapper.MasteryData == masteryData)
{
return wrapper.MasteryStatic;
}
else
{
var listWrapper = Cache.Get<MasteryListStaticWrapper>(MasteriesCacheKey);
if (listWrapper != null && listWrapper.Language == language && listWrapper.MasteryData == masteryData)
{
if (listWrapper.MasteryListStatic.Masteries.ContainsKey(masteryId))
{
return listWrapper.MasteryListStatic.Masteries[masteryId];
}
else
{
return null;
}
}
else
{
var json = await requester.CreateRequestAsync(string.Format(MasteryRootUrl, region.ToString())
+ string.Format(IdUrl, masteryId.ToString())
, new List<string>() { string.Format("locale={0}", language.ToString())
, masteryData == MasteryData.none ? string.Empty
: string.Format("masteryData={0}", masteryData.ToString()) });
var mastery = await JsonConvert.DeserializeObjectAsync<MasteryStatic>(json);
Cache.Add<MasteryStaticWrapper>(MasteryCacheKey + masteryId
, new MasteryStaticWrapper(mastery, language, masteryData));
return mastery;
}
}
}
/// <summary>
/// Get a list of all masteries asynchronously.
/// </summary>
/// <param name="region">Region from which to retrieve the data.</param>
/// <param name="masteryData">Data to retrieve.</param>
/// <param name="language">Language of the data to be retrieved.</param>
/// <returns>An MasteryListStatic object containing all masteries.</returns>
public async Task<MasteryListStatic> GetMasteriesAsync(Region region
, MasteryData masteryData = MasteryData.none, Language language = Language.en_US)
{
var wrapper = Cache.Get<MasteryListStaticWrapper>(MasteriesCacheKey);
if (wrapper == null || language != wrapper.Language || masteryData != wrapper.MasteryData)
{
var json = await requester.CreateRequestAsync(string.Format(MasteryRootUrl, region.ToString())
, new List<string>() { string.Format("locale={0}", language.ToString())
, masteryData == MasteryData.none ? string.Empty
: string.Format("masteryListData={0}", masteryData.ToString()) });
var masteries = await JsonConvert.DeserializeObjectAsync<MasteryListStatic>(json);
wrapper = new MasteryListStaticWrapper(masteries, language, masteryData);
Cache.Add<MasteryListStaticWrapper>(MasteriesCacheKey, wrapper);
}
return wrapper.MasteryListStatic;
}
/// <summary>
/// Get a list of all items synchronously.
/// </summary>
/// <param name="region">Region from which to retrieve the data.</param>
/// <param name="itemData">Data to retrieve.</param>
/// <param name="language">Language of the data to be retrieved.</param>
/// <returns>An ItemListStatic object containing all items.</returns>
public async Task<ItemListStatic> GetItemsAsync(Region region, ItemData itemData = ItemData.none
, Language language = Language.en_US)
{
var wrapper = Cache.Get<ItemListStaticWrapper>(ItemsCacheKey);
if (wrapper == null || language != wrapper.Language || itemData != wrapper.ItemData)
{
var json = await requester.CreateRequestAsync(string.Format(ItemRootUrl, region.ToString())
, new List<string>() { string.Format("locale={0}", language.ToString())
, itemData == ItemData.none ? string.Empty
: string.Format("itemListData={0}", itemData.ToString()) });
var items = await JsonConvert.DeserializeObjectAsync<ItemListStatic>(json);
wrapper = new ItemListStaticWrapper(items, language, itemData);
Cache.Add<ItemListStaticWrapper>(ItemsCacheKey, wrapper);
}
return wrapper.ItemListStatic;
}
public static string ToString(Language value)
{
return value.ToString().Replace('_', '-');
}
public static FunctionTree BuildFunctionTree(Guid userId, Language language)
{
FunctionTree tree = new FunctionTree();
try
{
using (SqlConnection sqlConnection = DataAccess.GetInstance().GetSqlConnection())
{
SqlCommand command = sqlConnection.CreateCommand();
command.CommandText = "[dbo].[FunctionTree_GetData]";
command.CommandType = System.Data.CommandType.StoredProcedure;
command.Parameters.Add(new SqlParameter("@userId", userId));
command.Parameters.Add(new SqlParameter("@language", language.ToString()));
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
Category category = new Category();
category.CategoryType = (ModuleCategoryType)Enum.Parse(typeof(ModuleCategoryType), reader["CategoryCode"].ToString());
category.CategoryDescription = reader["Description"].ToString();
tree.Categories.Add(category);
}
reader.NextResult();
while (reader.Read())
{
Module module = new Module();
module.Type = (ModuleType)Enum.Parse(typeof(ModuleType), reader["ModuleCode"].ToString());
module.ModuleDescription = reader["Description"].ToString();
module.Category = (ModuleCategoryType)Enum.Parse(typeof(ModuleCategoryType), reader["parentCode"].ToString());
tree.Modules.Add(module);
}
}
return tree;
}
catch (Exception ex)
{
Logger.AddEvent(TraceEventType.Error, "UserDataAccess.BuildFunctionTree error:\r\n{0}", ex.ToString());
return tree;
}
}
/// <summary>
/// Get a summoner spell asynchronously.
/// </summary>
/// <param name="region">Region from which to retrieve the data.</param>
/// <param name="summonerSpell">Summoner spell to retrieve.</param>
/// <param name="summonerSpellData">Data to retrieve.</param>
/// <param name="language">Language of the data to be retrieved.</param>
/// <returns>A summoner spell.</returns>
public async Task<SummonerSpellStatic> GetSummonerSpellAsync(Region region, SummonerSpell summonerSpell
, SummonerSpellData summonerSpellData = SummonerSpellData.none, Language language = Language.en_US)
{
var wrapper = Cache.Get<SummonerSpellStaticWrapper>(SummonerSpellCacheKey + summonerSpell.ToCustomString());
if (wrapper != null && wrapper.SummonerSpellData == summonerSpellData && wrapper.Language == language)
{
return wrapper.SummonerSpellStatic;
}
else
{
var listWrapper = Cache.Get<SummonerSpellListStaticWrapper>(SummonerSpellsCacheKey);
if (listWrapper != null && listWrapper.SummonerSpellData == summonerSpellData
&& listWrapper.Language == language)
{
if (listWrapper.SummonerSpellListStatic.SummonerSpells.ContainsKey(summonerSpell.ToCustomString()))
{
return listWrapper.SummonerSpellListStatic.SummonerSpells[summonerSpell.ToCustomString()];
}
else
{
return null;
}
}
else
{
var json = await requester.CreateRequestAsync(string.Format(SummonerSpellRootUrl, region.ToString())
+ string.Format(IdUrl, (int)summonerSpell)
, new List<string>() { string.Format("locale={0}", language.ToString())
, summonerSpellData == SummonerSpellData.none ? string.Empty
: string.Format("spellData={0}", summonerSpellData.ToString()) });
var spell = await JsonConvert.DeserializeObjectAsync<SummonerSpellStatic>(json);
Cache.Add<SummonerSpellStaticWrapper>(SummonerSpellCacheKey + summonerSpell.ToCustomString()
, new SummonerSpellStaticWrapper(spell, language, summonerSpellData));
return spell;
}
}
}
/// <summary>
/// Get a champion asynchronously.
/// </summary>
/// <param name="region">Region from which to retrieve the data.</param>
/// <param name="championId">Id of the champion to retrieve.</param>
/// <param name="championData">Data to retrieve.</param>
/// <param name="language">Language of the data to be retrieved.</param>
/// <returns>A champion.</returns>
public async Task<ChampionStatic> GetChampionAsync(Region region, int championId
, ChampionData championData = ChampionData.none, Language language = Language.en_US)
{
var wrapper = Cache.Get<ChampionStaticWrapper>(ChampionCacheKey + championId);
if (wrapper != null && wrapper.Language == language && wrapper.ChampionData == championData)
{
return wrapper.ChampionStatic;
}
else
{
var listWrapper = Cache.Get<ChampionListStaticWrapper>(ChampionsCacheKey);
if (listWrapper != null && listWrapper.Language == language && listWrapper.ChampionData == championData)
{
return listWrapper.ChampionListStatic.Champions.Values
.Where((c) => c.Id == championId).FirstOrDefault();
}
else
{
var json = await requester.CreateRequestAsync(string.Format(ChampionRootUrl, region.ToString())
+ string.Format(IdUrl, championId)
, new List<string>() { string.Format("locale={0}", language.ToString())
, championData == ChampionData.none ? string.Empty
: string.Format("champData={0}", championData.ToString()) });
var champ = await JsonConvert.DeserializeObjectAsync<ChampionStatic>(json);
Cache.Add<ChampionStaticWrapper>(ChampionCacheKey + championId
, new ChampionStaticWrapper(champ, language, championData));
return champ;
}
}
}
/// <summary>
/// Get an item asynchronously.
/// </summary>
/// <param name="region">Region from which to retrieve the data.</param>
/// <param name="itemId">Id of the item to retrieve.</param>
/// <param name="itemData">Data to retrieve.</param>
/// <param name="language">Language of the data to be retrieved.</param>
/// <returns>An item.</returns>
public async Task<ItemStatic> GetItemAsync(Region region, int itemId, ItemData itemData = ItemData.none
, Language language = Language.en_US)
{
var wrapper = Cache.Get<ItemStaticWrapper>(ItemCacheKey + itemId);
if (wrapper != null && wrapper.Language == language && wrapper.ItemData == itemData)
{
return wrapper.ItemStatic;
}
else
{
var listWrapper = Cache.Get<ItemListStaticWrapper>(ItemsCacheKey);
if (listWrapper != null && listWrapper.Language == language && listWrapper.ItemData == itemData)
{
if (listWrapper.ItemListStatic.Items.ContainsKey(itemId))
{
return listWrapper.ItemListStatic.Items[itemId];
}
else
{
return null;
}
}
else
{
var json = await requester.CreateRequestAsync(string.Format(ItemRootUrl, region.ToString())
+ string.Format(IdUrl, itemId)
, new List<string>() { string.Format("locale={0}", language.ToString())
, itemData == ItemData.none ? string.Empty
: string.Format("itemData={0}", itemData.ToString()) });
var item = await JsonConvert.DeserializeObjectAsync<ItemStatic>(json);
Cache.Add<ItemStaticWrapper>(ItemCacheKey + itemId, new ItemStaticWrapper(item, language, itemData));
return item;
}
}
}
