public void AddResource(string tmPath)
{
#region "open"
FileBasedTranslationMemory tm = new FileBasedTranslationMemory(tmPath);
#endregion
#region "default"
DefaultLanguageResourceProvider defaultBundle = new DefaultLanguageResourceProvider();
#endregion
#region "newBundle"
LanguageResourceBundle newBundle = defaultBundle.GetDefaultLanguageResources(CultureInfo.GetCultureInfo("en-US"));
#endregion
#region "abbreviations"
newBundle.Abbreviations = new Wordlist();
newBundle.Abbreviations.Add("hr.");
newBundle.Abbreviations.Add("cont.");
#endregion
#region "variables"
newBundle.Variables = new Wordlist();
newBundle.Variables.Add("Mac OSX");
newBundle.Variables.Add("Microsoft Windows 7");
newBundle.Variables.Add("Suse Linux");
tm.LanguageResourceBundles.Add(newBundle);
tm.Save();
#endregion
}
private void ReadFromExcel(ExcelPackage package, List <LanguageResourceBundle> newLanguageResourceBundles)
{
foreach (var workSheet in package.Workbook.Worksheets)
{
var column01 = workSheet.Cells[1, 1].Value;
var column02 = workSheet.Cells[1, 2].Value;
var column03 = workSheet.Cells[1, 3].Value;
var column04 = workSheet.Cells[1, 4].Value;
if (!AreColumnsValid(column01, column02, column03, column04))
{
throw new Exception(PluginResources.Excel_spreadsheet_not_in_correct_format);
}
var abbreviations = new Wordlist();
var ordinalFollowers = new Wordlist();
var variables = new Wordlist();
var segmentationRules = new SegmentationRules();
ReadFromExcel(workSheet, abbreviations, ordinalFollowers, variables, segmentationRules);
var newLanguageResourceBundle =
new LanguageResourceBundle(CultureInfoExtensions.GetCultureInfo(workSheet.Name))
{
Abbreviations = abbreviations,
OrdinalFollowers = ordinalFollowers,
Variables = variables,
SegmentationRules = segmentationRules
};
newLanguageResourceBundles.Add(newLanguageResourceBundle);
}
ExcludeWhatIsNotNeeded(newLanguageResourceBundles);
AddNewBundles(newLanguageResourceBundles);
}
public List <LanguageResourceBundle> GetLanguageResourceBundlesFromFile(string resourceTemplatePath, out string message, out List <int> unIDedLanguages)
{
if (ValidateFile(resourceTemplatePath, out message, out unIDedLanguages, out var lrt))
{
return(null);
}
var langResBundlesList = new List <LanguageResourceBundle>();
foreach (XmlNode res in lrt)
{
var cultureName = res?.Attributes?["CultureName"]?.Value;
if (string.IsNullOrWhiteSpace(cultureName))
{
continue;
}
var lr = langResBundlesList.FirstOrDefault(lrb => lrb.Language.Name == cultureName);
if (lr == null)
{
var culture = CultureInfoExtensions.GetCultureInfo(cultureName);
lr = new LanguageResourceBundle(culture);
langResBundlesList.Add(lr);
}
AddLanguageResourceToBundle(lr, res);
}
return(langResBundlesList);
}
public void CreateTemplate(TranslationProviderServer tmServer)
{
#region "TemplateProps"
ServerBasedLanguageResourcesTemplate template = new ServerBasedLanguageResourcesTemplate(tmServer);
template.Name = "Sample Language Resources Template";
template.Description = "Language Resources template created through API";
#endregion
#region "variables"
LanguageResourceBundle variables = new LanguageResourceBundle(CultureInfo.GetCultureInfo("en-US"));
variables.Variables.Add("SDL Trados Studio 2009");
variables.Variables.Add("SDL MultiTerm 2009");
#endregion
#region "abbreviations"
LanguageResourceBundle abbreviations = new LanguageResourceBundle(CultureInfo.GetCultureInfo("en-US"));
abbreviations.Abbreviations.Add("hr.");
abbreviations.Abbreviations.Add("cont.");
#endregion
#region "AddResources"
template.LanguageResourceBundles.Add(variables);
template.LanguageResourceBundles.Add(abbreviations);
#endregion
#region "save"
template.Save();
MessageBox.Show("Unsaved changes? " + template.IsDirty.ToString());
#endregion
#region "delete"
template.Delete();
#endregion
}
private void AddSegmentationRulesToBundle(LanguageResourceBundle newBundle, LanguageResourceBundle correspondingBundleInTemplate)
{
if (newBundle.SegmentationRules != null)
{
if (correspondingBundleInTemplate.SegmentationRules != null)
{
foreach (var newRule in newBundle.SegmentationRules.Rules)
{
if (!correspondingBundleInTemplate.SegmentationRules.Rules.Any(oldRule =>
string.Equals(newRule.Description.Text, oldRule.Description.Text,
StringComparison.OrdinalIgnoreCase)))
{
correspondingBundleInTemplate.SegmentationRules.AddRule(newRule);
}
}
}
else
{
correspondingBundleInTemplate.SegmentationRules = newBundle.SegmentationRules;
}
}
if (correspondingBundleInTemplate.SegmentationRules.Count == 0)
{
correspondingBundleInTemplate.SegmentationRules = null;
}
}
private static void AddSegmentationRulesToBundle(LanguageResourceBundle newBundle, LanguageResourceBundle correspondingBundleInTemplate)
{
if (newBundle.SegmentationRules == null)
{
return;
}
if (correspondingBundleInTemplate.SegmentationRules != null)
{
var newSegmentationRules = new SegmentationRules();
foreach (var newRule in newBundle.SegmentationRules.Rules)
{
if (correspondingBundleInTemplate.SegmentationRules.Rules.All(oldRule =>
!string.Equals(newRule.Description.Text, oldRule.Description.Text,
StringComparison.OrdinalIgnoreCase)))
{
newSegmentationRules.AddRule(newRule);
}
}
correspondingBundleInTemplate.SegmentationRules.Rules.AddRange(newSegmentationRules.Rules);
}
else
{
correspondingBundleInTemplate.SegmentationRules = new SegmentationRules(newBundle.SegmentationRules);
}
}
private void AddMeasurementUnits(LanguageResourceBundle newBundle, LanguageResourceBundle correspondingBundleInTemplate)
{
if (newBundle.MeasurementUnits != null)
{
if (correspondingBundleInTemplate.MeasurementUnits != null)
{
foreach (var unit in newBundle.MeasurementUnits)
{
if (!correspondingBundleInTemplate.MeasurementUnits.ContainsKey(unit.Key))
{
correspondingBundleInTemplate.MeasurementUnits.Add(unit.Key, unit.Value);
}
}
}
else
{
correspondingBundleInTemplate.MeasurementUnits = newBundle.MeasurementUnits;
}
}
if (correspondingBundleInTemplate.MeasurementUnits.Count == 0)
{
correspondingBundleInTemplate.MeasurementUnits = null;
}
}
//public string GetValueFromCell();
private LanguageResourceBundle GetFromExcel(ExcelWorksheet workSheet, CultureInfo cultureInfo)
{
var cells = workSheet.Cells;
var languageResourceBundle =
new LanguageResourceBundle(cultureInfo)
{
Abbreviations = new Wordlist(),
OrdinalFollowers = new Wordlist(),
Variables = new Wordlist(),
SegmentationRules = new SegmentationRules(),
LongDateFormats = new List <string>(),
ShortDateFormats = new List <string>(),
LongTimeFormats = new List <string>(),
ShortTimeFormats = new List <string>(),
NumbersSeparators = new List <SeparatorCombination>(),
MeasurementUnits = new Dictionary <string, CustomUnitDefinition>(),
CurrencyFormats = new List <CurrencyFormat>()
};
for (var i = 2; i <= workSheet.Dimension.End.Row; i++)
{
var abbreviation = cells[i, 1]?.Value?.ToString();
AddToWordlist(abbreviation, languageResourceBundle.Abbreviations);
var ordinalFollower = cells[i, 2]?.Value?.ToString();
AddToWordlist(ordinalFollower, languageResourceBundle.OrdinalFollowers);
var variable = cells[i, 3]?.Value?.ToString();
AddToWordlist(variable, languageResourceBundle.Variables);
var serializedData = cells[i, 4]?.Value?.ToString();
AddSegmentationRule(serializedData, languageResourceBundle.SegmentationRules.Rules);
var longDate = cells[i, 5]?.Value?.ToString();
AddDateFormat(longDate, languageResourceBundle.LongDateFormats);
var shortDate = cells[i, 6]?.Value?.ToString();
AddDateFormat(shortDate, languageResourceBundle.ShortDateFormats);
var longTime = cells[i, 7]?.Value?.ToString();
AddDateFormat(longTime, languageResourceBundle.LongTimeFormats);
var shortTime = cells[i, 8]?.Value?.ToString();
AddDateFormat(shortTime, languageResourceBundle.ShortTimeFormats);
serializedData = cells[i, 9]?.Value?.ToString();
AddNumberSeparator(serializedData, languageResourceBundle.NumbersSeparators);
var unit = cells[i, 10]?.Value?.ToString();
AddMeasurementUnits(unit, languageResourceBundle.MeasurementUnits);
serializedData = cells[i, 11]?.Value?.ToString();
AddCurrencies(serializedData, languageResourceBundle.CurrencyFormats);
}
return(languageResourceBundle);
}
private void AddWordlists(LanguageResourceBundle correspondingBundleInTemplate, LanguageResourceBundle newBundle)
{
correspondingBundleInTemplate.Abbreviations =
AddItemsToWordlist(newBundle.Abbreviations, correspondingBundleInTemplate.Abbreviations);
correspondingBundleInTemplate.OrdinalFollowers =
AddItemsToWordlist(newBundle.OrdinalFollowers, correspondingBundleInTemplate.OrdinalFollowers);
correspondingBundleInTemplate.Variables =
AddItemsToWordlist(newBundle.Variables, correspondingBundleInTemplate.Variables);
}
private void AddLanguageResourceToBundle(LanguageResourceBundle langResBundle, XmlNode resource)
{
if (resource?.Attributes?["Type"].Value == "Variables")
{
var vars = Encoding.UTF8.GetString(Convert.FromBase64String(resource.InnerText));
langResBundle.Variables = new Wordlist();
foreach (Match s in Regex.Matches(vars, @"([^\s]+)"))
{
langResBundle.Variables.Add(s.ToString());
}
return;
}
if (resource?.Attributes?["Type"].Value == "Abbreviations")
{
var abbrevs = Encoding.UTF8.GetString(Convert.FromBase64String(resource.InnerText));
langResBundle.Abbreviations = new Wordlist();
foreach (Match s in Regex.Matches(abbrevs, @"([^\s]+)"))
{
langResBundle.Abbreviations.Add(s.ToString());
}
return;
}
if (resource?.Attributes?["Type"].Value == "OrdinalFollowers")
{
var ordFollowers = Encoding.UTF8.GetString(Convert.FromBase64String(resource.InnerText));
langResBundle.OrdinalFollowers = new Wordlist();
foreach (Match s in Regex.Matches(ordFollowers, @"([^\s]+)"))
{
langResBundle.OrdinalFollowers.Add(s.ToString());
}
return;
}
if (resource?.Attributes?["Type"].Value == "SegmentationRules")
{
var segRules = Convert.FromBase64String(resource.InnerText);
var stream = new MemoryStream(segRules);
var segmentRules = SegmentationRules.Load(stream,
CultureInfo.GetCultureInfo(langResBundle.Language.LCID), null);
langResBundle.SegmentationRules = segmentRules;
}
}
private LanguageResourceBundle CreateDefaultBundle(CultureInfo cultureInfo)
{
//we can either create a bundle from scratch or use DefaultLanguageResourceProvider which allows us to access the default list
DefaultLanguageResourceProvider defaultProvider = new DefaultLanguageResourceProvider();
//as working with file based TM, we will create a bundle for source language
LanguageResourceBundle bundle = defaultProvider.GetDefaultLanguageResources(cultureInfo);
bundle.Abbreviations = new Sdl.LanguagePlatform.Core.Wordlist();
bundle.Abbreviations.Add("SDL");
return(bundle);
}
public void AddLanguageResourceToBundle(LanguageResourceBundle langResBundle)
{
var segRules = Encoding.UTF8.GetString(Convert.FromBase64String(_resource.InnerText));
var xmlSerializer = new XmlSerializer(typeof(SegmentationRules));
var stringReader = new StringReader(segRules);
var segmentRules = (SegmentationRules)xmlSerializer.Deserialize(stringReader);
langResBundle.SegmentationRules = segmentRules;
}
private void InitializeBundle(LanguageResourceBundle correspondingBundleInTemplate)
{
foreach (var propertyInfo in typeof(LanguageResourceBundle).GetProperties())
{
if (propertyInfo.CanWrite)
{
if (propertyInfo.GetValue(correspondingBundleInTemplate) == null)
{
propertyInfo.SetValue(correspondingBundleInTemplate, Activator.CreateInstance(propertyInfo.PropertyType));
}
}
}
}
/// <summary>
/// Adapt language resource bundle, add a new abbreviations
/// </summary>
/// <param name="languageResourceBundleCollection"></param>
private void AdaptLanguageResourceBundles(LanguageResourceBundleCollection languageResourceBundleCollection)
{
//we can either create a bundle from scratch or use DefaultLanguageResourceProvider which allows us to access the default list
DefaultLanguageResourceProvider defaultProvider = new DefaultLanguageResourceProvider();
//as working with file based TM, we will create a bundle for source language
LanguageResourceBundle bundle = defaultProvider.GetDefaultLanguageResources(CultureInfo.GetCultureInfo("en-US"));
bundle.Abbreviations.Add("SDK");
bundle.Abbreviations.Add("SDL");
languageResourceBundleCollection.Add(bundle);
WriteResult("A custom abbreviations added\r\n");
}
public List <LanguageResourceBundle> GetLanguageResourceBundlesFromFile(string resourceTemplatePath, out string message, out List <int> unIDedLanguages)
{
if (ValidateFile(resourceTemplatePath, out message, out unIDedLanguages, out var lrt))
{
return(null);
}
var langResBundlesList = new List <LanguageResourceBundle>();
foreach (XmlNode res in lrt)
{
var successful = int.TryParse(res?.Attributes?["Lcid"]?.Value, out var lcid);
if (!successful)
{
continue;
}
var lr = langResBundlesList.FirstOrDefault(lrb => lrb.Language.LCID == lcid);
if (lr == null)
{
CultureInfo culture;
try
{
culture = CultureInfoExtensions.GetCultureInfo(lcid);
if (CultureInfo.GetCultures(CultureTypes.AllCultures).Where(ci => ci.LCID == lcid).ToList().Count > 1)
{
throw new Exception();
}
}
catch (Exception)
{
if (!unIDedLanguages.Exists(id => id == lcid))
{
unIDedLanguages.Add(lcid);
}
continue;
}
lr = new LanguageResourceBundle(culture);
langResBundlesList.Add(lr);
}
AddLanguageResourceToBundle(lr, res);
}
return(langResBundlesList);
}
public void AddLanguageResourceToBundle(LanguageResourceBundle langResBundle)
{
var vars = Encoding.UTF8.GetString(Convert.FromBase64String(_resource.InnerText));
var langResBundleSetter = typeof(LanguageResourceBundle).GetProperty(_propertyName)?.SetMethod;
langResBundleSetter?.Invoke(langResBundle, new[] { new Wordlist() });
var langResBundleGetter = (typeof(LanguageResourceBundle).GetProperty(_propertyName)?.GetMethod.Invoke(langResBundle, null) as Wordlist);
foreach (Match s in Regex.Matches(vars, @"([^\s]+)"))
{
langResBundleGetter?.Add(s.ToString());
}
}
private void AddSimpleResources(LanguageResourceBundle correspondingBundleInTemplate, LanguageResourceBundle newBundle)
{
correspondingBundleInTemplate.LongDateFormats = GetUnionOfListsOfObjects(newBundle.LongDateFormats,
correspondingBundleInTemplate.LongDateFormats);
correspondingBundleInTemplate.ShortDateFormats = GetUnionOfListsOfObjects(newBundle.ShortDateFormats,
correspondingBundleInTemplate.ShortDateFormats);
correspondingBundleInTemplate.LongTimeFormats = GetUnionOfListsOfObjects(newBundle.LongTimeFormats,
correspondingBundleInTemplate.LongTimeFormats);
correspondingBundleInTemplate.ShortTimeFormats = GetUnionOfListsOfObjects(newBundle.ShortTimeFormats,
correspondingBundleInTemplate.ShortTimeFormats);
correspondingBundleInTemplate.NumbersSeparators = GetUnionOfListsOfObjects(newBundle.NumbersSeparators,
correspondingBundleInTemplate.NumbersSeparators);
correspondingBundleInTemplate.CurrencyFormats = GetUnionOfListsOfObjects <CurrencyFormat>(newBundle.CurrencyFormats,
correspondingBundleInTemplate.CurrencyFormats, new CurrencyComparer());
}
public void GetTemplates(TranslationProviderServer tmServer)
{
#region "LoopTemplates"
string templateList = string.Empty;
foreach (ServerBasedLanguageResourcesTemplate template in tmServer.GetLanguageResourcesTemplates(LanguageResourcesTemplateProperties.All))
#endregion
{
#region "info"
templateList += "Template name: " + template.Name + "\n";
templateList += "Description: " + template.Description + "\n";
#endregion
#region "VarCount"
LanguageResourceBundle bundle = template.LanguageResourceBundles[0];
templateList += "Number of variables in template: " + bundle.Variables.Count.ToString() + "\n\n";
#endregion
}
MessageBox.Show(templateList, "Available language resources remplates");
}
private void CopyTmLanguageResources(FileBasedTranslationMemory templateTm, FileBasedTranslationMemory tm)
{
ITranslationMemoryLanguageDirection languageDirection = tm.LanguageDirection;
// Copy any sourcelanguage resources from the template tm to the new tm
LanguageResourceBundle sourceLanguageBundle = templateTm.LanguageResourceBundles[languageDirection.SourceLanguage];
if (sourceLanguageBundle != null)
{
tm.LanguageResourceBundles.Add(sourceLanguageBundle.Clone());
}
// Copy any target language resources from the template tm to the new tm
LanguageResourceBundle targetLanguageBundle = templateTm.LanguageResourceBundles[languageDirection.TargetLanguage];
if (targetLanguageBundle != null)
{
tm.LanguageResourceBundles.Add(targetLanguageBundle.Clone());
}
}
public void TransferResourcesFromBundle(Settings settings, LanguageResourceBundle sourceBundle, LanguageResourceBundle targetBundle)
{
//TODO: this method would be very useful if there would be a class for each resource and we could just Invoke the class' method for adding each specific type
if (targetBundle == null)
{
return;
}
foreach (var propertyInfo in typeof(Settings).GetProperties())
{
if (propertyInfo.CanWrite)
{
if ((bool)propertyInfo.GetValue(settings))
{
var property = targetBundle?.GetType().GetProperties()
.Where(prop => prop.Name.Contains(propertyInfo.Name.Substring(0, 4)));
property?.ToList().ForEach(bundleProp => bundleProp?.SetValue(targetBundle, bundleProp.GetValue(sourceBundle)));
}
}
}
}
public void ApplyTmTemplate(List <TranslationMemory> translationMemories)
{
var resourceBundlesWithOptions = new List <LanguageResourceBundle>();
foreach (var resourceBundle in LanguageResourceBundles)
{
var newResourceBundle = new LanguageResourceBundle(resourceBundle.Language);
if (_settings.VariablesChecked)
{
newResourceBundle.Variables = resourceBundle.Variables;
}
if (_settings.AbbreviationsChecked)
{
newResourceBundle.Abbreviations = resourceBundle.Abbreviations;
}
if (_settings.OrdinalFollowersChecked)
{
newResourceBundle.OrdinalFollowers = resourceBundle.OrdinalFollowers;
}
if (_settings.SegmentationRulesChecked)
{
newResourceBundle.SegmentationRules = resourceBundle.SegmentationRules;
}
resourceBundlesWithOptions.Add(newResourceBundle);
}
foreach (var languageResourceBundle in resourceBundlesWithOptions)
{
foreach (var translationMemory in translationMemories)
{
translationMemory.ApplyTemplate(languageResourceBundle);
}
}
}
private static void AddItemsToWordlist(LanguageResourceBundle newLanguageResourceBundle, LanguageResourceBundle template, string property)
{
var templateBundleGetter = typeof(LanguageResourceBundle).GetProperty(property)?.GetMethod.Invoke(template, null) as Wordlist;
var templateBundleSetter = typeof(LanguageResourceBundle).GetProperty(property)?.SetMethod;
var newBundleGetter = typeof(LanguageResourceBundle).GetProperty(property)?.GetMethod.Invoke(newLanguageResourceBundle, null) as Wordlist;
if (newBundleGetter == null || !newBundleGetter.Items.Any())
{
return;
}
if (templateBundleGetter != null && templateBundleGetter.Items.Any())
{
foreach (var abbrev in newBundleGetter.Items)
{
templateBundleGetter.Add(abbrev);
}
}
else
{
templateBundleSetter?.Invoke(template, new[] { new Wordlist(newBundleGetter) });
}
}
private void AddLanguageResourceToBundle(LanguageResourceBundle langResBundle, XmlNode resource)
{
var allResourceTypes = new List <string>()
{
"Variables", "Abbreviations", "OrdinalFollowers"
};
var resourceAdder = new Resource();
foreach (var resourceType in allResourceTypes)
{
if (resourceType == resource?.Attributes?["Type"].Value)
{
resourceAdder.SetResourceType(new WordlistResource(resource, resourceType));
resourceAdder.AddLanguageResourceToBundle(langResBundle);
}
}
if (resource?.Attributes?["Type"].Value == "SegmentationRules")
{
resourceAdder.SetResourceType(new SegmentationRulesResource(resource));
resourceAdder.AddLanguageResourceToBundle(langResBundle);
}
}
private void AddNewBundles(List <LanguageResourceBundle> newLanguageResourceBundles, ILanguageResourcesContainer languageResourcesContainer)
{
foreach (var newBundle in newLanguageResourceBundles)
{
if (newBundle == null)
{
continue;
}
var correspondingBundleInTemplate = languageResourcesContainer.LanguageResourceBundles[newBundle.Language];
if (correspondingBundleInTemplate == null)
{
correspondingBundleInTemplate = new LanguageResourceBundle(newBundle.Language);
languageResourcesContainer.LanguageResourceBundles.Add(correspondingBundleInTemplate);
}
//to be able to deal with all the resources uniformly and easily, we must ensure that none are null
InitializeBundle(correspondingBundleInTemplate);
AddWordlists(correspondingBundleInTemplate, newBundle);
AddSegmentationRulesToBundle(newBundle, correspondingBundleInTemplate);
AddSimpleResources(correspondingBundleInTemplate, newBundle);
AddMeasurementUnits(newBundle, correspondingBundleInTemplate);
}
}
public void AddLanguageResourceToBundle(LanguageResourceBundle langResBundle)
{
_resourceType.AddLanguageResourceToBundle(langResBundle);
}
