/// <summary>
/// creates new importer, sets importer settings
/// </summary>
/// <param name="tm">TM to import to</param>
/// <param name="settings">import settings</param>
public Importer(FileBasedTranslationMemory tm, DataImportSettings settings)
{
_settings = settings;
_importer = new TranslationMemoryImporter(tm.LanguageDirection);
ChangeSettings();
}
public async Task <ImportStatistics> Import(string tmxPath)
{
var importer = new TranslationMemoryImporter(_tm.LanguageDirection);
importer.BatchImported += importer_BatchImported;
GetImportSettings(importer.ImportSettings);
var t = new Task(() => importer.Import(tmxPath));
#pragma warning disable 4014
t.ContinueWith(task =>
#pragma warning restore 4014
{
if (task.IsFaulted)
{
throw new Exception(ProcessorUtil.ExceptionToMsg(task.Exception));
}
}, TaskScheduler.FromCurrentSynchronizationContext());
t.Start();
await t;
Results = importer.Statistics;
return(Results);
}
/// <summary>
/// This function performs the actual TMX import into the appropriate master TM.
/// </summary>
/// <param name="tmxPath">Path to *.tmx file.</param>
public void Import(string tmxPath)
{
#region "CreatePath"
// Create the path in which the master TMs should be
// stored (if the path does not exist yet).
string masterPath = @"c:\MasterTMs\";
if (!System.IO.Directory.Exists(masterPath))
{
System.IO.Directory.CreateDirectory(masterPath);
}
#endregion
#region "GetLanguageDirection"
// Retrieve the language direction of the current TM
// by reading the appropriate lang values from the first
// tu element.
string srcLang = string.Empty;
string trgLang = string.Empty;
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(tmxPath);
try
{
XmlNode tu = xmlDoc.SelectNodes("tmx/body/tu")[0];
srcLang = tu.SelectNodes("tuv")[0].Attributes[0].Value;
trgLang = tu.SelectNodes("tuv")[1].Attributes[0].Value;
}
catch
{
// TU count is zero, i.e. no TM content to import
Console.WriteLine(tmxPath + " is empty, no content to import.");
}
#endregion
#region "CheckMasterTmExists"
// Check whether a master TM with the language direction found in the
// current TMX file already exists. If not, then create the TM.
string translationMemoryPath = string.Format("{0}MasterTM_{1}_{2}.sdltm", masterPath, srcLang, trgLang);
if (!System.IO.File.Exists(translationMemoryPath))
{
TMCreator create = new TMCreator();
create.CreateMasterTm(srcLang, trgLang, masterPath);
}
#endregion
#region "DoImport"
// Open the appropriate master TM and do the import.
FileBasedTranslationMemory tm = new FileBasedTranslationMemory(translationMemoryPath);
TranslationMemoryImporter importer = new TranslationMemoryImporter(tm.LanguageDirection);
this.GetImportSettings(importer.ImportSettings);
importer.Import(tmxPath);
#endregion
}
/// <summary>
/// Imports a single tmx file into specified file based TM
/// </summary>
/// <param name="tmPath"></param>
/// <param name="tmxFile"></param>
public void ImportSDLXLIFFFile(string tmPath, string sdlxliffFile)
{
FileBasedTranslationMemory tm = new FileBasedTranslationMemory(tmPath);
TranslationMemoryImporter importer = new TranslationMemoryImporter(tm.LanguageDirection);
//Set up the Poco Filter Manager with default list of filters
importer.FileTypeManager = new PocoFilterManager(true);
importer.BatchImported += new EventHandler <BatchImportedEventArgs>(importer_BatchImported);
importer.ChunkSize = 1; //sets the import size after which the BatchImported event is launched
AdaptImportSettigns(importer.ImportSettings);
importer.Import(sdlxliffFile);
}
private void ImportInTmWithoutFields(string tmPath)
{
var tm = new FileBasedTranslationMemory(tmPath);
var tmImporter = new TranslationMemoryImporter(tm.LanguageDirection);
tmImporter.BatchImported += TmImporter_BatchImported;
tmImporter.ChunkSize = 20;
var importSettings = tmImporter.ImportSettings;
importSettings.ExistingFieldsUpdateMode = ImportSettings.FieldUpdateMode.Merge;
ImportFiles(tmImporter);
}
public async Task <ImportStatistics> Import(string tmxPath)
{
var importer = new TranslationMemoryImporter(_tm.LanguageDirection);
GetImportSettings(importer.ImportSettings);
var t = new Task(() => importer.Import(tmxPath));
t.Start();
await t;
return(importer.Statistics);
}
/// <summary>
/// Imports a single tmx file into specified file based TM
/// </summary>
/// <param name="tmPath"></param>
/// <param name="tmxFile"></param>
public void ImportTMXFile(string tmPath, string tmxFile)
{
FileBasedTranslationMemory tm = new FileBasedTranslationMemory(tmPath);
TranslationMemoryImporter importer = new TranslationMemoryImporter(tm.LanguageDirection);
importer.BatchImported += new EventHandler <BatchImportedEventArgs>(importer_BatchImported);
importer.ChunkSize = 1; //sets the import size after which the BatchImported event is launched
AdaptImportSettigns(importer.ImportSettings);
importer.Import(tmxFile);
}
private void ImportSdlXliffIntoTm(string sdlXliffFullPath)
{
var tmImporter = new TranslationMemoryImporter(_fileBasedTM.LanguageDirection);
var importSettings = new ImportSettings()
{
IsDocumentImport = false,
CheckMatchingSublanguages = false,
IncrementUsageCount = false,
NewFields = ImportSettings.NewFieldsOption.Ignore,
PlainText = false,
ExistingTUsUpdateMode = ImportSettings.TUUpdateMode.AddNew
};
tmImporter.ImportSettings = importSettings;
tmImporter.Import(sdlXliffFullPath);
}
private void ImportSdlXliffIntoTm(string sdlXliffFolderPath, PackageModel package)
{
try
{
var targetLanguages = package.LanguagePairs.Select(f => f.TargetLanguage.Name).ToList();
var importSettings = new ImportSettings
{
IsDocumentImport = false,
CheckMatchingSublanguages = false,
IncrementUsageCount = true,
NewFields = ImportSettings.NewFieldsOption.AddToSetup,
PlainText = false,
ExistingTUsUpdateMode = ImportSettings.TUUpdateMode.AddNew
};
foreach (var languageCode in targetLanguages)
{
var folderPath = Path.Combine(sdlXliffFolderPath, languageCode);
var xliffFiles = Directory.GetFiles(folderPath);
foreach (var xliffFile in xliffFiles)
{
var fileName = Path.GetFileNameWithoutExtension(xliffFile);
// for tms list or MT list the name of star transit tm corresponds to Studio tm
// for general tm the name of the tm is the name of the package. In constructor we set 0 as penalty for general tms
var correspondingTm =
StudioTranslationMemories.Keys.FirstOrDefault(t => t.Name.Equals(fileName)) ??
StudioTranslationMemories.FirstOrDefault(s => s.Value.Equals(0)).Key;
if (correspondingTm is null)
{
return;
}
var tmImporter = new TranslationMemoryImporter(correspondingTm.LanguageDirection)
{
ImportSettings = importSettings
};
tmImporter.Import(xliffFile);
}
}
}
catch (Exception ex)
{
_logger.Error(ex);
}
}
private void ImportSdlXliffsIntoTm(string sdlXliffFolderPath, CultureInfo targetLanguage)
{
try
{
ConfirmationLevel[] levels = { ConfirmationLevel.ApprovedTranslation, ConfirmationLevel.Translated, ConfirmationLevel.ApprovedSignOff };
var importSettings = new ImportSettings
{
IsDocumentImport = true,
CheckMatchingSublanguages = false,
IncrementUsageCount = true,
NewFields = ImportSettings.NewFieldsOption.AddToSetup,
PlainText = false,
ExistingTUsUpdateMode = ImportSettings.TUUpdateMode.AddNew,
ConfirmationLevels = levels
};
var tmImporter = new TranslationMemoryImporter(_translationMemory.LanguageDirection)
{
ImportSettings = importSettings
};
var folderPath = Path.Combine(sdlXliffFolderPath, targetLanguage.Name);
if (!Directory.Exists(folderPath))
{
return;
}
var xliffFiles = Directory.GetFiles(folderPath);
var tmFileProgress = new TmFilesProgress
{
TotalFilesNumber = xliffFiles.Length,
TargetLanguage = targetLanguage
};
foreach (var xliffFile in xliffFiles)
{
tmFileProgress.ProcessingFileNumber++;
tmImporter.Import(xliffFile);
_eventAggregator?.PublishEvent(tmFileProgress);
}
}
catch (Exception ex)
{
_logger.Error(ex);
}
}
protected override void ExecuteImpl()
{
FileBasedTranslationMemory tm = _outputTranslationMemory.TranslationMemory;
TranslationMemoryImporter importer = new TranslationMemoryImporter(tm.LanguageDirection);
importer.BatchImported += (sender, e) =>
{
StatusMessage = String.Format("TUs: {0}/{1}", e.Statistics.TotalRead, _tmxFile.GetDetectInfo().TuCount);
ReportProgress((int)((100.0 * e.Statistics.RawTUs) / _tmxFile.GetDetectInfo().TuCount));
};
importer.ImportSettings = new ImportSettings
{
CheckMatchingSublanguages = false,
ExistingFieldsUpdateMode = ImportSettings.FieldUpdateMode.Merge,
NewFields = ImportSettings.NewFieldsOption.AddToSetup,
OverwriteExistingTUs = false,
TUProcessingMode = ImportSettings.ImportTUProcessingMode.ProcessCleanedTUOnly
};
importer.Import(_tmxFile.FilePath);
}
protected override void ExecuteImpl()
{
FileBasedTranslationMemory tm = _outputTranslationMemory.TranslationMemory;
TranslationMemoryImporter importer = new TranslationMemoryImporter(tm.LanguageDirection);
importer.BatchImported += (sender, e) =>
{
StatusMessage = String.Format("TUs: {0}/{1}", e.Statistics.TotalRead, _tmxFile.GetDetectInfo().TuCount);
ReportProgress((int)((100.0 * e.Statistics.RawTUs) / _tmxFile.GetDetectInfo().TuCount));
};
importer.ImportSettings = new ImportSettings
{
CheckMatchingSublanguages = false,
ExistingFieldsUpdateMode = ImportSettings.FieldUpdateMode.Merge,
NewFields = ImportSettings.NewFieldsOption.AddToSetup,
OverwriteExistingTUs = false,
TUProcessingMode = ImportSettings.ImportTUProcessingMode.ProcessCleanedTUOnly
};
importer.Import(_tmxFile.FilePath);
}
private void ImportSdlXliffIntoTm(string sdlXliffFullPath)
{
try
{
var tmImporter = new TranslationMemoryImporter(_fileBasedTM.LanguageDirection);
var importSettings = new ImportSettings()
{
IsDocumentImport = false,
CheckMatchingSublanguages = false,
IncrementUsageCount = false,
NewFields = ImportSettings.NewFieldsOption.Ignore,
PlainText = false,
ExistingTUsUpdateMode = ImportSettings.TUUpdateMode.AddNew
};
tmImporter.ImportSettings = importSettings;
tmImporter.Import(sdlXliffFullPath);
}
catch (Exception ex)
{
Log.Logger.Error($"ImportSdlXliffIntoTm method: {ex.Message}\n {ex.StackTrace}");
}
}
public void ImportTMXFile(string tmPath, string importFilePath)
{
#region "CreateImporter"
FileBasedTranslationMemory tm = new FileBasedTranslationMemory(tmPath);
TranslationMemoryImporter importer = new TranslationMemoryImporter(tm.LanguageDirection);
#endregion
#region "chunk"
importer.ChunkSize = 20;
#endregion
#region "GetSettings"
GetImportSettings(importer.ImportSettings);
#endregion
#region "FireEvent"
importer.BatchImported += new EventHandler <BatchImportedEventArgs>(Importer_BatchImported);
#endregion
#region "execute"
importer.Import(importFilePath);
#endregion
}
private void ImportFiles(TranslationMemoryImporter tmImporter)
{
tmImporter.Import(@"");
tmImporter.Import(@"");
}
