/// <summary> /// Check if a file is concerned by a project /// </summary> /// <param name="projFullPathFileName">Source project full-path filename</param> /// <param name="glossaryFullPathFileName">Target glossary full-path file name</param> /// <param name="engineFolderName">Remote Translator/Translation engine folder name for Glossary</param> /// <param name="srcLang">Mapping source language</param> /// <param name="tgtLang">Mapping target language</param> /// <returns>true for concerned</returns> public static bool IsFileConcernedByProject(string projFullPathFileName, string glossaryFullPathFileName, string engineFolderName = "Excite", SupportedSourceLanguage srcLang = SupportedSourceLanguage.Japanese, SupportedTargetLanguage tgtLang = SupportedTargetLanguage.ChineseTraditional) { if (string.IsNullOrWhiteSpace(projFullPathFileName) || string.IsNullOrWhiteSpace(glossaryFullPathFileName) || srcLang == SupportedSourceLanguage.AutoDetect) { return(false); } if (glossaryFullPathFileName == projFullPathFileName) { return(true); } var baseProjPath = Path.GetDirectoryName(projFullPathFileName); if (glossaryFullPathFileName.StartsWith(baseProjPath) == false) { return(false); } var fileName = Path.GetFileName(glossaryFullPathFileName); var glossaryPath = Path.Combine(baseProjPath, MappingMonitor.GlossaryFolderName); if (Path.Combine(glossaryPath, fileName) == glossaryFullPathFileName) { return(true); } var enginePath = Path.Combine(glossaryPath, engineFolderName); if (Path.Combine(enginePath, fileName) == glossaryFullPathFileName) { return(true); } var src2tgt = $"{srcLang.ToString()}2{tgtLang.ToString()}"; var langPath = Path.Combine(enginePath, src2tgt); if (Path.Combine(langPath, fileName) == glossaryFullPathFileName) { return(true); } return(false); }
public static string ToL10nString(this SupportedSourceLanguage srcLang) { switch (srcLang) { case SupportedSourceLanguage.ChineseSimplified: return(Languages.SupportedLanguages.Str0ChineseSimplified); case SupportedSourceLanguage.ChineseTraditional: return(Languages.SupportedLanguages.Str0ChineseTraditional); case SupportedSourceLanguage.English: return(Languages.SupportedLanguages.Str0English); case SupportedSourceLanguage.Japanese: return(Languages.SupportedLanguages.Str0Japanese); } return(""); }
// ISO 639 (primary language code, two-letter) + ISO 3166-1 (sub language code, region) <= old // RFC 4646 http://www.ietf.org/rfc/rfc4646.txt <= old // ISO 639 (primary language code, two-letter) + ISO 15924 (sub language code, region) http://unicode.org/iso15924/iso15924-codes.html /// <summary> /// Convert Minax language enum to ISO code /// </summary> /// <param name="srcLang">Supported source language</param> /// <returns>ISO code string</returns> public static string ToIsoCode(this SupportedSourceLanguage srcLang) { switch (srcLang) { case SupportedSourceLanguage.English: return("en"); case SupportedSourceLanguage.Japanese: return("ja"); case SupportedSourceLanguage.ChineseSimplified: return("zh-Hans"); case SupportedSourceLanguage.ChineseTraditional: return("zh-Hant"); default: return(""); } }
/// <summary> /// Get glossary file name list under Glossary full-path folder /// </summary> /// <param name="glossaryPath">Full-path glossary sub-folder</param> /// <param name="engineFolderName">Translator engine sub-folder name</param> /// <param name="srcLang">Supported source language</param> /// <param name="tgtLang">Supported target language</param> /// <returns>Full-path file name list of found glossary files</returns> public static IList <string> GetGlossaryFiles(string glossaryPath, string engineFolderName = "Excite", SupportedSourceLanguage srcLang = SupportedSourceLanguage.Japanese, SupportedTargetLanguage tgtLang = SupportedTargetLanguage.ChineseTraditional) { if (Directory.Exists(glossaryPath) == false || string.IsNullOrWhiteSpace(engineFolderName) || srcLang == SupportedSourceLanguage.AutoDetect) { return(null); } // the files in <glossaryPath>/<engineFolderName>/<langFolder>/*.* are specific srcLang to tgtLang glossary files // the files in <glossaryPath>/<engineFolderName>/*.* are language-ignored, so put them be careful! // the files in <glossaryPath>/*.* are engine-ignored, so put them be careful!!! // current supproted MappingEntry file extensions(.csv, .tsv, etc.) var supExtensions = new List <string> { MappingEntryCsv.FileExtension, MappingEntryTsv.FileExtension, }; var listAllEngine = new List <string>(); foreach (var fileName in Directory.EnumerateFiles(glossaryPath, "*.*", SearchOption.TopDirectoryOnly)) { if (supExtensions.Contains(Path.GetExtension(fileName))) { listAllEngine.Add(fileName); } } var enginePath = Path.Combine(glossaryPath, engineFolderName); if (Directory.Exists(enginePath) == false) { return(Minax.Utils.SortWithNumericOrdering(listAllEngine).ToList()); } // get files in enginePath var listAllLang = new List <string>(); foreach (var fileName in Directory.EnumerateFiles(enginePath, "*.*", SearchOption.TopDirectoryOnly)) { if (supExtensions.Contains(Path.GetExtension(fileName))) { listAllLang.Add(fileName); } } // concate listAllLang + listAllEngine back to listAllLang listAllLang = Minax.Utils.SortWithNumericOrdering(listAllLang).Concat( Minax.Utils.SortWithNumericOrdering(listAllEngine)).ToList(); var langFolder = $"{srcLang.ToString()}2{tgtLang.ToString()}"; // like "Japanese2ChineseTraditional" var langPath = Path.Combine(enginePath, langFolder); if (Directory.Exists(langPath) == false) { return(listAllLang); } // get files in langPath var list = new List <string>(); foreach (var fileName in Directory.EnumerateFiles(langPath, "*.*", SearchOption.TopDirectoryOnly)) { if (supExtensions.Contains(Path.GetExtension(fileName))) { list.Add(fileName); } } // the returned list is sorted by the sequence: // <glossaryPath>/<engineFolder>/<langFolder>/*.* -> <glossaryPath>/<engineFolder>/*.* -> <glossaryPath>/*.*, // the later is high priority for overwriting previous terms!! return(Minax.Utils.SortWithNumericOrdering(list).Concat(listAllLang).ToList()); }
/// <summary> /// Open and start monitoring glossary files /// </summary> /// <param name="projFullPathFileName">Project full-path file name</param> /// <param name="projEntries">Project Mapping entries list</param> /// <param name="monitor">MappingMonitor for this project's base path</param> /// <param name="engineFolderName">Corresponding translator/translation engine folder name</param> /// <param name="srcLang">Supported source language</param> /// <param name="tgtLang">Supported target language</param> /// <returns>true for success</returns> public static async Task <bool> OpenAndMonitorGlossaryFiles(string projFullPathFileName, IList <MappingEntry> projEntries, MappingMonitor monitor, string engineFolderName = "Excite", SupportedSourceLanguage srcLang = SupportedSourceLanguage.Japanese, SupportedTargetLanguage tgtLang = SupportedTargetLanguage.ChineseTraditional) { if (string.IsNullOrWhiteSpace(projFullPathFileName) || monitor == null) { return(false); } var baseProjectPath = Path.GetDirectoryName(projFullPathFileName); if (string.IsNullOrWhiteSpace(baseProjectPath) || Directory.Exists(baseProjectPath) == false || monitor.BaseProjectPath.StartsWith(baseProjectPath) == false) { return(false); } var glossaryPath = monitor.GlossaryPath; if (Directory.Exists(glossaryPath) == false || string.IsNullOrWhiteSpace(engineFolderName) || srcLang == SupportedSourceLanguage.AutoDetect) { return(false); } monitor.Stop(); foreach (var fn in monitor.MonitoringFileList.ToList()) { if (fn == projFullPathFileName) { continue; } monitor.RemoveMonitoring(fn); } await Task.Delay(50); // collect mapping files var listAllEngine = Directory.GetFiles(glossaryPath, "*.*", SearchOption.TopDirectoryOnly).NumericSort(); var enginePath = Path.Combine(glossaryPath, engineFolderName); var langPath = Path.Combine(enginePath, $"{srcLang.ToString()}2{tgtLang.ToString()}"); // like "Excite/Japanese2ChineseTraditional" IEnumerable <string> listAllLang = null, listLang = null; if (Directory.Exists(enginePath)) { listAllLang = Directory.GetFiles(enginePath, "*.*", SearchOption.TopDirectoryOnly).NumericSort(); } if (Directory.Exists(langPath)) { listLang = Directory.GetFiles(langPath, "*.*", SearchOption.TopDirectoryOnly).NumericSort(); } if (listLang == null) { listLang = new string[] { } } ; // add file names to list by descended priority var listFiles = new List <string>(listLang); if (listAllLang != null) { listFiles.AddRange(listAllLang); } if (listAllEngine != null) { listFiles.AddRange(listAllEngine); } // the listFiles is sorted by the sequence: // <glossaryPath>/<engineFolder>/<langFolder>/*.* => <glossaryPath>/<engineFolder>/*.* => <glossaryPath>/*.*, // the later is high priority for overwriting previous terms!! // FileHelpers not support SmartDetect in .Net Standard 2.0 var engine = new FileHelpers.DelimitedFileEngine <MappingEntry>(System.Text.Encoding.UTF8); foreach (var field in engine.Options.Fields) { field.IsOptional = true; } engine.Options.Fields[0].IsOptional = false; // OriginalText // Switch error mode off engine.ErrorManager.ErrorMode = FileHelpers.ErrorMode.IgnoreAndContinue; List <(string, List <MappingEntry>)> glossaries = new List <(string, List <MappingEntry>)>(); foreach (var fileName in listFiles) { try { var fileExt = Path.GetExtension(fileName); switch (fileExt) { case MappingEntryCsv.FileExtension: engine.Options.Delimiter = ","; break; case MappingEntryTsv.FileExtension: engine.Options.Delimiter = "\t"; break; } var list = engine.ReadFileAsList(fileName); if (list == null) { // try another delmiter engine.Options.Delimiter = engine.Options.Delimiter == "," ? "\t" : ","; list = engine.ReadFileAsList(fileName); } if (list == null || list.Count <= 0) { continue; } if (list != null) { // ignore first line for Header fields var first = list[0]; if (first.OriginalText == nameof(MappingEntry.OriginalText) && first.MappingText == nameof(MappingEntry.MappingText)) { list.RemoveAt(0); } glossaries.Add((fileName, list)); continue; } // TODO: try to parse .xlxs file... } catch { continue; } } // prepared, then clear existed project.conf mapping var projMappingColl = monitor.GetMappingCollection(projFullPathFileName); monitor.RemoveMonitoring(projFullPathFileName); foreach (var glossary in glossaries) { monitor.AddMonitoring(glossary.Item1, glossary.Item2); } // finally, add back project.conf's mapping for highest priority if (projMappingColl == null) { monitor.AddMonitoring(projFullPathFileName, projEntries); } else { monitor.AddMonitoring(projFullPathFileName, projMappingColl); } monitor.Start(); return(true); }