/// <summary>
/// Initializes a new instance of the SettingsViewModel class.
/// </summary>
public SettingsViewModel()
{
AvailableLanguages = Configurator.returnAllLanguages();
selectedLanguage = AvailableLanguages.SingleOrDefault(l => l.FileName ==
Configurator.getLanguage());
FindCommand = new RelayCommand(SelectGameFolder);
if (!Configurator.getFirstStart())
{
Message = LocalizationHelper.getValueForKey("First_Start");
}
else
{
Message = "";
}
}
/// <summary>
/// Every item should start with Rarity in the first line.
/// This will force the TradeClient to refetch the Public API's data if needed.
/// </summary>
public async Task FindAndSetLanguage(string itemDescription)
{
if (string.IsNullOrEmpty(itemDescription))
{
return;
}
var language = AvailableLanguages.Find(x => itemDescription.StartsWith(x.DescriptionRarity));
if (language != null && SetLanguage(language.Name))
{
await cacheService.Clear();
await initializeService.Initialize();
}
}
private async void LoadLocales()
{
JsonObject json_res = await AvailableLanguages.getLocales("invoicing", CloureManager.lang);
txtAdvice.Text = json_res.GetNamedString("press_f2_to_finish");
tbDatePrompt.Text = json_res.GetNamedString("date");
tbCompanyBranchPrompt.Text = json_res.GetNamedString("branch");
tbReceiptType.Text = json_res.GetNamedString("receipt_type");
tbCustomerPrompt.Text = json_res.GetNamedString("customer");
tbCustomerNamePrompt.Text = json_res.GetNamedString("customer_name");
tbSaldoPrompt.Text = json_res.GetNamedString("balance");
tbProductsServicesPrompt.Text = json_res.GetNamedString("products_services");
tbQuantityPrompt.Text = json_res.GetNamedString("quantity");
tbProductPrompt.Text = json_res.GetNamedString("product_service");
tbObservationsPrompt.Text = json_res.GetNamedString("observations");
}
public override void Initialize()
{
Files.Clear();
foreach (var assembly in Assemblies.Keys)
{
var prefix = Assemblies[assembly];
var compare = !string.IsNullOrEmpty(prefix) ? f => f.StartsWith(prefix) && f.EndsWith(FileExtension)
: (Func <string, bool>)(f => f.EndsWith(FileExtension));
var files = assembly.GetManifestResourceNames().Where(compare).ToList();
var available = files.Select(s => s.Replace(FileExtension, string.Empty).Split('.').Where(st => st.Length == 2).LastOrDefault()).Distinct();
var list = AvailableLanguages.Union(available);
_languages = list.ToList();
Files.Add(assembly, files);
}
}
/// <summary>
/// Initializes a new instance of the TranslateXML class.
/// </summary>
/// <param name="Logger">
/// The logger.
/// </param>
public TranslateXML(ConsoleLogger Logger)
: base(Logger)
{
TranslationServiceFacade.Initialize();
if (!TranslationServiceFacade.IsTranslationServiceReady())
{
this.Logger.WriteLine(LogLevel.Error, "Invalid translation service credentials. Use \"DocumentTranslatorCmd setcredentials\", or use the Document Translator Settings option.");
return;
}
this.xmltotranslate = new Argument(
"XML",
true,
"The XML file in need of translation");
this.elementsdispositioncsv = new Argument(
"Elements",
true,
"CSV file listing the elements to translate");
this.fromlanguage = new Argument(
"from",
false,
new[] { "Auto-Detect" },
AvailableLanguages.GetLanguages().Result.Keys.ToArray(),
true,
"The source language. Auto-detect if no language specified.");
this.tolanguage = new SimpleStringArgument(
"to",
true,
new string[] { },
AvailableLanguages.GetLanguages().Result.Keys.ToArray(),
new[] { ',' },
"The target language code, or comma-separated list of language codes.");
this.generatecsv = new BooleanArgument(
"generate",
false,
false,
"Set to true if you want to generate a list of elements.");
this.Arguments = new ArgumentList(
new[] { this.xmltotranslate, this.elementsdispositioncsv, this.fromlanguage, this.tolanguage, this.generatecsv },
Logger);
}
public override void LoadLanguage(string language = null)
{
if (language == null)
{
language = TranslationLoader.CurrentLanguage;
}
if (AvailableLanguages.Contains(language) && !LoadedLanguages.Contains(language))
{
foreach (var assembly in Files.Keys)
{
var files = Files[assembly].Where(f => f.Contains($".{language}.")).ToList();
files.ForEach(f => LoadFile(f, assembly, language));
}
}
_loaded.Add(language);
Translate.AddLoaded(language);
}
public UILanguageProvider(SidekickSettings settings)
{
AvailableLanguages = SupportedLanguages
.Select(x => new CultureInfo(x))
.ToList();
var current = AvailableLanguages.FirstOrDefault(x => x.Name == settings.Language_UI);
if (current != null)
{
SetLanguage(settings.Language_UI);
}
else
{
SetLanguage(SupportedLanguages.FirstOrDefault());
}
}
/// <summary>
/// Change the language, this will only do something if the language actually changed.
/// All files are reloaded.
/// </summary>
/// <param name="ietf">The iso code for the language to use</param>
/// <param name="cancellationToken">CancellationToken for the loading</param>
/// <returns>Task</returns>
public async Task ChangeLanguageAsync(string ietf, CancellationToken cancellationToken = default)
{
if (ietf == CurrentLanguage)
{
return;
}
Log.Verbose().WriteLine("Changing language to {0}", ietf);
if (AvailableLanguages.ContainsKey(ietf))
{
CurrentLanguage = ietf;
await ReloadAsync(cancellationToken).ConfigureAwait(false);
}
else
{
Log.Warn().WriteLine("Language {0} was not available.", ietf);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TranslateDocuments" /> class.
/// </summary>
/// <param name="Logger">
/// The logger.
/// </param>
public TranslateDocuments(ConsoleLogger Logger)
: base(Logger)
{
try
{
_ = TranslationServiceFacade.Initialize();
}
catch (CredentialsMissingException ex)
{
this.Logger.WriteLine(LogLevel.Error, ex.Message);
}
if (!TranslationServiceFacade.IsTranslationServiceReady())
{
this.Logger.WriteLine(LogLevel.Error, "Invalid translation service credentials. Use \"DocumentTranslatorCmd setcredentials\"");
return;
}
this.sourceDocuments = new SimpleStringArgument(
"Documents",
true,
new[] { ',' },
"Document to translate, or list of documents separated by comma, or a wildcard. Wildcard recurses through subfolders.");
this.sourceLanguage = new Argument(
"from",
false,
new[] { "Auto-Detect" },
AvailableLanguages.GetLanguages().Result.Keys.ToArray(),
true,
"The source language. Auto-detect if no language specified.");
this.targetLanguages = new SimpleStringArgument(
"to",
true,
new string[] { },
AvailableLanguages.GetLanguages().Result.Keys.ToArray(),
new[] { ',' },
"The target language code, or comma-separated list of language codes.");
this.Arguments = new ArgumentList(
new[] { this.sourceDocuments, this.sourceLanguage, this.targetLanguages },
Logger);
}
/// <summary>
/// Loads all languages.
/// </summary>
/// <param name="logger">The <see cref="ILogger" /> instance used within the sided API.</param>
/// <param name="assetManager">The <see cref="IAssetManager" /> instance used within the sided API.</param>
/// <param name="defaultLanguage">The language code to set as the default/fallback language for the game.</param>
public static void Load(ILogger logger, IAssetManager assetManager, string defaultLanguage = "en")
{
CurrentLocale = defaultLanguage;
var languageFile = Path.Combine(GamePaths.AssetsPath, "game", "lang", "languages.json");
var json = JsonObject.FromJson(File.ReadAllText(languageFile)).AsArray();
foreach (var jsonObject in json)
{
var languageCode = jsonObject["code"].AsString();
LoadLanguage(logger, assetManager, languageCode, languageCode != defaultLanguage);
}
if (!AvailableLanguages.ContainsKey(defaultLanguage))
{
logger.Error("Language '{0}' not found. Will default to english.", defaultLanguage);
CurrentLocale = "en";
}
}
public void AddAvailableLanguage(string languageShortName)
{
if (AvailableLanguages.Count == 0)
{
AvailableLanguages.Add(languageShortName);
}
else
{
foreach (string language in AvailableLanguages)
{
if (language == languageShortName)
{
return;
}
}
AvailableLanguages.Add(languageShortName);
return;
}
}
public static async Task <string> GetAllLanguages()
{
StringWriter writer = new StringWriter();
Dictionary <string, string> languagelist = new Dictionary <string, string>();
languagelist = await AvailableLanguages.GetLanguages();
writer.WriteLine("{0}\t{1}\t{2}", "Language", "Language Code", "Display Name");
writer.WriteLine("------------------------------------------------------");
foreach (KeyValuePair <string, string> language in languagelist.ToList())
{
Dictionary <string, string> languagesinlanguage = await AvailableLanguages.GetLanguages(language.Key);
foreach (KeyValuePair <string, string> lang in languagesinlanguage)
{
writer.WriteLine("{0}\t{1}\t{2}", language.Key, lang.Key, lang.Value);
}
writer.WriteLine("\n\n");
}
return(writer.ToString());
}
private void LogMissingTranslation(string textId, string defaultText)
{
if (LogOutMissingTranslations)
{
AvailableLanguages.ToList().ForEach(delegate(string languageId)
{
if (!TranslationsDictionary.ContainsKey(textId) ||
!TranslationsDictionary[textId].ContainsKey(languageId))
{
if (!MissingTranslations.ContainsKey(textId))
{
MissingTranslations.Add(textId, new SortedDictionary <string, string>());
}
MissingTranslations[textId][languageId] = $"default text : {defaultText}";
}
});
File.WriteAllText(missingTranslationsFileName,
JsonConvert.SerializeObject(MissingTranslations, Formatting.Indented));
}
}
internal void Load(string filePath)
{
var xmlDocument = new XmlDocument();
xmlDocument.Load(filePath);
var fileNamePart = filePath.Split('\\').Last().Split('.');
var languageId = fileNamePart.First().Split('_').Last().ToLowerInvariant();
_currentFileNameNoExtension = fileNamePart.First().Split('_').First();
if (!AvailableLanguages.Contains(languageId))
{
AvailableLanguages.Add(languageId);
}
var rootNode = xmlDocument.SelectSingleNode("Language");
foreach (XmlNode childNode in rootNode.ChildNodes)
{
ReadXmlNode(childNode, languageId, "Language", LangStrings);
}
}
private void ManipulateUX(AvailableLanguages Language, bool ShowProgressBar, bool ShowDownloadButton, bool ShowCancelButton, bool ShowRemoveButton)
{
if (ShowProgressBar)
{
ProgressBarList[(int)Language].Visibility = Visibility.Visible;
}
else
{
ProgressBarList[(int)Language].Visibility = Visibility.Collapsed;
}
if (ShowDownloadButton)
{
DownloadButtonList[(int)Language].Visibility = Visibility.Visible;
}
else
{
DownloadButtonList[(int)Language].Visibility = Visibility.Collapsed;
}
if (ShowCancelButton)
{
CancelButtonList[(int)Language].Visibility = Visibility.Visible;
}
else
{
CancelButtonList[(int)Language].Visibility = Visibility.Collapsed;
}
if (ShowRemoveButton)
{
RemoveButtonList[(int)Language].Visibility = Visibility.Visible;
}
else
{
RemoveButtonList[(int)Language].Visibility = Visibility.Collapsed;
}
}
/// <summary>
/// Populate available source and target languages.
/// </summary>
public void PopulateAvailableLanguages()
{
this.sourceLanguageList.Clear();
this.targetLanguageList.Clear();
if (!TranslationServiceFacade.UseCustomEndpoint)
{
this.sourceLanguageList.Add(Properties.Resources.Common_AutoDetect);
}
try
{
targetLanguageList.AddRange(AvailableLanguages.GetLanguages().Result.Values);
}
catch (Exception ex) {
this.StatusText = String.Format("{0}\n{1}", Properties.Resources.Error_LanguageList, ex.Message);
this.NotifyPropertyChanged("StatusText");
return;
};
this.targetLanguageList.Sort();
this.sourceLanguageList.AddRange(this.targetLanguageList);
this.NotifyPropertyChanged("SourceLanguageList");
this.NotifyPropertyChanged("TargetLanguageList");
Debug.WriteLine("DocumentTranslation.cs: targetLanguageList.Count: {0}", targetLanguageList.Count);
}
private bool SetLanguage(string name)
{
var language = AvailableLanguages.Find(x => x.Name == name);
if (language == null)
{
logger.Information("Couldn't find language matching {language}.", name);
return(false);
}
if (Language == null || Language.DescriptionRarity != language.DescriptionRarity)
{
logger.Information("Changed active language support to {language}.", language.Name);
Language = (ILanguage)Activator.CreateInstance(language.ImplementationType);
settings.Language_Parser = name;
settings.Save();
return(true);
}
return(false);
}
public RootViewModel(
IServerResponseService serverResponseService,
IFileProcessService fileProcessService,
IConfigurationService _configurationService,
IRecordService recordService)
{
_recordService = recordService;
_recordService.RecordStopped += delegate { IsTranscribingInProgress = false; };
_recordService.InfoMessage += delegate(object _sender, string message) { InfoMessage = message; };
_recordService.RecordLevel += delegate(object _sender, float level) { RecordLevel = level; };
_fontSizes = new int[] { 8, 12, 14, 16, 18, 20, 22, 24, 26 };
_selectedFontSize = _fontSizes[3];
_transportService = Mvx.IoCProvider.Resolve <ITransportService>();
_transportService.InfoMessage += delegate(object _sender, string message) { InfoMessage = message; };
_configurationService = new ConfigurationService();
_fileProcessService = fileProcessService;
_fileProcessService.PercentageTranscribed += UpdatePercentageTranscribed;
_fileProcessService.InfoMessage += delegate(object _sender, string message) { InfoMessage = message; };
_serverResponseService = serverResponseService;
_serverResponseService.HandledServerResponse += delegate(object _sender, string resp) { Transcription = resp; };
_serverResponseService.InfoMessage += delegate(object _sender, string message) { InfoMessage = message; };
ToggleTranscriptionCommand = new MvxCommand(StartTranscribing);
ClearTextCommand = new MvxCommand(_serverResponseService.Clear);
TranscribeFileCommand = new MvxAsyncCommand(TranscribeFile);
AvailableLanguages = _configurationService.GetLanguages().ToArray();
if (AvailableLanguages.Count() != 0)
{
SelectedLanguage = AvailableLanguages.Where(x => x.Key.ToLower() == "russian").FirstOrDefault();
}
}
/// <summary>Loads all available language files from the specificed folder</summary>
public static void LoadLanguageFiles(string LanguageFolder)
{
if (!Directory.Exists(LanguageFolder))
{
MessageBox.Show(@"The default language files have been moved or deleted.");
LoadEmbeddedLanguage();
return;
}
try {
string[] LanguageFiles = Directory.GetFiles(LanguageFolder, "*.xlf");
if (LanguageFiles.Length == 0)
{
MessageBox.Show(@"No valid language files were found.");
LoadEmbeddedLanguage();
return;
}
foreach (var File in LanguageFiles)
{
try
{
using (FileStream stream = new FileStream(File, FileMode.Open, FileAccess.Read))
using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
{
Language l = new Language(reader, System.IO.Path.GetFileNameWithoutExtension(File));
AvailableLanguages.Add(l);
}
}
catch
{
//Corrupt language file? Just ignore
}
}
} catch {
MessageBox.Show(@"An error occured whilst attempting to load the default language files.");
LoadEmbeddedLanguage();
}
}
/* Load localization for chosen language
*/
public static void LoadLocalization(AvailableLanguages language)
{
string file;
switch (language)
{
case AvailableLanguages.English:
file = Properties.Resources.English;
break;
case AvailableLanguages.Russian:
file = Properties.Resources.Russian;
break;
default:
file = Properties.Resources.English;
break;
}
XmlSerializer serializer = new XmlSerializer(typeof(LocalizedStrings));
MemoryStream memoryStream = new MemoryStream(Encoding.Unicode.GetBytes(file));
localized = (LocalizedStrings)serializer.Deserialize(memoryStream);
memoryStream.Close();
userLogKeywords = new Dictionary <string, Color>()
{
{ localized.regExWhite, Color.White },
{ localized.regExBlack, Color.Black },
{ localized.regExLoaded, Color.Lime },
{ localized.regExSaved, Color.Red },
{ localized.regExWon, Color.Coral }
};
currentLanguage = language;
}
private void LoadPage()
{
#region GetAvailableLanguages
string saveDir = Directory.GetCurrentDirectory();
bool ErrorsFound = false;
if (Directory.GetFiles(saveDir + "/Languages").Length > 1)
{
foreach (var file in Directory.GetFiles(saveDir + "/Languages", "*.lang"))
{
StreamReader langReader = new StreamReader(file);
string rawObj = langReader.ReadToEnd();
try
{
LanguageDataModel tempObj = JsonConvert.DeserializeObject <LanguageDataModel>(rawObj);
if (tempObj != null)
{
AvailableLanguages.Add(tempObj);
}
// MessageBox.Show(file);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
ErrorsFound = true;
}
}
if (ErrorsFound)
{
MessageBox.Show("Errors Found");
}
}
else
{
SelectedLanguage = new LanguageDataModel();
}
#endregion
#region LoadSavedSettings
if (File.Exists("Settings/settings.json"))
{
StreamReader settingsReader = new StreamReader("Settings/settings.json");
try
{
SettingsDataModel serializedData = JsonConvert.DeserializeObject <SettingsDataModel>(settingsReader.ReadToEnd());
// MessageBox.Show("loaded");
SelectedLanguage = AvailableLanguages.Single(lang => lang.LanguageName == serializedData.SelectedLanguage.LanguageName);
if (SelectedLanguage == null)
{
SelectedLanguage = new LanguageDataModel();
}
SelectedLanguageIndex = AvailableLanguages.IndexOf(SelectedLanguage);
HomeLocation = serializedData.HomeLocation;
SelectedUnitIndex = Units.IndexOf(serializedData.Unit);
}catch (Exception)
{
SelectedLanguage = new LanguageDataModel();
}
settingsReader.Dispose();
}
#endregion
}
public TemplateDocumentationPage(string templateFile, string relativeTemplateDirectory, TemplateDirectory templateDir)
{
_relativeTemplateDirectory = relativeTemplateDirectory;
TemplateFile = templateFile;
TemplateDir = templateDir;
string templateXMLFile = Path.Combine(Path.GetDirectoryName(templateFile), Path.GetFileNameWithoutExtension(templateFile) + ".xml");
if (!File.Exists(templateXMLFile))
{
throw new Exception(string.Format("Missing meta infos for template {0}!", templateFile));
}
TemplateXML = XElement.Load(templateXMLFile);
BitmapFrame icon = null;
if (TemplateXML.Element("icon") != null && TemplateXML.Element("icon").Attribute("file") != null)
{
var iconFile = Path.Combine(Path.GetDirectoryName(templateFile), TemplateXML.Element("icon").Attribute("file").Value);
if (iconFile == null || !File.Exists(iconFile))
{
iconFile = Path.Combine(Path.GetDirectoryName(templateFile), Path.GetFileNameWithoutExtension(templateFile) + ".png");
}
if (File.Exists(iconFile))
{
try
{
icon = BitmapFrame.Create(new BitmapImage(new Uri(iconFile)));
Icon = iconFile;
}
catch (Exception)
{
icon = null;
Icon = "";
}
}
}
var authorElement = XMLHelper.FindLocalizedChildElement(TemplateXML, "author");
if (authorElement != null)
{
AuthorName = authorElement.Value;
}
var relevantPlugins = TemplateXML.Element("relevantPlugins");
if (relevantPlugins != null)
{
RelevantPlugins = new List <string>();
foreach (var plugin in relevantPlugins.Elements("plugin"))
{
var name = plugin.Attribute("name");
if (name != null)
{
RelevantPlugins.Add(name.Value);
}
}
}
foreach (var title in TemplateXML.Elements("title"))
{
var langAtt = title.Attribute("lang");
if (langAtt != null && !AvailableLanguages.Contains(langAtt.Value))
{
Localizations.Add(langAtt.Value, new LocalizedTemplateDocumentationPage(this, langAtt.Value, icon));
}
}
if (!Localizations.ContainsKey("en"))
{
throw new Exception("Documentation should at least support english language!");
}
}
public void RemoveAvailableLanguage(string languageShortName)
{
AvailableLanguages.Remove(languageShortName);
}
/// <summary>
/// The execute.
/// </summary>
/// <returns>
/// The <see cref="bool" />.
/// </returns>
public override bool Execute()
{
int documentcount = 0;
List <String> listoffiles = new List <string>();
//Expand wildcard, if name specification contains *
if (this.sourceDocuments.Values.ToArray().Any(file => file.ToString().Contains("*")))
{
foreach (string filename in this.sourceDocuments.Values.ToArray())
{
int lastBackslashPosition = filename.LastIndexOf('\\') + 1;
string path = filename.Substring(0, lastBackslashPosition);
string filenameOnly = filename.Substring(lastBackslashPosition);
String[] filelist = Directory.GetFiles(path, filenameOnly, SearchOption.AllDirectories);
listoffiles.AddRange(filelist);
}
}
else //no * in the file name
{
foreach (var file in this.sourceDocuments.ValueString.Split(','))
{
listoffiles.Add(file);
}
}
try
{
var model = new CommentTranslationModel
{
SourceLanguage =
this.sourceLanguage.ValueString ?? "Auto-Detect",
TargetLanguage = this.targetLanguages.ValueString
};
foreach (var file in listoffiles)
{
if (!File.Exists(file))
{
Logger.WriteLine(LogLevel.Error, String.Format("Specified document {0} does not exist. ", file));
}
foreach (var language in this.targetLanguages.Values)
{
try
{
this.Logger.WriteLine(
LogLevel.Msg,
string.Format(
"Translating document {0} to language {1}.",
file,
language));
model.TargetPath = file;
var sourceLanguageExpanded = String.IsNullOrEmpty(this.sourceLanguage.ValueString) ||
this.sourceLanguage.ValueString.Equals("Auto-Detect")
? "Auto-Detect"
: AvailableLanguages.GetLanguages().Result[this.sourceLanguage.ValueString];
string languagename = TranslationServiceFacade.LanguageCodeToLanguageName(language.ToString());
DocumentTranslationManager.DoTranslation(
file,
false,
sourceLanguageExpanded,
languagename);
this.Logger.WriteLine(
LogLevel.Msg,
string.Format(
"-- Translated document name {0} to language {1}.",
file,
language));
documentcount++;
}
catch (Exception ex)
{
this.Logger.WriteLine(
LogLevel.Error,
string.Format(
"Error while processing file: {0} to language {1} with error: {2}",
model.TargetPath,
language,
ex.Message));
throw;
}
}
}
}
catch (Exception ex)
{
this.Logger.WriteException(ex);
Console.ReadLine();
return(false);
}
this.Logger.WriteLine(LogLevel.Msg, string.Format("Documents translated successfully: {0}.", documentcount));
return(true);
}
private CommonLanguageContextProvider SetDefaultLanguage(string value)
{
DefaultLanguage = AvailableLanguages.Contains(value) ? value : null;
return(this);
}
private string LookForHttpSessionContext()
{
var sessionLanguageContext = HttpContext.Current.Session[SessionContextKey] as string;
return(AvailableLanguages.Contains(sessionLanguageContext) ? sessionLanguageContext : null);
}
private void SetupMenu()
{
var languages = GetAvailableLanguages();
AvailableLanguages.AddRange(languages);
}
public List <string> GetLanguages()
{
return(AvailableLanguages.Select(l => l.Name).ToList());
}