/// <summary>
/// Demonstrates how to validate a document on write and display the data where the validation error occurred.
/// </summary>
/// <param name="document">The document to validate.</param>
/// <param name="file">The path to write the document to.</param>
public static void ViewValidations(XliffDocument document, string file)
{
using (IO.FileStream stream = new IO.FileStream(file, IO.FileMode.Create, IO.FileAccess.Write))
{
XliffWriter writer;
writer = new XliffWriter();
try
{
writer.Serialize(stream, document);
}
catch (ValidationException e)
{
Console.WriteLine("ValidationException Details:");
if (e.Data != null)
{
foreach (object key in e.Data.Keys)
{
Console.WriteLine(" '{0}': '{1}'", key, e.Data[key]);
}
}
}
}
}
/// <summary>
/// Gets the contents of a document as a serialized string.
/// </summary>
/// <param name="document">The document whose contents to get.</param>
/// <param name="indentChars">Characters to use to indent the serialized document for readability.</param>
/// <returns>The string representation of the serialized document.</returns>
public static string GetDocumentContents(XliffDocument document, string indentChars)
{
using (MemoryStream stream = new MemoryStream())
{
StreamReader reader;
XliffWriter writer;
if (indentChars == null)
{
writer = new XliffWriter();
}
else
{
XliffWriterSettings settings;
settings = new XliffWriterSettings();
settings.Indent = true;
settings.IndentChars = (indentChars == string.Empty) ? " " : indentChars;
writer = new XliffWriter(settings);
}
writer.Serialize(stream, document);
stream.Seek(0, SeekOrigin.Begin);
reader = new StreamReader(stream);
return(reader.ReadToEnd());
}
}
internal ExportResult Export(ICollection <LocalizationResource> resources, CultureInfo fromLanguage, CultureInfo toLanguage)
{
if (resources == null)
{
throw new ArgumentNullException(nameof(resources));
}
if (fromLanguage == null)
{
throw new ArgumentNullException(nameof(fromLanguage));
}
if (toLanguage == null)
{
throw new ArgumentNullException(nameof(toLanguage));
}
var doc = new XliffDocument(fromLanguage.Name)
{
TargetLanguage = toLanguage.Name
};
var file = new File("f1");
doc.Files.Add(file);
var unit = new Unit("u1");
file.Containers.Add(unit);
foreach (var resource in resources)
{
var segment = new Segment(XmlConvert.EncodeNmToken(resource.ResourceKey))
{
Source = new Source(),
Target = new Target()
};
segment.Source.Text.Add(new CDataTag(resource.Translations.ByLanguage(fromLanguage.Name, false)));
segment.Target.Text.Add(new CDataTag(resource.Translations.ByLanguage(toLanguage.Name, false)));
unit.Resources.Add(segment);
}
var dest = new MemoryStream();
var settings = new XliffWriterSettings();
settings.Validators.Clear();
var writer = new XliffWriter(settings);
writer.Serialize(dest, doc);
dest.Position = 0;
var reader = new StreamReader(dest);
return(new ExportResult(reader.ReadToEnd(), "application/x-xliff+xml", $"{fromLanguage.Name}-{toLanguage.Name}-{DateTime.UtcNow:yyyyMMdd}.xliff"));
}
/// <summary>
/// Demonstrates how to write an XLIFF document to a file.
/// </summary>
/// <param name="document">The document to write.</param>
/// <param name="file">The path to write the document to.</param>
public static void WriteDocument(XliffDocument document, string file)
{
using (IO.FileStream stream = new IO.FileStream(file, IO.FileMode.Create, IO.FileAccess.Write))
{
XliffWriter writer;
writer = new XliffWriter();
writer.Serialize(stream, document);
}
}
public void TestInitialize()
{
XliffWriterSettings settings;
settings = new XliffWriterSettings();
settings.Indent = true;
settings.IndentChars = " ";
settings.Validators.Clear();
this._document = new XliffDocument();
this._stream = new System.IO.MemoryStream();
this._writer = new XliffWriter(settings);
}
public void TestInitialize()
{
XliffWriterSettings settings;
settings = new XliffWriterSettings();
settings.Indent = true;
settings.IndentChars = " ";
settings.Validators.Clear();
this._document = new XliffDocument();
this._stream = new System.IO.MemoryStream();
this._writer = new XliffWriter(settings);
}
/// <summary>
/// Demonstrates how to disable validation when writing an XLIFF document.
/// </summary>
/// <param name="document">The document to write.</param>
/// <param name="file">The path to the document to write.</param>
public static void DisableValidationOnWrite(XliffDocument document, string file)
{
using (IO.FileStream stream = new IO.FileStream(file, IO.FileMode.Create, IO.FileAccess.Write))
{
XliffWriter writer;
XliffWriterSettings settings;
settings = new XliffWriterSettings();
settings.Validators.Clear();
writer = new XliffWriter(settings);
writer.Serialize(stream, document);
}
}
/// <summary>
/// Writes the internal document to the internal stream and returns the contents of the stream using a
/// specific output detail.
/// </summary>
/// <param name="detail">The output detail to use when writing.</param>
/// <returns>The contents of the stream.</returns>
private string Serialize(OutputDetail detail)
{
XliffWriterSettings settings;
XliffWriter writer;
settings = new XliffWriterSettings();
settings.Indent = true;
settings.IndentChars = " ";
settings.Detail = detail;
this._stream.Seek(0, System.IO.SeekOrigin.Begin);
writer = new XliffWriter(settings);
writer.Serialize(this._stream, this._document);
return(this.GetStreamContents());
}
public EncoderTests()
{
var settings = new XliffWriterSettings
{
Indent = true,
IndentChars = " "
};
settings.Validators.Clear();
_document = new XliffDocument("en-GB")
{
TargetLanguage = "en-US"
};
_stream = new MemoryStream();
_writer = new XliffWriter(settings);
}
public string Write(XliffDocument document, bool indent = false)
{
var result = string.Empty;
using (IO.Stream stream = new IO.MemoryStream())
{
XliffWriter writer;
var settings = new XliffWriterSettings();
settings.Indent = indent;
writer = new XliffWriter(settings);
writer.Serialize(stream, document);
stream.Position = 0;
var sr = new IO.StreamReader(stream);
result = sr.ReadToEnd();
}
return(result);
}
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;
}
}
}
/// <summary>
/// Writes the internal document to the internal stream and returns the contents of the stream using a
/// specific output detail.
/// </summary>
/// <param name="detail">The output detail to use when writing.</param>
/// <returns>The contents of the stream.</returns>
private string Serialize(OutputDetail detail)
{
XliffWriterSettings settings;
XliffWriter writer;
settings = new XliffWriterSettings();
settings.Indent = true;
settings.IndentChars = " ";
settings.Detail = detail;
this._stream.Seek(0, System.IO.SeekOrigin.Begin);
writer = new XliffWriter(settings);
writer.Serialize(this._stream, this._document);
return this.GetStreamContents();
}
protected override void Execute()
{
var projects = _controllers.TranscreateController.GetSelectedProjects();
if (projects?.Count != 1)
{
Enabled = false;
return;
}
var project = projects[0];
if (project is BackTranslationProject)
{
return;
}
var studioProject = _controllers.ProjectsController.GetProjects()
.FirstOrDefault(a => a.GetProjectInfo().Id.ToString() == project.Id);
if (studioProject == null)
{
return;
}
var studioProjectInfo = studioProject.GetProjectInfo();
var backTranslationsFolder = Path.Combine(studioProjectInfo.LocalProjectFolder, "BackProjects");
if (Directory.Exists(backTranslationsFolder))
{
var message01 = "The Back-Translations folder is not empty."
+ Environment.NewLine + Environment.NewLine
+ "'" + backTranslationsFolder + "'"
+ Environment.NewLine + Environment.NewLine;
var message02 = "Do you want to proceed and delete this folder?";
var response = MessageBox.Show(message01 + message02, PluginResources.Plugin_Name,
MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (response != DialogResult.Yes)
{
return;
}
TryDeleteDirectory(backTranslationsFolder);
}
var taskContexts = new List <TaskContext>();
var progressSettings = new ProgressDialogSettings(ApplicationInstance.GetActiveForm(), true, true, true);
var result = ProgressDialog.Execute("Create Back-Translation Projects", () =>
{
ProgressDialog.Current.Report(0, "Reading language files...");
var dateTimeStamp = DateTime.UtcNow;
var dataTimeStampToString = DateTimeStampToString(dateTimeStamp);
var workFlowPath = GetPath(studioProjectInfo.LocalProjectFolder, "WorkFlow");
var workingActionPath = GetPath(workFlowPath, "Convert");
var workingFolder = GetPath(workingActionPath, dataTimeStampToString);
var exportOptions = new ExportOptions();
exportOptions.IncludeBackTranslations = true;
exportOptions.IncludeTranslations = true;
exportOptions.CopySourceToTarget = false;
var importOptions = new ImportOptions();
importOptions.OverwriteTranslations = true;
importOptions.OriginSystem = "Transcreate Automation";
importOptions.StatusTranslationUpdatedId = string.Empty;
var analysisBands = _projectAutomationService.GetAnalysisBands(studioProject);
var sdlxliffReader = new SdlxliffReader(_segmentBuilder, exportOptions, analysisBands);
var sdlxliffWriter = new SdlxliffWriter(_segmentBuilder, importOptions, analysisBands);
var xliffWriter = new XliffWriter(Enumerators.XLIFFSupport.xliff12sdl);
// Read the SDLXLIFF data
var fileDataList = GetFileDataList(project, studioProjectInfo, sdlxliffReader);
var filesWithEmptyTranslations = fileDataList.Count(a => a.HasEmptyTranslations);
if (filesWithEmptyTranslations > 0)
{
var message01 = string.Format(PluginResources.Found_empty_translations_in_0_files,
filesWithEmptyTranslations)
+ Environment.NewLine + Environment.NewLine;
var message02 = PluginResources.Proceed_and_copy_source_to_target_for_empty_translations;
var response = MessageBox.Show(message01 + message02, PluginResources.Plugin_Name,
MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (response != DialogResult.Yes)
{
return;
}
}
ProgressDialog.Current.ProgressBarIsIndeterminate = false;
decimal maximum = project.TargetLanguages.Count;
decimal current = 0;
foreach (var targetLanguage in project.TargetLanguages)
{
if (ProgressDialog.Current.CheckCancellationPending())
{
ProgressDialog.Current.ThrowIfCancellationPending();
}
current++;
var progress = current / maximum * 100;
ProgressDialog.Current.Report((int)progress, "Language: " + targetLanguage.CultureInfo.DisplayName);
var sourceFiles = new List <string>();
var languageFolder = GetPath(workingFolder, targetLanguage.CultureInfo.Name);
var targetFiles = project.ProjectFiles.Where(a =>
string.Compare(a.TargetLanguage, targetLanguage.CultureInfo.Name,
StringComparison.CurrentCultureIgnoreCase) == 0);
var languageFileData = new List <FileData>();
foreach (var projectFile in targetFiles)
{
var fileData =
fileDataList.FirstOrDefault(a => a.Data.DocInfo.DocumentId == projectFile.FileId);
if (fileData == null)
{
continue;
}
SwitchSourceWithTargetSegments(fileData);
var xliffFolder = GetPath(languageFolder, projectFile.Path);
var xliffFilePath = Path.Combine(xliffFolder,
projectFile.Name.Substring(0, projectFile.Name.Length - ".sdlxliff".Length));
// Write the XLIFF file
var success = xliffWriter.WriteFile(fileData.Data, xliffFilePath, true);
if (!success)
{
throw new Exception(string.Format(
PluginResources.Unexpected_error_while_converting_the_file, xliffFilePath));
}
sourceFiles.Add(xliffFilePath);
languageFileData.Add(fileData);
}
var iconPath = GetBackTranslationIconPath();
var newStudioProject = _projectAutomationService.CreateBackTranslationProject(
studioProject, targetLanguage.CultureInfo.Name, iconPath, sourceFiles, "BT");
_projectAutomationService.RunPretranslationWithoutTm(newStudioProject);
var taskContext = CreateBackTranslationTaskContext(newStudioProject, languageFileData,
studioProjectInfo.LocalProjectFolder, sdlxliffReader, sdlxliffWriter, xliffWriter);
taskContext.Completed = true;
taskContexts.Add(taskContext);
}
}, progressSettings);
if (result.Cancelled || result.OperationFailed)
{
TryDeleteDirectory(backTranslationsFolder);
var message = result.Cancelled ? "Process cancelled by user." : result.Error?.Message;
MessageBox.Show(message, PluginResources.Plugin_Name);
return;
}
foreach (var taskContext in taskContexts)
{
CleanupProjectSettings(taskContext.FileBasedProject);
ActivateProject(taskContext.FileBasedProject);
_projectAutomationService.RemoveLastReportOfType("Translate");
var reports = _controllers.TranscreateController.CreateHtmlReports(taskContext, taskContext.FileBasedProject, taskContext.Project);
_controllers.TranscreateController.ReportsController.AddReports(_controllers.TranscreateController.ClientId, reports);
_controllers.TranscreateController.UpdateBackTranslationProjectData(project, taskContext);
}
_controllers.TranscreateController.InvalidateProjectsContainer();
Enabled = false;
}
private TaskContext CreateBackTranslationTaskContext(FileBasedProject newStudioProject,
IReadOnlyCollection <FileData> languageFileData, string localProjectFolder,
SdlxliffReader sdlxliffReader, SdlxliffWriter sdlxliffWriter, XliffWriter xliffWriter)
{
var newStudioProjectInfo = newStudioProject.GetProjectInfo();
var action = Enumerators.Action.CreateBackTranslation;
var workFlow = Enumerators.WorkFlow.Internal;
var setttings = GetSettings();
var taskContext = new TaskContext(action, workFlow, setttings);
taskContext.AnalysisBands = _projectAutomationService.GetAnalysisBands(newStudioProject);
taskContext.ExportOptions.IncludeBackTranslations = true;
taskContext.ExportOptions.IncludeTranslations = true;
taskContext.ExportOptions.CopySourceToTarget = false;
taskContext.LocalProjectFolder = newStudioProjectInfo.LocalProjectFolder;
taskContext.WorkflowFolder = taskContext.GetWorkflowPath();
var workingProject = _projectAutomationService.GetProject(newStudioProject, null);
workingProject.ProjectFiles.RemoveAll(a => a.TargetLanguage == workingProject.SourceLanguage.CultureInfo.Name);
taskContext.Project = workingProject;
taskContext.FileBasedProject = newStudioProject;
taskContext.ProjectFiles = workingProject.ProjectFiles;
foreach (var projectFile in taskContext.ProjectFiles)
{
projectFile.Selected = true;
var fileData = GetFileData(languageFileData, localProjectFolder, projectFile);
var tmpInputFile = Path.GetTempFileName();
File.Move(tmpInputFile, tmpInputFile + ".sdlxliff");
tmpInputFile = tmpInputFile + ".sdlxliff";
var paragraphMap = GetParagraphMap(sdlxliffReader, projectFile.ProjectId, projectFile.FileId,
projectFile.Location, projectFile.TargetLanguage);
AlignParagraphIds(fileData.Data, paragraphMap.Keys.ToList());
var filePath = Path.Combine(taskContext.WorkingFolder, projectFile.Path.Trim('\\'));
var externalFilePath = Path.Combine(filePath, projectFile.Name + ".xliff");
if (!Directory.Exists(filePath))
{
Directory.CreateDirectory(filePath);
}
xliffWriter.WriteFile(fileData.Data, externalFilePath, true);
var success = sdlxliffWriter.UpdateFile(fileData.Data, projectFile.Location, tmpInputFile, true);
if (success)
{
projectFile.Date = taskContext.DateTimeStamp;
projectFile.Action = action;
projectFile.WorkFlow = workFlow;
projectFile.Status = Enumerators.Status.Success;
projectFile.Report = string.Empty;
projectFile.ExternalFilePath = externalFilePath;
projectFile.ConfirmationStatistics = sdlxliffWriter.ConfirmationStatistics;
projectFile.TranslationOriginStatistics = sdlxliffWriter.TranslationOriginStatistics;
}
var activityFile = new ProjectFileActivity
{
ProjectFileId = projectFile.FileId,
ActivityId = Guid.NewGuid().ToString(),
Action = action,
WorkFlow = workFlow,
Status = success ? Enumerators.Status.Success : Enumerators.Status.Error,
Date = projectFile.Date,
Name = Path.GetFileName(projectFile.ExternalFilePath),
Path = Path.GetDirectoryName(projectFile.ExternalFilePath),
Report = string.Empty,
ProjectFile = projectFile,
ConfirmationStatistics = projectFile.ConfirmationStatistics,
TranslationOriginStatistics = projectFile.TranslationOriginStatistics
};
projectFile.ProjectFileActivities.Add(activityFile);
File.Copy(projectFile.Location, Path.Combine(filePath, projectFile.Name));
File.Delete(projectFile.Location);
File.Copy(tmpInputFile, projectFile.Location, true);
File.Delete(tmpInputFile);
}
return(taskContext);
}
internal ExportResult Export(ICollection <LocalizationResource> resources, CultureInfo fromLanguage, CultureInfo toLanguage)
{
if (resources == null)
{
throw new ArgumentNullException(nameof(resources));
}
if (fromLanguage == null)
{
throw new ArgumentNullException(nameof(fromLanguage));
}
if (toLanguage == null)
{
throw new ArgumentNullException(nameof(toLanguage));
}
// NOTE: legacy reosurces could not be exported as they contain illegal characters in keys
// also some more modern resources cannot be exported as-is (nested classes)
var exportableResources = resources.Where(r => !r.ResourceKey.StartsWith("/"))
.ForEach(r => r.ResourceKey = r.ResourceKey.Replace("+", "---"));
var doc = new XliffDocument(fromLanguage.Name)
{
TargetLanguage = toLanguage.Name
};
var file = new File("f1");
doc.Files.Add(file);
var unit = new Unit("u1");
file.Containers.Add(unit);
foreach (var resource in exportableResources)
{
var segment = new Segment(resource.ResourceKey)
{
Source = new Source(),
Target = new Target()
};
segment.Source.Text.Add(new CDataTag(resource.Translations.ByLanguage(fromLanguage)));
segment.Target.Text.Add(new CDataTag(resource.Translations.ByLanguage(toLanguage)));
unit.Resources.Add(segment);
}
var dest = new MemoryStream();
var settings = new XliffWriterSettings();
settings.Validators.Clear();
var writer = new XliffWriter(settings);
writer.Serialize(dest, doc);
dest.Position = 0;
var reader = new StreamReader(dest);
return(new ExportResult(reader.ReadToEnd(), "application/x-xliff+xml", $"{fromLanguage.Name}-{toLanguage.Name}-{DateTime.UtcNow:yyyyMMdd}.xliff"));
}
