private List <FileData> GetFileDataList(Interfaces.IProject project, ProjectInfo studioProjectInfo, SdlxliffReader sdlxliffReader)
{
var fileDataList = new List <FileData>();
foreach (var targetLanguage in project.TargetLanguages)
{
var targetFiles = project.ProjectFiles.Where(a =>
string.Compare(a.TargetLanguage, targetLanguage.CultureInfo.Name,
StringComparison.CurrentCultureIgnoreCase) == 0);
foreach (var projectFile in targetFiles)
{
var inputPath = Path.Combine(studioProjectInfo.LocalProjectFolder, projectFile.Location);
var data = sdlxliffReader.ReadFile(project.Id, projectFile.FileId, inputPath, projectFile.TargetLanguage);
var hasEmptyTranslations = ContainsEmptyTranslations(data);
fileDataList.Add(new FileData
{
Data = data,
HasEmptyTranslations = hasEmptyTranslations
});
}
}
return(fileDataList);
}
private void AssignProjectFileXliffData(Interfaces.IProject project, IEnumerable <ProjectFile> projectfiles)
{
if (projectfiles == null)
{
return;
}
foreach (var projectFile in projectfiles)
{
if (projectFile.XliffData == null)
{
continue;
}
var projectFileName = projectFile.Name.Substring(0, projectFile.Name.Length - ".sdlxliff".Length) + ".xliff.sdlxliff";
var targetFile = project.ProjectFiles?.FirstOrDefault(a =>
string.Compare(a.Name, projectFileName, StringComparison.CurrentCultureIgnoreCase) == 0 &&
string.Compare(a.Path, projectFile.Path, StringComparison.CurrentCultureIgnoreCase) == 0 &&
string.Compare(a.TargetLanguage, projectFile.TargetLanguage, StringComparison.CurrentCultureIgnoreCase) == 0);
if (targetFile != null)
{
targetFile.XliffData = projectFile.XliffData;
targetFile.ExternalFilePath = projectFile.ExternalFilePath;
targetFile.ConfirmationStatistics = projectFile.ConfirmationStatistics;
targetFile.TranslationOriginStatistics = projectFile.TranslationOriginStatistics;
targetFile.Selected = true;
}
}
}
private void WriteReportProject(XmlWriter writer, string elementName, Interfaces.IProject project)
{
if (project == null)
{
return;
}
writer.WriteStartElement(elementName);
writer.WriteAttributeString("name", project.Name);
writer.WriteAttributeString("number", project.Id);
var minValue = DateTime.MinValue.ToString(CultureInfo.InvariantCulture);
var maxValue = DateTime.MaxValue.ToString(CultureInfo.InvariantCulture);
var utcMinValue = DateTime.MinValue.ToUniversalTime().ToString(CultureInfo.InvariantCulture);
var utcMaxValue = DateTime.MaxValue.ToUniversalTime().ToString(CultureInfo.InvariantCulture);
var dueDateValue = project.DueDate.ToString(CultureInfo.InvariantCulture);
if (dueDateValue != minValue && dueDateValue != maxValue &&
dueDateValue != utcMinValue && dueDateValue != utcMaxValue)
{
writer.WriteAttributeString("dueDate", GetDisplayDateTime(project.DueDate));
}
writer.WriteEndElement(); //project
}
public Interfaces.IProject GetProject(FileBasedProject selectedProject, IReadOnlyCollection <string> selectedFileIds, List <ProjectFile> projectFiles = null)
{
if (selectedProject == null)
{
return(null);
}
var projectInfo = selectedProject.GetProjectInfo();
Interfaces.IProject project = IsBackTranslationProject(projectInfo.ProjectOrigin)
? new BackTranslationProject()
: new Project();
project.Id = projectInfo.Id.ToString();
project.Name = projectInfo.Name;
project.Customer = _customerProvider.GetProjectCustomer(selectedProject);
project.Created = projectInfo.CreatedAt.ToUniversalTime();
project.DueDate = projectInfo.DueDate?.ToUniversalTime() ?? DateTime.MaxValue;
project.Path = projectInfo.LocalProjectFolder;
project.SourceLanguage = GetLanguageInfo(projectInfo.SourceLanguage.CultureInfo);
project.TargetLanguages = GetLanguageInfos(projectInfo.TargetLanguages);
project.ProjectType = GetProjectType(selectedProject);
var existingProject = IsBackTranslationProject(projectInfo.ProjectOrigin)
? GetBackTranslationProjectProject(projectInfo.Id.ToString(), out _)
: _controller.GetProjects().FirstOrDefault(a => a.Id == projectInfo.Id.ToString());
if (existingProject != null)
{
foreach (var projectFile in existingProject.ProjectFiles)
{
if (projectFile.Clone() is ProjectFile clonedProjectFile)
{
clonedProjectFile.Project = project;
clonedProjectFile.Location = GeFullPath(project.Path, clonedProjectFile.Location);
clonedProjectFile.Report = GeFullPath(project.Path, clonedProjectFile.Report);
clonedProjectFile.ExternalFilePath = GeFullPath(project.Path, clonedProjectFile.ExternalFilePath);
clonedProjectFile.Selected = selectedFileIds != null && selectedFileIds.Any(a => a == projectFile.FileId.ToString());
project.ProjectFiles.Add(clonedProjectFile);
}
}
foreach (var existingProjectBackTranslationProject in existingProject.BackTranslationProjects)
{
project.BackTranslationProjects.Add(existingProjectBackTranslationProject.Clone() as BackTranslationProject);
}
}
else
{
project.ProjectFiles = GetProjectFiles(selectedProject, project, selectedFileIds);
}
AssignProjectFileXliffData(project, projectFiles);
return(project);
}
private static void WriteReportCustomer(XmlWriter writer, Interfaces.IProject project)
{
if (!string.IsNullOrEmpty(project.Customer?.Name))
{
writer.WriteStartElement("customer");
writer.WriteAttributeString("name", project.Customer.Name);
writer.WriteAttributeString("email", project.Customer.Email);
writer.WriteEndElement(); //customer
}
}
private void SetEnabled(Interfaces.IProject selectedProject)
{
if (selectedProject == null ||
selectedProject is BackTranslationProject)
{
Enabled = false;
}
else
{
Enabled = true;
}
}
private Interfaces.IProject GetBackTranslationProject(Interfaces.IProject project, string targetLanguage)
{
foreach (var backTranslationProject in project.BackTranslationProjects)
{
if (string.Compare(backTranslationProject.SourceLanguage.CultureInfo.Name,
targetLanguage, StringComparison.CurrentCultureIgnoreCase) == 0)
{
return(backTranslationProject);
}
}
return(null);
}
private Xliff GetBackTranslationXliffData(Interfaces.IProject project, ProjectFile projectFile, SdlxliffReader sdlxliffReader)
{
if (project != null && projectFile != null)
{
var backTranslationFilePath =
Path.Combine(project.Path, projectFile.Location);
if (System.IO.File.Exists(backTranslationFilePath))
{
return(sdlxliffReader.ReadFile(project.Id, projectFile.FileId,
backTranslationFilePath,
projectFile.TargetLanguage));
}
}
return(null);
}
public Interfaces.IProject GetBackTranslationProject(string projectId, out Interfaces.IProject parentProject)
{
parentProject = null;
var projects = _controller.GetProjects();
foreach (var project in projects)
{
var backTranslationProject =
project.BackTranslationProjects.FirstOrDefault(a => a.Id == projectId);
if (backTranslationProject != null)
{
parentProject = project;
return(backTranslationProject);
}
}
return(null);
}
private static ProjectFile GetBackTranslationProjectFile(Interfaces.IProject backTranslationProject, ProjectFile projectFile)
{
if (backTranslationProject == null)
{
return(null);
}
foreach (var translationProjectFile in backTranslationProject.ProjectFiles)
{
if (string.Compare(projectFile.Name, translationProjectFile.Name,
StringComparison.CurrentCultureIgnoreCase) == 0 &&
string.Compare(projectFile.Path, translationProjectFile.Path,
StringComparison.CurrentCultureIgnoreCase) == 0)
{
return(translationProjectFile);
}
}
return(null);
}
private ProjectFile GetProjectFile(Interfaces.IProject project, ProjectAutomation.Core.ProjectFile projectFile,
IReadOnlyCollection <string> selectedFileIds)
{
var projectFileModel = new ProjectFile
{
ProjectId = project.Id,
FileId = projectFile.Id.ToString(),
Name = projectFile.Name,
Path = projectFile.Folder,
Location = projectFile.LocalFilePath,
Action = Enumerators.Action.None,
WorkFlow = Enumerators.WorkFlow.None,
Status = Enumerators.Status.Ready,
Date = DateTime.MinValue,
TargetLanguage = projectFile.Language.CultureInfo.Name,
Selected = selectedFileIds != null && selectedFileIds.Any(a => a == projectFile.Id.ToString()),
FileType = projectFile.FileTypeId,
Project = project
};
return(projectFileModel);
}
private List <ProjectFile> GetProjectFiles(IProject project, Interfaces.IProject projectModel, IReadOnlyCollection <string> selectedFileIds)
{
var projectInfo = project.GetProjectInfo();
var projectFiles = new List <ProjectFile>();
var sourceLanguageFiles = project.GetSourceLanguageFiles();
foreach (var projectFile in sourceLanguageFiles)
{
if (projectFile.Role != FileRole.Translatable)
{
continue;
}
var projectFileModel = GetProjectFile(projectModel, projectFile, null);
projectFiles.Add(projectFileModel);
}
foreach (var targetLanguage in projectInfo.TargetLanguages)
{
var languageFiles = project.GetTargetLanguageFiles(targetLanguage);
foreach (var projectFile in languageFiles)
{
if (projectFile.Role != FileRole.Translatable)
{
continue;
}
var projectFileModel = GetProjectFile(projectModel, projectFile, selectedFileIds);
projectFiles.Add(projectFileModel);
}
}
return(projectFiles);
}
public ProjectPropertiesViewModel(Interfaces.IProject project)
{
SelectedProject = project;
}
public List <Report> CreateFinalReport(Interfaces.IProject project, FileBasedProject studioProject, List <ProjectFile> selectedFiles, out string workingPathOut)
{
var reports = new List <Report>();
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = true,
Indent = false
};
var reportName = "Trados Transcreate Report";
var studioProjectInfo = studioProject.GetProjectInfo();
var dateTimeStamp = DateTime.UtcNow;
var dataTimeStampToString = DateTimeStampToString(dateTimeStamp);
var workflowPath = GetPath(studioProjectInfo.LocalProjectFolder, "Workflow");
var actionPath = GetPath(workflowPath, "Report");
var workingPath = GetPath(actionPath, dataTimeStampToString);
var exportOptions = new ExportOptions();
exportOptions.IncludeBackTranslations = true;
exportOptions.IncludeTranslations = true;
exportOptions.CopySourceToTarget = false;
var analysisBands = _projectAutomationService.GetAnalysisBands(studioProject);
var progressSettings = new ProgressDialogSettings(ApplicationInstance.GetActiveForm(), true, true, false);
var result = ProgressDialog.ProgressDialog.Execute("Create Transcreate Reports", () =>
{
var sdlxliffReader = new SdlxliffReader(_segmentBuilder, exportOptions, analysisBands);
decimal maximum = project.ProjectFiles.Count;
decimal current = 0;
foreach (var targetLanguage in project.TargetLanguages)
{
var projectFiles = project.ProjectFiles.Where(a =>
string.Compare(a.TargetLanguage, targetLanguage.CultureInfo.Name, StringComparison.CurrentCultureIgnoreCase) == 0).ToList();
var hasProjectFiles = HasProjectFiles(selectedFiles, projectFiles);
if (!hasProjectFiles)
{
current += projectFiles.Count;
var progress = current / maximum * 100;
ProgressDialog.ProgressDialog.Current.Report((int)progress,
string.Format("Language: {0}\r\nFile: {1}", targetLanguage.CultureInfo.DisplayName, projectFiles.FirstOrDefault().Name));
continue;
}
var workingLanguageFolder = GetPath(workingPath, targetLanguage.CultureInfo.Name);
foreach (var projectFile in projectFiles)
{
if (ProgressDialog.ProgressDialog.Current.CheckCancellationPending())
{
ProgressDialog.ProgressDialog.Current.ThrowIfCancellationPending();
}
current++;
var progress = current / maximum * 100;
ProgressDialog.ProgressDialog.Current.Report((int)progress, string.Format("Language: {0}\r\nFile: {1}", targetLanguage.CultureInfo.DisplayName, projectFile.Name));
if (selectedFiles != null && !selectedFiles.Exists(a => a.FileId == projectFile.FileId))
{
continue;
}
var projectFilePath = Path.Combine(project.Path, projectFile.Location);
var xliffData = sdlxliffReader.ReadFile(project.Id, projectFile.FileId, projectFilePath,
targetLanguage.CultureInfo.Name);
var backTranslationProject = GetBackTranslationProject(project, targetLanguage.CultureInfo.Name);
var backTranslationFile = GetBackTranslationProjectFile(backTranslationProject, projectFile);
var xliffDataBackTranslation = GetBackTranslationXliffData(backTranslationProject, backTranslationFile, sdlxliffReader);
var fileName = projectFile.Name.Substring(0, projectFile.Name.LastIndexOf(".", StringComparison.Ordinal));
var reportFile = Path.Combine(workingLanguageFolder, fileName + ".xml");
using (var writer = XmlWriter.Create(reportFile, settings))
{
writer.WriteStartElement("task");
writer.WriteAttributeString("name", reportName);
writer.WriteAttributeString("created", dataTimeStampToString);
writer.WriteStartElement("taskInfo");
writer.WriteAttributeString("action", "Trados Transcreate Report");
writer.WriteAttributeString("file", projectFile.Path + projectFile.Name);
writer.WriteAttributeString("taskId", Guid.NewGuid().ToString());
writer.WriteAttributeString("runAt", GetDisplayDateTime(dateTimeStamp));
WriteReportProject(writer, "project", project);
WriteReportProject(writer, "backProject", backTranslationProject);
WriteReportLanguage(writer, "source", project.SourceLanguage.CultureInfo.Name);
WriteReportLanguage(writer, "target", targetLanguage.CultureInfo.Name);
WriteReportCustomer(writer, project);
WriteReportTranslationProviders(writer, studioProject);
writer.WriteEndElement(); //taskInfo
writer.WriteStartElement("translations");
foreach (var dataFile in xliffData.Files)
{
writer.WriteStartElement("version");
writer.WriteAttributeString("type", dataFile.Original);
var backTranslationDataFile =
xliffDataBackTranslation?.Files.FirstOrDefault(a => a.Original == dataFile.Original);
writer.WriteStartElement("segments");
foreach (var transUnit in dataFile.Body.TransUnits)
{
var textFunction = transUnit.Contexts.FirstOrDefault(
a => string.Compare(a.DisplayName, "Text Function", StringComparison.CurrentCultureIgnoreCase) == 0);
foreach (var segmentPair in transUnit.SegmentPairs)
{
writer.WriteStartElement("segment");
var backTranslationSegmentPair = GetBackTranslationSegmentPair(backTranslationDataFile, segmentPair);
writer.WriteAttributeString("id", segmentPair.Id);
writer.WriteAttributeString("textFunction", textFunction?.Description ?? string.Empty);
writer.WriteStartElement("source");
writer.WriteString(segmentPair.Source.ToString());
writer.WriteEndElement(); //source
writer.WriteStartElement("target");
writer.WriteString(segmentPair.Target.ToString());
writer.WriteEndElement(); //source
writer.WriteStartElement("back");
writer.WriteString(backTranslationSegmentPair?.Target?.ToString() ?? string.Empty);
writer.WriteEndElement(); //backTranslation
writer.WriteStartElement("comments");
var comments = GetSegmentComments(segmentPair.Target, xliffData.DocInfo);
if (comments != null)
{
foreach (var comment in comments)
{
writer.WriteStartElement("comment");
writer.WriteAttributeString("version", comment.Version);
writer.WriteAttributeString("author", comment.Author);
writer.WriteAttributeString("severity", comment.Severity.ToString());
writer.WriteAttributeString("date", GetDisplayDateTime(comment.Date));
writer.WriteString(comment.Text ?? string.Empty);
writer.WriteEndElement(); //comment
}
}
writer.WriteEndElement(); //comments
writer.WriteEndElement(); //segment
}
}
writer.WriteEndElement(); //segments
writer.WriteEndElement(); //version
}
writer.WriteEndElement(); //translations
}
// transform the file against an xslt
var templatePath = GetReportTemplatePath("TranscreateFinalReport.xsl");
var reportFilePath = CreateHtmlReportFile(reportFile, templatePath);
var report = new Report
{
Name = fileName,
Date = dateTimeStamp,
Description = "Transcreate Report",
Group = "Transcreate Report",
Language = targetLanguage.CultureInfo.Name,
Path = reportFilePath
};
reports.Add(report);
}
}
}, progressSettings);
workingPathOut = workingPath;
if (result.Cancelled)
{
System.Windows.Forms.MessageBox.Show("Process cancelled by user.", PluginResources.Plugin_Name);
return(new List <Report>());
}
return(reports);
}
