/// <summary>
/// Checks if specified provider is up to date (compares local version to server version).
/// </summary>
/// <param name="type">Translation provider type.</param>
/// <returns>True if local version is greater than or equal to remote.</returns>
public bool IsUpToDate(TranslationProviderType type)
{
if ((!versions.ContainsKey(type)) || (versions[type] == null) || !apiAvailable)
{
return(true);
}
switch (type)
{
case TranslationProviderType.App:
Version remoteAppVersion, localAppVersion = Assembly.GetEntryAssembly().GetName().Version;
if (!Version.TryParse(versions[type], out remoteAppVersion))
{
return(true);
}
return(remoteAppVersion <= localAppVersion);
default:
int verRemote, verLocal;
if (!int.TryParse(versions[type], out verRemote))
{
return(true);
}
if (!int.TryParse(TranslationDataProvider.Version(type), out verLocal))
{
return(false);
}
return(verRemote <= verLocal);
}
}
public void DeferredInit(object sender, IKanColleClientSettings value)
{
TranslationDataProvider.ChangeCulture(value.Culture, true);
this.Translations = new Translations(TranslationDataProvider.CurrentCulture);
this.Updater = new Updater(ApiUrl, TranslationDataProvider.CurrentCulture);
TranslationDataProvider.ChangeCulture(value.Culture);
}
/// <summary>
/// Looks up a translated string for a resource.
/// </summary>
/// <param name="type">Resource type.</param>
/// <param name="rawData">Raw API data; provides the necessary data (ID, names, etc.) for a look-up.</param>
/// <returns></returns>
public string Lookup(TranslationType type, object rawData)
{
if (!EnableTranslations || CurrentCulture.StartsWith("ja"))
{
Debug.WriteLine(this.GetType().Name + ": lookup called for {0} but translations are disabled or culture is Japanese.", type);
return(null);
}
return(TranslationDataProvider.Lookup(type, rawData));
}
/// <summary>
/// Checks if any updates are needed, downloads and serialises them for local storage.
/// </summary>
private void UpdateAsNeeded()
{
Debug.WriteLine("API available: {0}, Updates enabled: {1}", apiAvailable, EnableUpdates);
if (!apiAvailable || !EnableUpdates)
{
return;
}
foreach (var version in versions)
{
if (!this.IsUpToDate(version.Key))
{
Debug.WriteLine("Updater: {0} needs update; local version: {1}, remote: {2}.", version.Key, (version.Key != TranslationProviderType.App) ? TranslationDataProvider.Version(version.Key) : Assembly.GetEntryAssembly().GetName().Version.ToString(), string.IsNullOrEmpty(version.Value) ? "N/A" : version.Value);
if ((version.Key != TranslationProviderType.App) && this.FetchTranslations(version.Key))
{
TranslationDataProvider.SaveXml(version.Key);
}
}
}
}
/// <summary>
/// Downloads translations for the specified provider.
/// </summary>
/// <param name="type">Provider type.</param>
/// <returns></returns>
private bool FetchTranslations(TranslationProviderType type)
{
if (!apiAvailable)
{
return(false);
}
if (type == TranslationProviderType.App)
{
return(false);
}
if (type == TranslationProviderType.Operations)
{
return(false);
}
if (type == TranslationProviderType.Expeditions)
{
return(false);
}
var apiUri = new Uri(kcvApiUrl + type.ToString().ToLower() + "/");
using (var client = new ViewerWebClient())
{
byte[] responseBytes;
try
{
responseBytes = client.UploadValues(apiUri, "POST", this.DefaultRequestParameters());
Debug.WriteLine("{0}: API request sent for {1}, URL: {2}. Response: {3}.", nameof(Updater), type, apiUri, Encoding.UTF8.GetString(responseBytes));
}
catch (Exception ex)
{
Debug.WriteLine("{0} API request sent for {1}, URL: {2}. Request failed with exception {3}.", nameof(Updater), type, apiUri, ex.Message);
return(false);
}
return(TranslationDataProvider.LoadJson(type, responseBytes));
}
}
/// <summary>
/// Loads remote version data from the URL specified.
/// </summary>
/// <param name="url">Remote version data URL.</param>
/// <returns>True if version information was retrieved and parsed successfully.</returns>
private bool LoadVersions(string url)
{
using (ViewerWebClient client = new ViewerWebClient())
{
byte[] responseBytes;
try
{
responseBytes = client.UploadValues(url, "POST", this.DefaultRequestParameters());
}
catch (Exception ex)
{
Debug.WriteLine("Updater: Could not access the API, reason: " + ex.Message + ".");
return(false);
}
kcvapi_version rawResult;
if (!this.TryConvertTo(responseBytes, out rawResult))
{
return(false);
}
bool cultureAvailable = rawResult.selected_culture == CurrentCulture;
if (!cultureAvailable)
{
Debug.WriteLine("Updater: server returned a different culture; expected {0}, got {1}.", CurrentCulture, rawResult.selected_culture);
}
Version apiRemoteVersion;
if (!Version.TryParse(rawResult.api_version, out apiRemoteVersion) && (apiRemoteVersion.CompareTo("1.0") >= 0))
{
Debug.WriteLine("Updater: Server API version check failed.");
return(false);
}
kcvApiUrl = rawResult.api_url;
Debug.WriteLine("Updater: remote API version {0}; providers available: {1}.", rawResult.api_version, rawResult.components.Count());
foreach (var component in rawResult.components)
{
Debug.WriteLine("Updater: provider {0}: version {1}{2}.", component.type, component.version, string.IsNullOrEmpty(component.url) ? "" : " (" + component.url + ")");
var typeTemp = TranslationDataProvider.StringToTranslationProviderType(component.type);
if (typeTemp == null)
{
continue;
}
// Enforce version = 1 for unsupported cultures
// versions[typeTemp.Value] = (!cultureAvailable && (typeTemp != TranslationProviderType.App)) ? "1" : component.version;
// If not enforced, upon adding a new culture its components' versions must be set to values greater than those for 'en'.
versions[typeTemp.Value] = component.version;
if (typeTemp == TranslationProviderType.App)
{
downloadUrl = component.url; // TODO: proper implementation of overrides for all resource types
}
}
}
return(true);
}
