protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
if (!AgreementMethods.UserAgreed())
{
CancelHelper.CancelTaskIfRequested(true);
}
if (!_settings.ShouldAnonymize ?? false)
{
return;
}
var projectController = SdlTradosStudio.Application.GetController <ProjectsController>();
var selectedPatternsFromGrid = _settings.RegexPatterns.Where(e => e.ShouldEnable).ToList();
if (projectController.CurrentProject != null)
{
ProjectBackup.CreateProjectBackup(projectController.CurrentProject.FilePath);
}
var key = _settings.EncryptionKey == "<dummy-encryption-key>" ? "" : AnonymizeData.DecryptData(_settings.EncryptionKey, Constants.Key);
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(new AnonymizerPreProcessor(selectedPatternsFromGrid, key, _settings.EncryptionState.HasFlag(State.PatternsEncrypted))));
ParseRestOfFiles(projectController, selectedPatternsFromGrid, key);
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
Contract.Assume(settings != null);
tempCounter = new SegmentWordCounter(projectFile.Name, settings, GetWordCounter(projectFile));
multiFileConverter.AddBilingualProcessor(tempCounter);
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
var projectController = SdlTradosStudio.Application.GetController <ProjectsController>();
ProjectBackup.CreateProjectBackup(projectController.CurrentProject.FilePath);
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(new AnonymizerPreProcessor()));
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
var usernameService = new UserNameService();
var resourceOriginsService = new ResourceOriginsService();
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(new AnonymizerProcessor(_settings, usernameService, resourceOriginsService)));
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
//Get instances of the translation memories included in the project.
var languageDirection = projectFile.GetLanguageDirection();
var targetLanguage = languageDirection.TargetLanguage;
var tmLanguageDirections = tms[targetLanguage].Select(x => x.GetLanguageDirection(new Sdl.LanguagePlatform.Core.LanguagePair(languageDirection.SourceLanguage.CultureInfo, languageDirection.TargetLanguage.CultureInfo)));
FileReader _task = new FileReader(tmLanguageDirections, settings, this.collectedSentencePairCount);
multiFileConverter.AddBilingualProcessor(_task);
multiFileConverter.Parse();
this.collectedSentencePairCount = _task.CollectedSentencePairCount;
var targetLang = projectFile.GetLanguageDirection().TargetLanguage;
if (this.ProjectTranslations.ContainsKey(targetLang))
{
this.ProjectTranslations[targetLang].AddRange(_task.FileTranslations);
this.ProjectNewSegments[targetLang].AddRange(_task.FileNewSegments);
if (this.settings.ExtractFuzzies)
{
this.ProjectFuzzies[targetLang].AddRange(_task.TmFuzzies);
}
}
else
{
this.ProjectTranslations[targetLang] = _task.FileTranslations;
this.ProjectNewSegments[targetLang] = _task.FileNewSegments;
if (this.settings.ExtractFuzzies)
{
this.ProjectFuzzies[targetLang] = _task.TmFuzzies;
}
}
}
public IEnumerable <string> ExtractWords()
{
ProjectFile[] files = Project.GetSourceLanguageFiles();
int i = 0;
foreach (ProjectFile file in files)
{
if (file.Role != FileRole.Translatable)
{
continue;
}
FileTypeManager.SettingsBundle = Sdl.Core.Settings.SettingsUtil.CreateSettingsBundle(null);
// disable xliff validation to speed up things
FileTypeManager.SettingsBundle.GetSettingsGroup("SDL XLIFF 1.0 v 1.0.0.0").GetSetting <bool>("ValidateXliff").Value = false;
IMultiFileConverter converter = FileTypeManager.GetConverter(file.LocalFilePath, (sender, e) => { });
TextExtractionBilingualContentHandler extractor = new TextExtractionBilingualContentHandler();
converter.AddBilingualProcessor(new Sdl.FileTypeSupport.Framework.Core.Utilities.BilingualApi.BilingualContentHandlerAdapter(extractor));
converter.Parse();
foreach (string text in extractor.Text)
{
foreach (string word in GetWords(text))
{
yield return(word);
}
}
i++;
OnProgress((int)(100.0 * i / (double)files.Length));
}
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
var phCreator = new PlaceholderCreator(settings);
var handler = new BilingualContentHandlerAdapter(phCreator);
multiFileConverter.AddBilingualProcessor(handler);
}
/// <summary>
/// Run export on SDLXLIFF path
/// </summary>
/// <param name="filePath">SDLXLIFF file for export</param>
public bool GeneratePreviewFiles(string filePath, IMultiFileConverter multiFileConverter)
{
multiFileConverter.SynchronizeDocumentProperties();
multiFileConverter.AddBilingualProcessor(new FileReader(DataExtractorObj, _settings, filePath));
multiFileConverter.Parse();
return true;
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
var projectController = SdlTradosStudio.Application.GetController <ProjectsController>();
var selectedPatternsFromGrid = _settings.RegexPatterns.Where(e => e.ShouldEnable).ToList();
ProjectBackup.CreateProjectBackup(projectController.CurrentProject.FilePath);
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(new AnonymizerPreProcessor(selectedPatternsFromGrid)));
}
/// <summary>
/// Run export on SDLXLIFF path
/// </summary>
/// <param name="filePath">SDLXLIFF file for export</param>
public bool GeneratePreviewFiles(string filePath, IMultiFileConverter multiFileConverter)
{
multiFileConverter.SynchronizeDocumentProperties();
multiFileConverter.AddBilingualProcessor(new FileReader(DataExtractorObj, _settings, filePath));
multiFileConverter.Parse();
return(true);
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
var segmentsToLock = GetSegmentListFromSettings();
//In here you should add your custom bilingual processor to the file converter
multiFileConverter.AddBilingualProcessor(
new Sdl.FileTypeSupport.Framework.Core.Utilities.BilingualApi.BilingualContentHandlerAdapter(new SegmentLockerPreProcessor(segmentsToLock, _settings.OtherTextbox, _settings.ClearCheck)));
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
var generalSettings = GetSetting <BatchAnonymizerSettings>();
_settings = generalSettings.UseGeneral ? generalSettings : GetAnonymizationSettings(projectFile.Language);
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(new AnonymizerProcessor(_settings, _userNameService, _resourceOriginsService)));
}
private void PrepareForGenerateTarget(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(new ClearTarget()));
if (settings.CopyToTarget)
{
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(new CopySourceToTarget()));
}
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
if (!_settings.ShouldDeanonymize ?? false)
{
return;
}
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(new DecryptDataProcessor(_settings)));
}
public IFileProperties GetFileProperties(IMultiFileConverter converter, string filePath)
{
var fileProperties = converter.ItemFactory.CreateFileProperties();
fileProperties.FileConversionProperties.InputFilePath = filePath;
fileProperties.FileConversionProperties.OriginalFilePath = filePath;
return(fileProperties);
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
var encryptSettings = GetSetting <AnonymizerSettings>();
//process only if the decryption key matches encryption key
if (encryptSettings.EncryptionKey.Equals(_settings.EncryptionKey))
{
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(new DecryptDataProcessor(_settings)));
}
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
if (_processor == null)
{
_processor = new SimplePsedoTranslateProcessor();
var settings = GetSetting <SimplePseudoTranslateSettings>();
_processor.Settings = settings;
}
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(_processor));
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
// Creating a new FileReader and giving it access to the settings (unneeded currently) and the file; parsing text afterwards
// The FileReader handles the task logic of searching the reference numbers, creating and populating the translation memory
// And providing the reference numbers back
logger = new BatchTaskLogger(Path.GetDirectoryName(projectFile.LocalFilePath), LoggingLevels.DEBUG);
task = new FileReader(_settings, projectFile, ref logger);
multiFileConverter.AddBilingualProcessor(task);
multiFileConverter.Parse();
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
if (!AgreementMethods.UserAgreed())
{
CancelHelper.CancelTaskIfRequested(true);
}
if (!_settings.ShouldDeanonymize ?? false)
{
return;
}
var projectController = SdlTradosStudio.Application.GetController <ProjectsController>();
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(new DecryptDataProcessor(_settings)));
var project = projectController.CurrentProject ?? projectController.SelectedProjects.ToList()[0];
var projectFiles = project.GetTargetLanguageFiles();
var unParsedProjectFiles = new List <ProjectFile>();
foreach (var file in projectFiles)
{
if (TaskFiles.GetIds().Contains(file.Id))
{
continue;
}
unParsedProjectFiles.Add(file);
}
var editor = SdlTradosStudio.Application.GetController <EditorController>();
var activeDocs = editor.GetDocuments().ToList();
foreach (var activeDoc in activeDocs)
{
Application.Current.Dispatcher.Invoke(() => { editor.Close(activeDoc); });
}
foreach (var file in unParsedProjectFiles)
{
var converter = DefaultFileTypeManager.CreateInstance(true).GetConverterToDefaultBilingual(file.LocalFilePath, file.LocalFilePath, null);
var contentProcessor = new DecryptDataProcessor(_settings);
converter.AddBilingualProcessor(new BilingualContentHandlerAdapter(contentProcessor));
converter.Parse();
}
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
if (!AgreementMethods.UserAgreed())
{
CancelHelper.CancelTaskIfRequested(true);
}
if (!_settings.ShouldDeanonymize ?? false)
{
return;
}
var projectController = SdlTradosStudio.Application.GetController <ProjectsController>();
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(new DecryptDataProcessor(_settings)));
_restOfFilesParser.ParseRestOfFiles(projectController, TaskFiles, new DecryptDataProcessor(_settings), out _ignoredFiles);
}
public override bool OnFileComplete(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
var key = CreateKey(projectFile.GetLanguageDirection());
if (counters.ContainsKey(key))
{
counters[key].Add(tempCounter);
}
else
{
counters.Add(key, new List <ISegmentWordCounter>()
{
tempCounter
});
keys.Add(key, projectFile.GetLanguageDirection());
}
return(false);
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
//In here you should add your custom bilingual processor to the file converter
// We initialize the class that performs the actual work
//FileReader _task = new FileReader(_settings, projectFile.LocalFilePath); //AbstractBilingualContentProcessor
//multiFileConverter.AddBilingualProcessor(_task);
//multiFileConverter.Parse();
//var regExPatterns = new List<string>(_settings.LockerRegEx.Split(
// new[] { Environment.NewLine },
// StringSplitOptions.None
// ));
var patternsFromGrid = _settings.RegexPatterns.ToList();
multiFileConverter.AddBilingualProcessor(new Sdl.FileTypeSupport.Framework.Core.Utilities.BilingualApi.BilingualContentHandlerAdapter(new SegmentLockerPreProcessor(patternsFromGrid, _settings.IncludeTagContent)));
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
if (!AgreementMethods.UserAgreed())
{
CancelHelper.CancelTaskIfRequested(true);
}
if (!_settings.ShouldAnonymize ?? false)
{
return;
}
var selectedPatternsFromGrid = _settings.RegexPatterns.Where(e => e.ShouldEnable).ToList();
var key = _settings.EncryptionKey == "<dummy-encryption-key>" ? "" : AnonymizeData.DecryptData(_settings.EncryptionKey, Constants.Key);
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(new AnonymizerPreProcessor(selectedPatternsFromGrid, key, _settings.EncryptionState.HasFlag(State.PatternsEncrypted))));
_restOfFilesParser.ParseRestOfFiles(_projectController, TaskFiles,
new AnonymizerPreProcessor(selectedPatternsFromGrid, key, _settings.EncryptionState.HasFlag(State.PatternsEncrypted)),
out _ignoredFiles);
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
//This collects existing translations and segments without full matches from the project files
var languageDirection = projectFile.GetLanguageDirection();
var targetLanguage = languageDirection.TargetLanguage;
FileReader _task = new FileReader(settings);
multiFileConverter.AddBilingualProcessor(_task);
multiFileConverter.Parse();
var targetLang = projectFile.GetLanguageDirection().TargetLanguage;
if (this.ProjectTranslations.ContainsKey(targetLang))
{
this.ProjectTranslations[targetLang].AddRange(_task.FileTranslations);
this.ProjectNewSegments[targetLang].AddRange(_task.FileNewSegments);
}
else
{
this.ProjectTranslations[targetLang] = _task.FileTranslations;
this.ProjectNewSegments[targetLang] = _task.FileNewSegments;
}
}
public override bool OnFileComplete(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
return(true);
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
var worker = new Worker(_settings);
worker.GeneratePreviewFiles(projectFile.LocalFilePath, multiFileConverter);
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
reportGenerator.AddFile(projectFile.LocalFilePath);
multiFileConverter.AddBilingualProcessor(new BilingualContentHandlerAdapter(new SaveToTargetPreProcessor(sourceSettings, targetSettings, reportGenerator)));
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
var worker = new Worker(_settings);
worker.GeneratePreviewFiles(projectFile.LocalFilePath, multiFileConverter);
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
var languageName = projectFile.Language.CultureInfo.Name;
var targetFile = _wizardContext.ProjectFiles.FirstOrDefault(a =>
a.FileId == projectFile.Id.ToString() && a.TargetLanguage == languageName);
if (targetFile != null)
{
if (!targetFile.Selected)
{
return;
}
targetFile.Location = Path.Combine(targetFile.Project.Path, targetFile.Location.Trim('\\'));
if (string.IsNullOrEmpty(_currentLanguage) || languageName != _currentLanguage)
{
_logReport.AppendLine();
_logReport.AppendLine(string.Format(PluginResources.Label_Language, languageName));
_currentLanguage = languageName;
}
var sdlxliffReader = new SdlxliffReader(_segmentBuilder,
_exportSettings.ExportOptions,
GetAnalysisBands(Project as FileBasedProject));
var xliffWriter = new XliffWriter(_exportSettings.ExportOptions.XliffSupport);
var dateTimeStampToString = GetDateTimeStampToString(_exportSettings.DateTimeStamp);
var workingFolder = Path.Combine(_exportSettings.TransactionFolder, dateTimeStampToString);
var languageFolder = Path.Combine(workingFolder, languageName);
var xliffFolder = GetXliffFolder(languageFolder, targetFile);
var xliffFilePath = Path.Combine(xliffFolder, targetFile.Name + ".xliff");
_logReport.AppendLine(string.Format(PluginResources.label_SdlXliffFile, targetFile.Location));
_logReport.AppendLine(string.Format(PluginResources.label_XliffFile, xliffFilePath));
try
{
var xliffData = sdlxliffReader.ReadFile(_projectInfo.Id.ToString(), targetFile.Location);
var exported = xliffWriter.WriteFile(xliffData, xliffFilePath, _exportSettings.ExportOptions.IncludeTranslations);
if (exported)
{
targetFile.Date = new DateTime(_exportSettings.DateTimeStamp.Ticks, DateTimeKind.Utc);
targetFile.Action = Enumerators.Action.Export;
targetFile.Status = Enumerators.Status.Success;
targetFile.XliffFilePath = xliffFilePath;
targetFile.ConfirmationStatistics = sdlxliffReader.ConfirmationStatistics;
targetFile.TranslationOriginStatistics = sdlxliffReader.TranslationOriginStatistics;
}
var activityFile = new ProjectFileActivity
{
ProjectFileId = targetFile.FileId,
ProjectFile = targetFile,
ActivityId = Guid.NewGuid().ToString(),
Action = Enumerators.Action.Export,
Status = exported ? Enumerators.Status.Success : Enumerators.Status.Error,
Date = targetFile.Date,
Name = Path.GetFileName(targetFile.XliffFilePath),
Path = Path.GetDirectoryName(targetFile.XliffFilePath),
ConfirmationStatistics = targetFile.ConfirmationStatistics,
TranslationOriginStatistics = targetFile.TranslationOriginStatistics
};
targetFile.ProjectFileActivities.Add(activityFile);
if (!exported)
{
_isError = true;
}
_logReport.AppendLine(string.Format(PluginResources.Label_Success, exported));
_logReport.AppendLine();
}
catch (Exception ex)
{
_logReport.AppendLine();
_logReport.AppendLine(string.Format(PluginResources.label_ExceptionMessage, ex.Message));
throw;
}
}
}
public void SetFileExtractorProperties(IFileExtractor extractor, IMultiFileConverter converter)
{
extractor.ItemFactory = converter.ItemFactory;
extractor.BilingualParser.ItemFactory = converter.ItemFactory;
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
//In here you should add your custom bilingual processor to the file converter
}
protected override void ConfigureConverter(ProjectFile projectFile, IMultiFileConverter multiFileConverter)
{
}
