public ActionResult DeleteConfirmed(int id)
{
StoreLanguage storelanguage = StoreLanguageRepository.GetSingle(id);
try
{
StoreLanguageRepository.Delete(storelanguage);
StoreLanguageRepository.Save();
if (IsSuperAdmin)
{
return(RedirectToAction("Index", new { storeId = storelanguage.StoreId }));
}
else
{
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
Logger.Error(ex, "Unable to delete it:" + storelanguage);
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return(View(storelanguage));
}
/// <summary>
/// Converts a StoreLanguage to a Steam accepted API language code
/// </summary>
/// <param name="language">Language to convert</param>
/// <returns>Steam Store API language code</returns>
public static string GetStoreLanguage(StoreLanguage language)
{
string storeLanguage;
switch (language)
{
case StoreLanguage.ChineseSimplified:
storeLanguage = "schinese";
break;
case StoreLanguage.ChineseTraditional:
storeLanguage = "tchinese";
break;
case StoreLanguage.Korean:
storeLanguage = "koreana";
break;
case StoreLanguage.PortugueseBrasil:
storeLanguage = "brazilian";
break;
default:
storeLanguage = language.ToString();
break;
}
return(storeLanguage.ToLower());
}
/// <summary>
/// Returns the CultureInfo from the specified StoreLanguage.
/// </summary>
/// <param name="language">
/// Language to get the matching culture from.
/// </param>
/// <returns>
/// CultureInfo of the specified StoreLanguage.
/// </returns>
/// <remarks>
/// Based on the "Web API language code" column:
/// https://partner.steamgames.com/doc/store/localization
/// </remarks>
public static CultureInfo GetCultureInfo(StoreLanguage language)
{
CultureInfo cultureInfo;
switch (language)
{
case StoreLanguage.ChineseSimplified:
cultureInfo = new CultureInfo("zh-CN");
break;
case StoreLanguage.ChineseTraditional:
cultureInfo = new CultureInfo("zh-TW");
break;
case StoreLanguage.PortugueseBrasil:
cultureInfo = new CultureInfo("pt-BR");
break;
default:
cultureInfo = CultureInfo.GetCultures(CultureTypes.AllCultures).First(c => c.EnglishName == language.ToString());
break;
}
return(cultureInfo);
}
public void Load(string path, bool compress)
{
Logger.Info(GlobalStrings.GameDB_LoadingGameDBFrom, path);
XmlDocument doc = new XmlDocument();
Stream stream = null;
try
{
stream = new FileStream(path, FileMode.Open);
if (compress)
{
stream = new GZipStream(stream, CompressionMode.Decompress);
}
doc.Load(stream);
Logger.Info(GlobalStrings.GameDB_GameDBXMLParsed);
Games.Clear();
ClearAggregates();
XmlNode gameListNode = doc.SelectSingleNode("/" + XmlName_RootNode);
int fileVersion = XmlUtil.GetIntFromNode(gameListNode[XmlName_Version], 0);
LastHltbUpdate = XmlUtil.GetIntFromNode(gameListNode[XmlName_LastHltbUpdate], 0);
dbLanguage = (StoreLanguage)Enum.Parse(typeof(StoreLanguage), XmlUtil.GetStringFromNode(gameListNode[XmlName_dbLanguage], "en"), true);
if (fileVersion == 1)
{
LoadGamelistVersion1(gameListNode);
}
else
{
XmlSerializer x = new XmlSerializer(typeof(DatabaseEntry));
foreach (XmlNode gameNode in gameListNode.SelectSingleNode(XmlName_Games).ChildNodes)
{
XmlReader reader = new XmlNodeReader(gameNode);
DatabaseEntry entry = (DatabaseEntry)x.Deserialize(reader);
Games.Add(entry.Id, entry);
}
}
Logger.Info("GameDB XML processed, load complete. Db Language: " + dbLanguage);
}
finally
{
stream?.Close();
}
}
private void changeStoreLanguage(StoreLanguage storeLanguage)
{
if (Program.GameDB == null)
{
return;
}
StoreLanguage dbLanguage = StoreLanguage.en;
if (storeLanguage == StoreLanguage.windows)
{
CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
if (Enum.GetNames(typeof(StoreLanguage)).ToList().Contains(currentCulture.TwoLetterISOLanguageName))
{
dbLanguage =
(StoreLanguage)Enum.Parse(typeof(StoreLanguage), currentCulture.TwoLetterISOLanguageName);
}
else
{
if (currentCulture.Name == "zh-Hans" || currentCulture.Parent.Name == "zh-Hans")
{
dbLanguage = StoreLanguage.zh_Hans;
}
else if (currentCulture.Name == "zh-Hant" || currentCulture.Parent.Name == "zh-Hant")
{
dbLanguage = StoreLanguage.zh_Hant;
}
else if (currentCulture.Name == "pt-BR" || currentCulture.Parent.Name == "pt-BR")
{
dbLanguage = StoreLanguage.pt_BR;
}
}
}
else
{
dbLanguage = storeLanguage;
}
if (Program.GameDB.dbLanguage != dbLanguage)
{
Program.GameDB.dbLanguage = dbLanguage;
foreach (GameDBEntry g in Program.GameDB.Games.Values)
{
g.Tags = null;
g.Flags = null;
g.Genres = null;
g.SteamReleaseDate = null;
g.LastStoreScrape = 0;
}
Program.GameDB.Save("GameDB.xml.gz");
}
string test = Thread.CurrentThread.CurrentCulture.Name;
}
public void TestStoreLanguageRepositoryGetSingle()
{
var log = new StoreLanguageRepository(new StoreContext(ConnectionString));
var storeLanguange = new StoreLanguage();
storeLanguange.LanguageCode = "tr-test";
storeLanguange.Name = "Turkce";
storeLanguange.UpdatedDate = DateTime.Now;
storeLanguange.CreatedDate = DateTime.Now;
storeLanguange.State = true;
storeLanguange.StoreId = 9;
storeLanguange.Ordering = 1;
log.Add(storeLanguange);
log.Save();
}
public void ChangeLanguage(StoreLanguage language)
{
StoreLanguage dbLang = language;
if (Language == dbLang)
{
return;
}
Language = dbLang;
//clean DB from data in wrong language
foreach (DatabaseEntry g in Games.Values)
{
if (g.Id <= 0)
{
continue;
}
g.Tags = null;
g.Flags = null;
g.Genres = null;
g.SteamReleaseDate = null;
g.LastStoreScrape = 1; //pretend it is really old data
g.VRSupport = new VRSupport();
g.LanguageSupport = new LanguageSupport();
}
//Update DB with data in correct language
Queue <int> gamesToUpdate = new Queue <int>();
if (FormMain.CurrentProfile != null)
{
foreach (GameInfo game in FormMain.CurrentProfile.GameData.Games.Values)
{
if (game.Id > 0)
{
gamesToUpdate.Enqueue(game.Id);
}
}
using (DbScrapeDlg dialog = new DbScrapeDlg(gamesToUpdate))
{
dialog.ShowDialog();
}
}
Save();
}
public static CultureInfo GetCultureInfoFromStoreLanguage(StoreLanguage dbLanguage)
{
string l = Enum.GetName(typeof(StoreLanguage), dbLanguage);
CultureInfo culture = CultureInfo.GetCultureInfo("en");
if (l == "zh_Hans")
{
culture = CultureInfo.GetCultureInfo("zh-Hans");
}
else if (l == "zh_Hant")
{
culture = CultureInfo.GetCultureInfo("zh-Hant");
}
else if (l == "pt-BR")
{
culture = CultureInfo.GetCultureInfo("pt-BR");
}
else if (l == "windows")
{
CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
if (Enum.GetNames(typeof(StoreLanguage)).ToList().Contains(currentCulture.TwoLetterISOLanguageName))
{
culture = currentCulture;
}
else
{
if (currentCulture.Name == "zh-Hans" || currentCulture.Parent.Name == "zh-Hans")
{
culture = CultureInfo.GetCultureInfo("zh-Hans");
}
else if (currentCulture.Name == "zh-Hant" || currentCulture.Parent.Name == "zh-Hant")
{
culture = CultureInfo.GetCultureInfo("zh-Hant");
}
else if (currentCulture.Name == "pt-BR" || currentCulture.Parent.Name == "pt-BR")
{
culture = CultureInfo.GetCultureInfo("pt-BR");
}
}
}
else
{
culture = CultureInfo.GetCultureInfo(l);
}
return(culture);
}
public ActionResult SaveOrEdit(int id = 0, int selectedStoreId = 0)
{
var item = new StoreLanguage();
if (id != 0)
{
item = StoreLanguageRepository.GetSingle(id);
item.UpdatedDate = DateTime.Now;
}
else
{
item.UpdatedDate = DateTime.Now;
item.CreatedDate = DateTime.Now;
item.State = true;
item.StoreId = selectedStoreId;
}
return(View(item));
}
public void ChangeLanguage(StoreLanguage language)
{
if (Program.Database == null)
{
return;
}
if (dbLanguage == language)
{
return;
}
dbLanguage = language;
foreach (DatabaseEntry entry in Games.Values)
{
if (entry.Id <= 0)
{
continue;
}
entry.Clear();
}
List <int> toUpdate = new List <int>();
if (FormMain.CurrentProfile != null)
{
foreach (GameInfo game in FormMain.CurrentProfile.GameData.Games.Values)
{
if (game.Id > 0)
{
toUpdate.Add(game.Id);
}
}
using (ScrapeDialog dialog = new ScrapeDialog(toUpdate))
{
dialog.ShowDialog();
}
}
Save("GameDB.xml.gz");
}
public ActionResult SaveOrEdit(StoreLanguage model)
{
try
{
if (ModelState.IsValid)
{
if (model.Id == 0)
{
StoreLanguageRepository.Add(model);
}
else
{
StoreLanguageRepository.Edit(model);
}
StoreLanguageRepository.Save();
if (IsSuperAdmin)
{
return(RedirectToAction("Index", new { storeId = model.StoreId }));
}
else
{
return(RedirectToAction("Index"));
}
}
}
catch (DbEntityValidationException ex)
{
var message = GetDbEntityValidationExceptionDetail(ex);
Logger.Error(ex, "DbEntityValidationException:" + message);
}
catch (Exception ex)
{
Logger.Error(ex, "Unable to save changes:" + model);
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return(View(model));
}
public void ChangeLanguage(StoreLanguage language)
{
StoreLanguage dbLang = language;
if (Language == dbLang)
{
return;
}
Language = dbLang;
//clean DB from data in wrong language
foreach (DatabaseEntry g in Values)
{
if (g.Id <= 0)
{
continue;
}
g.Tags = null;
g.Flags = null;
g.Genres = null;
g.SteamReleaseDate = null;
g.LastStoreScrape = 1; //pretend it is really old data
g.VRSupport = new VRSupport();
g.LanguageSupport = new LanguageSupport();
}
// Update DB with data in correct language
List <int> appIds = new List <int>();
if (FormMain.CurrentProfile != null)
{
appIds.AddRange(FormMain.CurrentProfile.GameData.Games.Values.Where(g => g.Id > 0).Select(g => g.Id));
using (DbScrapeDlg dialog = new DbScrapeDlg(appIds))
{
dialog.ShowDialog();
}
}
Save();
}
public static CultureInfo GetCultureInfoFromStoreLanguage(StoreLanguage storeLanguage)
{
CultureInfo cultureInfo = CultureInfo.CurrentCulture;
try
{
string language = storeLanguage == StoreLanguage.Default ? Settings.Instance.InterfaceLanguage.ToString() : storeLanguage.ToString();
foreach (CultureInfo culture in CultureInfo.GetCultures(CultureTypes.AllCultures))
{
if (culture.EnglishName == language)
{
cultureInfo = culture;
}
}
}
catch (Exception e)
{
SentryLogger.Log(e);
}
return(cultureInfo);
}
public static CultureInfo GetCulture(StoreLanguage language)
{
CultureInfo culture;
switch (language)
{
case StoreLanguage.Arabic:
culture = new CultureInfo("ar");
break;
case StoreLanguage.Bulgarian:
culture = new CultureInfo("bg");
break;
case StoreLanguage.ChineseSimplified:
culture = new CultureInfo("zh-CN");
break;
case StoreLanguage.ChineseTraditional:
culture = new CultureInfo("zh-TW");
break;
case StoreLanguage.Czech:
culture = new CultureInfo("cs");
break;
case StoreLanguage.Danish:
culture = new CultureInfo("da");
break;
case StoreLanguage.Dutch:
culture = new CultureInfo("nl");
break;
case StoreLanguage.English:
culture = new CultureInfo("en");
break;
case StoreLanguage.Finnish:
culture = new CultureInfo("fi");
break;
case StoreLanguage.French:
culture = new CultureInfo("fr");
break;
case StoreLanguage.German:
culture = new CultureInfo("de");
break;
case StoreLanguage.Greek:
culture = new CultureInfo("el");
break;
case StoreLanguage.Hungarian:
culture = new CultureInfo("hu");
break;
case StoreLanguage.Italian:
culture = new CultureInfo("it");
break;
case StoreLanguage.Japanese:
culture = new CultureInfo("ja");
break;
case StoreLanguage.Korean:
culture = new CultureInfo("ko");
break;
case StoreLanguage.Norwegian:
culture = new CultureInfo("no");
break;
case StoreLanguage.Polish:
culture = new CultureInfo("pl");
break;
case StoreLanguage.Portuguese:
culture = new CultureInfo("pt");
break;
case StoreLanguage.PortugueseBrasil:
culture = new CultureInfo("pt-BR");
break;
case StoreLanguage.Romanian:
culture = new CultureInfo("ro");
break;
case StoreLanguage.Russian:
culture = new CultureInfo("ru");
break;
case StoreLanguage.Spanish:
culture = new CultureInfo("es");
break;
case StoreLanguage.Swedish:
culture = new CultureInfo("sv");
break;
case StoreLanguage.Thai:
culture = new CultureInfo("th");
break;
case StoreLanguage.Turkish:
culture = new CultureInfo("tr");
break;
case StoreLanguage.Ukrainian:
culture = new CultureInfo("uk");
break;
default:
throw new ArgumentOutOfRangeException(nameof(language), language, null);
}
return(culture);
}
public void ChangeLanguage(StoreLanguage lang)
{
if (Program.Database == null)
{
return;
}
StoreLanguage dbLang = StoreLanguage.en;
if (lang == StoreLanguage.windows)
{
CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
if (Enum.GetNames(typeof(StoreLanguage)).ToList().Contains(currentCulture.TwoLetterISOLanguageName))
{
dbLang = (StoreLanguage)Enum.Parse(typeof(StoreLanguage), currentCulture.TwoLetterISOLanguageName);
}
else
{
if ((currentCulture.Name == "zh-Hans") || (currentCulture.Parent.Name == "zh-Hans"))
{
dbLang = StoreLanguage.zh_Hans;
}
else if ((currentCulture.Name == "zh-Hant") || (currentCulture.Parent.Name == "zh-Hant"))
{
dbLang = StoreLanguage.zh_Hant;
}
else if ((currentCulture.Name == "pt-BR") || (currentCulture.Parent.Name == "pt-BR"))
{
dbLang = StoreLanguage.pt_BR;
}
}
}
else
{
dbLang = lang;
}
if (Language == dbLang)
{
return;
}
foreach (DatabaseEntry entry in Games.Values)
{
if (entry.Id <= 0)
{
continue;
}
entry.Tags.Clear();
entry.Flags.Clear();
entry.Genres.Clear();
entry.SteamReleaseDate = null;
entry.LastStoreScrape = 1; //pretend it is really old data
entry.VRSupport = new VRSupport();
entry.LanguageSupport = new LanguageSupport();
}
//Update DB with data in correct language
if (MainForm.CurrentProfile == null)
{
Save("GameDB.xml.gz");
return;
}
SortedSet <int> appIds = new SortedSet <int>();
foreach (GameInfo game in MainForm.CurrentProfile.GameData.Games.Values)
{
if (game.Id <= 0)
{
continue;
}
appIds.Add(game.Id);
}
using (ScrapeDialog dialog = new ScrapeDialog(appIds))
{
dialog.ShowDialog();
}
Save("GameDB.xml.gz");
}
/// <summary>
/// Returns a CultureInfo instance for the specified language.
/// </summary>
/// <param name="language">
/// Store language to get the CultureInfo for.
/// </param>
/// <returns>
/// Returns a CultureInfo instance.
/// </returns>
/// <remarks>
/// https://partner.steamgames.com/doc/store/localization
/// </remarks>
public static CultureInfo GetCultureInfo(StoreLanguage language)
{
switch (language)
{
case StoreLanguage.Arabic:
return(new CultureInfo("ar"));
case StoreLanguage.Bulgarian:
return(new CultureInfo("bg"));
case StoreLanguage.ChineseSimplified:
return(new CultureInfo("zh-CN"));
case StoreLanguage.ChineseTraditional:
return(new CultureInfo("zh-TW"));
case StoreLanguage.Czech:
return(new CultureInfo("cs"));
case StoreLanguage.Danish:
return(new CultureInfo("da"));
case StoreLanguage.Dutch:
return(new CultureInfo("nl"));
case StoreLanguage.English:
return(new CultureInfo("en"));
case StoreLanguage.Finnish:
return(new CultureInfo("fi"));
case StoreLanguage.French:
return(new CultureInfo("fr"));
case StoreLanguage.German:
return(new CultureInfo("de"));
case StoreLanguage.Greek:
return(new CultureInfo("el"));
case StoreLanguage.Hungarian:
return(new CultureInfo("hu"));
case StoreLanguage.Italian:
return(new CultureInfo("it"));
case StoreLanguage.Japanese:
return(new CultureInfo("ja"));
case StoreLanguage.Korean:
return(new CultureInfo("ko"));
case StoreLanguage.Norwegian:
return(new CultureInfo("no"));
case StoreLanguage.Polish:
return(new CultureInfo("pl"));
case StoreLanguage.Portuguese:
return(new CultureInfo("pt"));
case StoreLanguage.PortugueseBrasil:
return(new CultureInfo("pt-BR"));
case StoreLanguage.Romanian:
return(new CultureInfo("ro"));
case StoreLanguage.Russian:
return(new CultureInfo("ru"));
case StoreLanguage.Spanish:
return(new CultureInfo("es"));
case StoreLanguage.SpanishLatin:
// TODO: Confirm this is the proper language code.
return(new CultureInfo("es-MX"));
case StoreLanguage.Swedish:
return(new CultureInfo("sv"));
case StoreLanguage.Thai:
return(new CultureInfo("th"));
case StoreLanguage.Turkish:
return(new CultureInfo("tr"));
case StoreLanguage.Ukrainian:
return(new CultureInfo("uk"));
case StoreLanguage.Vietnamese:
return(new CultureInfo("vi"));
default:
throw new ArgumentOutOfRangeException(nameof(language), language, null);
}
}
/// <summary>
/// Returns the Steam Store API language code for the specified language.
/// </summary>
/// <param name="language">
/// Store language to get the API code for.
/// </param>
/// <returns>
/// Returns the API language code.
/// </returns>
/// <remarks>
/// https://partner.steamgames.com/doc/store/localization
/// </remarks>
public static string LanguageCode(StoreLanguage language)
{
switch (language)
{
case StoreLanguage.Arabic:
return("arabic");
case StoreLanguage.Bulgarian:
return("bulgarian");
case StoreLanguage.ChineseSimplified:
// ReSharper disable once StringLiteralTypo
return("schinese");
case StoreLanguage.ChineseTraditional:
// ReSharper disable once StringLiteralTypo
return("tchinese");
case StoreLanguage.Czech:
return("czech");
case StoreLanguage.Danish:
return("danish");
case StoreLanguage.Dutch:
return("dutch");
case StoreLanguage.English:
return("english");
case StoreLanguage.Finnish:
return("finnish");
case StoreLanguage.French:
return("french");
case StoreLanguage.German:
return("german");
case StoreLanguage.Greek:
return("greek");
case StoreLanguage.Hungarian:
return("hungarian");
case StoreLanguage.Italian:
return("italian");
case StoreLanguage.Japanese:
return("japanese");
case StoreLanguage.Korean:
// ReSharper disable once StringLiteralTypo
return("koreana");
case StoreLanguage.Norwegian:
return("norwegian");
case StoreLanguage.Polish:
return("polish");
case StoreLanguage.Portuguese:
return("portuguese");
case StoreLanguage.PortugueseBrasil:
return("brazilian");
case StoreLanguage.Romanian:
return("romanian");
case StoreLanguage.Russian:
return("russian");
case StoreLanguage.Spanish:
return("spanish");
case StoreLanguage.SpanishLatin:
// ReSharper disable once StringLiteralTypo
return("latam");
case StoreLanguage.Swedish:
return("swedish");
case StoreLanguage.Thai:
return("thai");
case StoreLanguage.Turkish:
return("turkish");
case StoreLanguage.Ukrainian:
return("ukrainian");
case StoreLanguage.Vietnamese:
return("vietnamese");
default:
throw new ArgumentOutOfRangeException(nameof(language), language, null);
}
}
protected async Task <DateTime?> AddProductArtifactAsync(string key, string value, Product product, ProductBuild productBuild, bool successful)
{
var productArtifact = new ProductArtifact
{
ProductId = product.Id,
ProductBuildId = productBuild.Id,
ArtifactType = key,
Url = value
};
var updatedArtifact = WebRequestWrapper.GetFileInfo(productArtifact);
var existingArtifact = await ProductArtifactRepository
.Get().Where(a => a.ProductId == product.Id && a.ProductBuildId == productBuild.Id && a.ArtifactType == key && a.Url == value)
.FirstOrDefaultAsync();
if (existingArtifact != null)
{
// Not sure why we are getting multiple of these, but we don't want multiple entries.
// Should we ignore it or update? Ignore for now. Updating threw exceptions
Log.Information($"Updating Artifact: Id={existingArtifact.Id}");
updatedArtifact.Id = existingArtifact.Id;
// await ProductArtifactRepository.UpdateAsync(updatedArtifact);
}
else
{
var newArtifact = await ProductArtifactRepository.CreateAsync(updatedArtifact);
Log.Information($"Created Artifact: Id={newArtifact.Id}");
}
// On version.json, update the ProductBuild.Version
if (key == "version" && updatedArtifact.ContentType == "application/json")
{
try
{
var contents = WebClient.DownloadString(value);
var version = JsonConvert.DeserializeObject <Dictionary <string, object> >(contents);
if (version.ContainsKey("version"))
{
productBuild.Version = version["version"] as String;
await ProductBuildRepository.UpdateAsync(productBuild);
if (successful)
{
product.VersionBuilt = version["version"] as String;
await ProductRepository.UpdateAsync(product);
}
}
}
catch (Exception ex)
{
Log.Error(ex, $"Parsing {key}: {value}");
}
}
// On play-listing-manifest.json, update the Project.DefaultLanguage
if (key == "play-listing-manifest" && updatedArtifact.ContentType == "application/json")
{
try
{
var contents = WebClient.DownloadString(value);
var manifest = JsonConvert.DeserializeObject <Dictionary <string, object> >(contents);
if (manifest.ContainsKey("default-language"))
{
var languageName = manifest["default-language"] as String;
StoreLanguage storeLanguage = await LanguageRepository.Get().Where(lang => lang.Name == languageName).FirstOrDefaultAsync();
if (storeLanguage != null)
{
product.StoreLanguageId = storeLanguage.Id;
await ProductRepository.UpdateAsync(product);
}
}
}
catch (Exception ex)
{
Log.Error(ex, $"Parsing {key}: {value}");
}
}
return(updatedArtifact.LastModified);
}
//
// GET: /StoreLanguages/Delete/5
public ActionResult Delete(int id)
{
StoreLanguage storelanguage = StoreLanguageRepository.GetSingle(id);
return(View(storelanguage));
}
public static string GetStoreLanguage(StoreLanguage storeLanguage)
{
string language;
switch (storeLanguage)
{
case StoreLanguage.Arabic:
language = "arabic";
break;
case StoreLanguage.Bulgarian:
language = "bulgarian";
break;
case StoreLanguage.ChineseSimplified:
language = "schinese";
break;
case StoreLanguage.ChineseTraditional:
language = "tchinese";
break;
case StoreLanguage.Czech:
language = "czech";
break;
case StoreLanguage.Danish:
language = "danish";
break;
case StoreLanguage.Dutch:
language = "dutch";
break;
case StoreLanguage.English:
language = "english";
break;
case StoreLanguage.Finnish:
language = "finnish";
break;
case StoreLanguage.French:
language = "french";
break;
case StoreLanguage.German:
language = "german";
break;
case StoreLanguage.Greek:
language = "greek";
break;
case StoreLanguage.Hungarian:
language = "hungarian";
break;
case StoreLanguage.Italian:
language = "italian";
break;
case StoreLanguage.Japanese:
language = "japanese";
break;
case StoreLanguage.Korean:
language = "koreana";
break;
case StoreLanguage.Norwegian:
language = "norwegian";
break;
case StoreLanguage.Polish:
language = "polish";
break;
case StoreLanguage.Portuguese:
language = "portuguese";
break;
case StoreLanguage.PortugueseBrasil:
language = "brazilian";
break;
case StoreLanguage.Romanian:
language = "romanian";
break;
case StoreLanguage.Russian:
language = "russian";
break;
case StoreLanguage.Spanish:
language = "spanish";
break;
case StoreLanguage.Swedish:
language = "swedish";
break;
case StoreLanguage.Thai:
language = "thai";
break;
case StoreLanguage.Turkish:
language = "turkish";
break;
case StoreLanguage.Ukrainian:
language = "ukrainian";
break;
default:
throw new ArgumentOutOfRangeException(nameof(storeLanguage), storeLanguage, null);
}
return(language);
}
public void ChangeStoreLanguage(StoreLanguage storeLanguage)
{
if (Program.GameDB == null)
{
return;
}
StoreLanguage dbLanguage = StoreLanguage.en;
if (storeLanguage == StoreLanguage.windows)
{
CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
if (Enum.GetNames(typeof(StoreLanguage)).ToList().Contains(currentCulture.TwoLetterISOLanguageName))
{
dbLanguage =
(StoreLanguage)Enum.Parse(typeof(StoreLanguage), currentCulture.TwoLetterISOLanguageName);
}
else
{
if (currentCulture.Name == "zh-Hans" || currentCulture.Parent.Name == "zh-Hans")
{
dbLanguage = StoreLanguage.zh_Hans;
}
else if (currentCulture.Name == "zh-Hant" || currentCulture.Parent.Name == "zh-Hant")
{
dbLanguage = StoreLanguage.zh_Hant;
}
else if (currentCulture.Name == "pt-BR" || currentCulture.Parent.Name == "pt-BR")
{
dbLanguage = StoreLanguage.pt_BR;
}
}
}
else
{
dbLanguage = storeLanguage;
}
if (Program.GameDB.dbLanguage != dbLanguage)
{
Program.GameDB.dbLanguage = dbLanguage;
//clean DB from data in wrong language
foreach (GameDBEntry g in Program.GameDB.Games.Values)
{
if (g.Id > 0)
{
g.Tags = null;
g.Flags = null;
g.Genres = null;
g.SteamReleaseDate = null;
g.LastStoreScrape = 0;
g.vrSupport = new VrSupport();
g.languageSupport = new LanguageSupport();
}
}
Program.GameDB.Save("GameDB.xml.gz");
//Update DB with data in correct language
Queue <int> gamesToUpdate = new Queue <int>();
if (FormMain.CurrentProfile != null)
{
foreach (GameInfo game in FormMain.CurrentProfile.GameData.Games.Values)
{
if (game.Id > 0)
{
gamesToUpdate.Enqueue(game.Id);
}
}
DbScrapeDlg scrapeDlg = new DbScrapeDlg(gamesToUpdate);
DialogResult scrapeRes = scrapeDlg.ShowDialog();
if (scrapeRes != DialogResult.Cancel && scrapeDlg.JobsCompleted > 0)
{
Program.GameDB.Save("GameDB.xml.gz");
}
}
}
}
public void ChangeLanguage(StoreLanguage language)
{
StoreLanguage dbLang = StoreLanguage.en;
if (language == StoreLanguage.windows)
{
CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
if (Enum.GetNames(typeof(StoreLanguage)).ToList().Contains(currentCulture.TwoLetterISOLanguageName))
{
dbLang = (StoreLanguage)Enum.Parse(typeof(StoreLanguage), currentCulture.TwoLetterISOLanguageName);
}
else
{
if (currentCulture.Name == "zh-Hans" || currentCulture.Parent.Name == "zh-Hans")
{
dbLang = StoreLanguage.zh_Hans;
}
else if (currentCulture.Name == "zh-Hant" || currentCulture.Parent.Name == "zh-Hant")
{
dbLang = StoreLanguage.zh_Hant;
}
else if (currentCulture.Name == "pt-BR" || currentCulture.Parent.Name == "pt-BR")
{
dbLang = StoreLanguage.pt_BR;
}
}
}
else
{
dbLang = language;
}
if (Language == dbLang)
{
return;
}
Language = dbLang;
//clean DB from data in wrong language
foreach (DatabaseEntry g in Games.Values)
{
if (g.Id > 0)
{
g.Tags = null;
g.Flags = null;
g.Genres = null;
g.SteamReleaseDate = null;
g.LastStoreScrape = 1; //pretend it is really old data
g.VrSupport = new VrSupport();
g.LanguageSupport = new LanguageSupport();
}
}
//Update DB with data in correct language
Queue <int> gamesToUpdate = new Queue <int>();
if (FormMain.CurrentProfile != null)
{
foreach (GameInfo game in FormMain.CurrentProfile.GameData.Games.Values)
{
if (game.Id > 0)
{
gamesToUpdate.Enqueue(game.Id);
}
}
DbScrapeDlg scrapeDlg = new DbScrapeDlg(gamesToUpdate);
scrapeDlg.ShowDialog();
}
Save("database.json");
}
public static CultureInfo GetCultureInfoFromStoreLanguage(StoreLanguage storeLanguage)
{
CultureInfo cultureInfo;
switch (storeLanguage)
{
case StoreLanguage.Default:
cultureInfo = CultureInfo.GetCultures(CultureTypes.AllCultures).FirstOrDefault(c => c.EnglishName == Settings.Instance.InterfaceLanguage.ToString());
break;
case StoreLanguage.Arabic:
cultureInfo = CultureInfo.GetCultureInfo("ar");
break;
case StoreLanguage.Bulgarian:
cultureInfo = CultureInfo.GetCultureInfo("bg");
break;
case StoreLanguage.Schinese:
cultureInfo = CultureInfo.GetCultureInfo("zh-CN");
break;
case StoreLanguage.Tchinese:
cultureInfo = CultureInfo.GetCultureInfo("zh-TW");
break;
case StoreLanguage.Czech:
cultureInfo = CultureInfo.GetCultureInfo("cs");
break;
case StoreLanguage.Danish:
cultureInfo = CultureInfo.GetCultureInfo("da");
break;
case StoreLanguage.Dutch:
cultureInfo = CultureInfo.GetCultureInfo("nl");
break;
case StoreLanguage.English:
cultureInfo = CultureInfo.GetCultureInfo("en");
break;
case StoreLanguage.Finnish:
cultureInfo = CultureInfo.GetCultureInfo("fi");
break;
case StoreLanguage.French:
cultureInfo = CultureInfo.GetCultureInfo("fr");
break;
case StoreLanguage.German:
cultureInfo = CultureInfo.GetCultureInfo("de");
break;
case StoreLanguage.Greek:
cultureInfo = CultureInfo.GetCultureInfo("el");
break;
case StoreLanguage.Hungarian:
cultureInfo = CultureInfo.GetCultureInfo("hu");
break;
case StoreLanguage.Italian:
cultureInfo = CultureInfo.GetCultureInfo("it");
break;
case StoreLanguage.Japanese:
cultureInfo = CultureInfo.GetCultureInfo("ja");
break;
case StoreLanguage.Koreana:
cultureInfo = CultureInfo.GetCultureInfo("ko");
break;
case StoreLanguage.Norwegian:
cultureInfo = CultureInfo.GetCultureInfo("no");
break;
case StoreLanguage.Polish:
cultureInfo = CultureInfo.GetCultureInfo("pl");
break;
case StoreLanguage.Portuguese:
cultureInfo = CultureInfo.GetCultureInfo("pt");
break;
case StoreLanguage.Brazilian:
cultureInfo = CultureInfo.GetCultureInfo("pt-BR");
break;
case StoreLanguage.Romanian:
cultureInfo = CultureInfo.GetCultureInfo("ro");
break;
case StoreLanguage.Russian:
cultureInfo = CultureInfo.GetCultureInfo("ru");
break;
case StoreLanguage.Spanish:
cultureInfo = CultureInfo.GetCultureInfo("es");
break;
case StoreLanguage.Swedish:
cultureInfo = CultureInfo.GetCultureInfo("sv");
break;
case StoreLanguage.Thai:
cultureInfo = CultureInfo.GetCultureInfo("th");
break;
case StoreLanguage.Turkish:
cultureInfo = CultureInfo.GetCultureInfo("tr");
break;
case StoreLanguage.Ukrainian:
cultureInfo = CultureInfo.GetCultureInfo("uk");
break;
default:
throw new ArgumentOutOfRangeException(nameof(storeLanguage), storeLanguage, null);
}
return(cultureInfo);
}
