public void ProcessTargetLanguageFilesExtended(FileBasedProject project, string locale)
{
List <TaskStatusEventArgs> taskStatusEventArgsList = new List <TaskStatusEventArgs>();
List <MessageEventArgs> messageEventArgsList = new List <MessageEventArgs>();
ProjectFile[] targetFiles = project.GetTargetLanguageFiles(new Language(CultureInfo.GetCultureInfo(locale)));
AutomaticTask analyzeTask = project.RunAutomaticTask(
targetFiles.GetIds(),
AutomaticTaskTemplateIds.AnalyzeFiles);
CheckEvents(taskStatusEventArgsList, messageEventArgsList);
#region "SaveAnalysisReport"
Guid reportId = analyzeTask.Reports[0].Id;
project.SaveTaskReportAs(reportId, @"C:\ProjectFiles\Analysis_report.xls", ReportFormat.Excel);
#endregion
AutomaticTask translateTask = project.RunAutomaticTask(
targetFiles.GetIds(),
AutomaticTaskTemplateIds.PreTranslateFiles);
CheckEvents(taskStatusEventArgsList, messageEventArgsList);
AutomaticTask projectTmTask = project.RunAutomaticTask(
targetFiles.GetIds(),
AutomaticTaskTemplateIds.PopulateProjectTranslationMemories);
CheckEvents(taskStatusEventArgsList, messageEventArgsList);
}
public void PrepareFiles(FileBasedProject project)
{
#region "EventArgs"
List <TaskStatusEventArgs> taskStatusEventArgsList = new List <TaskStatusEventArgs>();
List <MessageEventArgs> messageEventArgsList = new List <MessageEventArgs>();
#endregion
ProjectFile[] sourceFiles = project.GetSourceLanguageFiles();
for (int i = 0; i < sourceFiles.Length; i++)
{
if (sourceFiles[i].Role == FileRole.Translatable)
{
Guid[] fileId = { sourceFiles[i].Id };
AutomaticTask convertTask = project.RunAutomaticTask(
fileId,
AutomaticTaskTemplateIds.ConvertToTranslatableFormat);
CheckEvents(taskStatusEventArgsList, messageEventArgsList);
AutomaticTask copyTask = project.RunAutomaticTask(
fileId,
AutomaticTaskTemplateIds.CopyToTargetLanguages);
CheckEvents(taskStatusEventArgsList, messageEventArgsList);
}
}
ProcessTargetLanguageFilesExtended(project, "de-DE");
ProcessTargetLanguageFilesExtended(project, "fr-FR");
}
public void ProcessTargetLanguageFiles(FileBasedProject project, string locale)
{
#region "PerfectMatchSetupAndTask"
Language targetLanguage = new Language(CultureInfo.GetCultureInfo(locale));
ProjectFile[] targetFiles = project.GetTargetLanguageFiles(targetLanguage);
project.AddBilingualReferenceFiles(GetBilingualFileMappings(new Language[] { targetLanguage }, targetFiles, @"c:\ProjectFiles\PreviousProjectFiles"));
AutomaticTask perfectMatchTask = project.RunAutomaticTask(
targetFiles.GetIds(),
AutomaticTaskTemplateIds.PerfectMatch);
#endregion
AutomaticTask analzyeTask = project.RunAutomaticTask(
targetFiles.GetIds(),
AutomaticTaskTemplateIds.AnalyzeFiles);
AutomaticTask translateTask = project.RunAutomaticTask(
targetFiles.GetIds(),
AutomaticTaskTemplateIds.PreTranslateFiles);
AutomaticTask projectTmTask = project.RunAutomaticTask(
targetFiles.GetIds(),
AutomaticTaskTemplateIds.PopulateProjectTranslationMemories);
}
public List <AutomaticTask> automaticTaskExecutionList()
{
List <AutomaticTask> automaticTasks = new List <AutomaticTask>();
using (DbConnection cn = b.CreateConnection())
{
using (DbCommand cmd = b.CreateCommand(cn))
{
cmd.CommandText = "wfSP_GET_AUTOMATIC_TASK_EXECUTION_LIST";
cmd.CommandType = CommandType.StoredProcedure;
cn.Open();
using (DbDataReader reader = b.ExecuteReader(cmd))
{
while (reader.Read())
{
AutomaticTask at = new AutomaticTask();
at.CodAutomaticTaskExecution = Util.Parse.ToInt(reader["CodAutomaticTaskExecution"]);
at.CodTask = Util.Parse.ToInt(reader["CodTask"]);
at.CodUser = Util.Parse.ToInt(reader["CodUser"]);
automaticTasks.Add(at);
}
}
return(automaticTasks);
}
}
}
public void PrepareFilesSimplified(FileBasedProject project)
{
#region "GetSourceLanguageFiles"
ProjectFile[] sourceFiles = project.GetSourceLanguageFiles();
#endregion
#region "ProcessSourceFiles"
for (int i = 0; i < sourceFiles.Length; i++)
{
if (sourceFiles[i].Role == FileRole.Translatable)
{
Guid[] fileId = { sourceFiles[i].Id };
AutomaticTask convertTask = project.RunAutomaticTask(
fileId,
AutomaticTaskTemplateIds.ConvertToTranslatableFormat);
AutomaticTask copyTask = project.RunAutomaticTask(
fileId,
AutomaticTaskTemplateIds.CopyToTargetLanguages);
}
}
#endregion
#region "ProcessTargetFiles"
ProcessTargetLanguageFiles(project, "de-DE");
ProcessTargetLanguageFiles(project, "fr-FR");
#endregion
}
public string CreateProject()
{
#region "ProjectSetupInformation"
ProjectInfo info = this.GetProjectInfo();
#endregion
#region "newProject"
FileBasedProject newProject = new FileBasedProject(info);
#endregion
#region "AddFiles"
ProjectFile[] files = newProject.AddFiles(this.AddProjectFiles(@"c:\ProjectFiles\Documents\"));
#endregion
#region "SetUpPerfectMatch"
newProject.AddBilingualReferenceFiles(GetBilingualFileMappings(info.TargetLanguages, files, @"c:\ProjectFiles\PreviousProjectFiles"));
#endregion
#region "ScanFiles"
AutomaticTask scanFiles = newProject.RunAutomaticTask(
newProject.GetSourceLanguageFiles().GetIds(),
AutomaticTaskTemplateIds.Scan);
#endregion
#region "CallSetFileRole"
this.SetFileRole(newProject, "brochure.pdf", FileRole.Reference);
this.SetFileRole(newProject, "options.jpg", FileRole.Localizable);
#endregion
#region "Tms"
this.AddMasterTMs(newProject, @"c:\ProjectFiles\TMs\");
#endregion
#region "Termbase"
this.AddTermbase(newProject, @"c:\ProjectFiles\Termbase\Software.sdltb");
#endregion
#region "PrepareProject"
this.PrepareFiles(newProject);
#endregion
////ProjectFile[] files = newProject.GetSourceLanguageFiles();
////UpdateFile(newProject, files[0].Id, @"c:\update\sample01.doc");
#region "SaveProject"
newProject.Save();
#endregion
ProjectPackage pack = new ProjectPackage();
pack.CreatePackage(newProject, @"c:\ProjectFiles\project_package.sdlppx");
TmSettings set = new TmSettings();
set.ConfigureTmSettings(newProject);
newProject.Save();
this.GetProjectStatistics(newProject);
return(newProject.FilePath);
}
/// <summary>
/// Runs the two automatic tasks: Convert translatable files to a translatable format (i.e. SDL XLIFF)
/// and creates target file copies.
/// </summary>
private void ConvertFiles(FileBasedProject project)
{
#region "GetFilesForProcessing"
ProjectFile[] files = project.GetSourceLanguageFiles();
#endregion
#region "RunConversion"
for (int i = 0; i < project.GetSourceLanguageFiles().Length; i++)
{
if (files[i].Role == FileRole.Translatable)
{
Guid[] currentFileId = { files[i].Id };
AutomaticTask convertTask = project.RunAutomaticTask(
currentFileId,
AutomaticTaskTemplateIds.ConvertToTranslatableFormat);
#region "CopyToTarget"
AutomaticTask copyTask = project.RunAutomaticTask(
currentFileId,
AutomaticTaskTemplateIds.CopyToTargetLanguages);
#endregion
}
}
#endregion
}
public void RunTranslationCount(FileBasedProject project, string trgLocale)
{
ProjectFile[] deFiles = project.GetTargetLanguageFiles(new Language(CultureInfo.GetCultureInfo(trgLocale)));
AutomaticTask translationCountTask = project.RunAutomaticTask(
deFiles.GetIds(),
AutomaticTaskTemplateIds.TranslationCount);
}
private void TestFiles(ProjectFile projectFile)
{
var failed = false;
var settings = GetSetting <ExportFilesSettings>();
// Store current settings so they can be restored later
var exportLocation = settings.GetSetting <string>("ExportLocation");
var fileVersion = settings.GetSetting <ExportFileVersion>("ExportFileVersion");
settings.BeginEdit();
settings.GetSetting <string>("ExportLocation").Value = backupPath;
settings.GetSetting <ExportFileVersion>("ExportFileVersion").Value = ExportFileVersion.Native;
settings.EndEdit();
AutomaticTask task = null;
try
{
task = Project.RunAutomaticTask(new[] { projectFile.Id }, AutomaticTaskTemplateIds.ExportFiles);
}
catch (Exception e)
{
failed = true;
root.Add(new XElement("Result",
new XAttribute("Name", projectFile.Name),
new XAttribute("Failed", true),
e.ToString()));
}
finally
{
// Restore
settings.BeginEdit();
settings.GetSetting <string>("ExportLocation").Value = exportLocation;
settings.GetSetting <ExportFileVersion>("ExportFileVersion").Value = fileVersion;
settings.EndEdit();
}
if (!failed && (task.Status != TaskStatus.Failed))
{
root.Add(new XElement("Result",
new XAttribute("Name", projectFile.Name),
new XAttribute("Failed", false)));
}
else
{
root.Add(new XElement("Result",
new XAttribute("Name", projectFile.Name),
new XAttribute("Failed", true),
FormatMessage(task?.Messages)));
errorMsgReporter.StoreMessage(projectFile.Name, FormatMessage(task?.Messages));
}
}
/// <summary>
/// Adds the files from the specified folder to the project and sets the file use, e.g. translatable or reference.
/// </summary>
#region "AddFilesFunction"
private void AddFiles(FileBasedProject project, string folder, bool recursion)
#endregion
{
#region "AddFolderWithFiles"
project.AddFolderWithFiles(folder, recursion);
#endregion
#region "GetSourceLanguageFiles"
ProjectFile[] projectFiles = project.GetSourceLanguageFiles();
AutomaticTask scan = project.RunAutomaticTask(
projectFiles.GetIds(),
AutomaticTaskTemplateIds.Scan);
#endregion
}
/// <summary>
/// Runs the actual analyze files task on the SDL XLIFF target documents.
/// </summary>
private void RunFileAnalysis(FileBasedProject project, string trgLocale)
#endregion
{
#region "GetTargetLanguageFiles"
ProjectFile[] targetFiles = project.GetTargetLanguageFiles(new Language(CultureInfo.GetCultureInfo(trgLocale)));
#endregion
#region "RunAnalysis"
AutomaticTask analyzeTask = project.RunAutomaticTask(
targetFiles.GetIds(),
AutomaticTaskTemplateIds.AnalyzeFiles);
#endregion
#region "SetTaskId"
this.reportId = analyzeTask.Reports[0].Id;
#endregion
}
private static void RunFinetune(FileBasedProject testProject)
{
ISettingsBundle settings = testProject.GetSettings();
FinetuneBatchTaskSettings finetuneSettings = settings.GetSettingsGroup <FinetuneBatchTaskSettings>();
TranslateTaskSettings pretranslateSettings = settings.GetSettingsGroup <TranslateTaskSettings>();
/*pretranslateSettings.Finetune = true;
* pretranslateSettings.ExtractFuzzies = true;
* pretranslateSettings.FuzzyMaxResults = 5;
* pretranslateSettings.ExtractFillerUnits = true;
* pretranslateSettings.FuzzyMinPercentage = 60;
* pretranslateSettings.BatchTranslate = false;
* pretranslateSettings.AddFiskmoProvider = false;
* pretranslateSettings.ExtractConcordanceUnits = true;
* pretranslateSettings.MaxFinetuningSentences = 100000;
* pretranslateSettings.IncludePlaceholderTags = false;
* pretranslateSettings.IncludeTagPairs = false;*/
var finetuneTaskSettingsWindow = new FiskmoTranslationProvider.FinetuneWpfControl(finetuneSettings);
Window window = new Window
{
Title = "Finetune task settings",
Content = finetuneTaskSettingsWindow
};
window.ShowDialog();
testProject.UpdateSettings(settings);
AutomaticTask pretranslateTask = testProject.RunAutomaticTask(
testProject.GetTargetLanguageFiles().GetIds(),
AutomaticTaskTemplateIds.PreTranslateFiles);
AutomaticTask finetuneTask = testProject.RunAutomaticTask(
testProject.GetTargetLanguageFiles().GetIds(),
"FiskmoBatchTask");
testProject.Save();
}
private AutomaticTask RunTasks(
FileBasedProject createdProject,
ProjectFile[] projectFiles,
string taskIDToRun,
List <TaskStatusEventArgs> taskStatusEventArgsList,
List <MessageEventArgs> messageEventArgsList)
{
AutomaticTask task = createdProject.RunAutomaticTask(
projectFiles.GetIds(),
taskIDToRun,
(sender, taskStatusArgs) =>
{
taskStatusEventArgsList.Add(taskStatusArgs);
},
(sender, messageArgs) =>
{
messageEventArgsList.Add(messageArgs);
});
return(task);
}
private static FileBasedProject CreateProject(string tmPath, FileInfo sourceFile, Language sourceLang, Language targetLang)
{
ProjectInfo info = new ProjectInfo();
info.SourceLanguage = sourceLang;
info.TargetLanguages = new Language[] { targetLang };
info.LocalProjectFolder = Path.Combine(
sourceFile.DirectoryName,
Path.GetFileNameWithoutExtension(sourceFile.FullName));
info.Name = Path.GetFileNameWithoutExtension(sourceFile.FullName);
FileBasedProject newProject = new FileBasedProject(info);
TranslationProviderConfiguration tmConfig = newProject.GetTranslationProviderConfiguration();
tmConfig.Entries.Add(new TranslationProviderCascadeEntry(tmPath, false, true, true));
newProject.UpdateTranslationProviderConfiguration(tmConfig);
newProject.AddFiles(new string[] { sourceFile.FullName });
AutomaticTask scanFiles = newProject.RunAutomaticTask(
newProject.GetSourceLanguageFiles().GetIds(),
AutomaticTaskTemplateIds.Scan);
AutomaticTask convertFiles = newProject.RunAutomaticTask(
newProject.GetSourceLanguageFiles().GetIds(),
AutomaticTaskTemplateIds.ConvertToTranslatableFormat);
AutomaticTask copyFiles = newProject.RunAutomaticTask(
newProject.GetSourceLanguageFiles().GetIds(),
AutomaticTaskTemplateIds.CopyToTargetLanguages);
newProject.Save();
return(newProject);
}
void ServerPuttingItAllTogether()
{
const string tmServerPrefix = "sdltm.";
string localcopylocation = @"C:\Projects\";
string serverName = "http://myServerAddress:80";
Uri serverAddress = new Uri(serverName);
string organizationPath = "/MyOrganizationPath";
ProjectServer server = new ProjectServer(serverAddress, false, "MyUser", "MyPassword");
ServerProjectInfo projectInfo = server.GetServerProject("/MyOrganization/MyProject");
FileBasedProject project;
if (projectInfo != null)
{
project = server.OpenProject(projectInfo.ProjectId, localcopylocation + projectInfo.Name);
ProjectFile[] sourceFiles = project.GetSourceLanguageFiles();
project.UndoCheckoutFiles(sourceFiles.GetIds());
//Add a server based translation provider
Uri tmAddress = new Uri(String.Format("{0}{1}{2}/{3}", tmServerPrefix, serverAddress, organizationPath, "UnitTestTm"));
TranslationProviderConfiguration tmConfig = project.GetTranslationProviderConfiguration();
tmConfig.Entries.Add
(
new TranslationProviderCascadeEntry
(
new TranslationProviderReference(tmAddress),
true,
true,
true,
0
)
);
//The credentials for a server based TM are keyed to the server address without path or tm name
project.Credentials.AddCredential(serverAddress, "user=sa;password=sa;type=CustomUser");
project.UpdateTranslationProviderConfiguration(tmConfig);
List <TaskStatusEventArgs> taskStatusEventArgsList = new List <TaskStatusEventArgs>();
List <MessageEventArgs> messageEventArgsList = new List <MessageEventArgs>();
// Run tasks for source files to create target files
AutomaticTask scanTask = project.RunAutomaticTask(
sourceFiles.GetIds(),
AutomaticTaskTemplateIds.Scan,
(sender, taskStatusArgs) => taskStatusEventArgsList.Add(taskStatusArgs),
(sender, messageArgs) => messageEventArgsList.Add(messageArgs));
AutomaticTask convertTask = project.RunAutomaticTask(
sourceFiles.GetIds(),
AutomaticTaskTemplateIds.ConvertToTranslatableFormat,
(sender, taskStatusArgs) => taskStatusEventArgsList.Add(taskStatusArgs),
(sender, messageArgs) => messageEventArgsList.Add(messageArgs));
AutomaticTask copyToTargetTask = project.RunAutomaticTask(
sourceFiles.GetIds(),
AutomaticTaskTemplateIds.CopyToTargetLanguages,
(sender, taskStatusArgs) => taskStatusEventArgsList.Add(taskStatusArgs),
(sender, messageArgs) => messageEventArgsList.Add(messageArgs));
// Run tasks for target files
ProjectFile[] targetFiles = project.GetTargetLanguageFiles();
AutomaticTask perfectMatchTask = project.RunAutomaticTask(
targetFiles.GetIds(),
AutomaticTaskTemplateIds.PerfectMatch,
(sender, taskStatusArgs) => taskStatusEventArgsList.Add(taskStatusArgs),
(sender, messageArgs) => messageEventArgsList.Add(messageArgs));
AutomaticTask analyseTask = project.RunAutomaticTask(
targetFiles.GetIds(),
AutomaticTaskTemplateIds.AnalyzeFiles,
(sender, taskStatusArgs) => taskStatusEventArgsList.Add(taskStatusArgs),
(sender, messageArgs) => messageEventArgsList.Add(messageArgs));
AutomaticTask preTranslateTask = project.RunAutomaticTask(
targetFiles.GetIds(),
AutomaticTaskTemplateIds.PreTranslateFiles,
(sender, taskStatusArgs) => taskStatusEventArgsList.Add(taskStatusArgs),
(sender, messageArgs) => messageEventArgsList.Add(messageArgs));
AutomaticTask populateProjTmTask = project.RunAutomaticTask(
targetFiles.GetIds(),
AutomaticTaskTemplateIds.PopulateProjectTranslationMemories,
(sender, taskStatusArgs) => taskStatusEventArgsList.Add(taskStatusArgs),
(sender, messageArgs) => messageEventArgsList.Add(messageArgs));
//Check in the new target files
targetFiles = project.GetTargetLanguageFiles();
project.CheckinFiles(targetFiles.GetIds(), "Target Files Created and Pre-translated", null);
//Save the project back to disk
project.Save();
}
}
/// <summary>
///
/// </summary>
/// <param name="createdProject">A project you have created</param>
/// <param name="settings">Settings containing initial input parameters</param>
private void RunTasks(FileBasedProject createdProject, LocalProjectSettings settings)
{
Language targetLanguage = new Language(settings.TargetLanguage);
List <TaskStatusEventArgs> taskStatusEventArgsList = new List <TaskStatusEventArgs>();
List <MessageEventArgs> messageEventArgsList = new List <MessageEventArgs>();
// set up perfect match
ProjectFile[] projectFiles = createdProject.GetSourceLanguageFiles();
createdProject.AddBilingualReferenceFiles(GetBilingualFileMappings(new Language[] { targetLanguage }, projectFiles, settings.PreviousVersionPath));
// scan files
AutomaticTask automaticTask = this.RunTasks(
createdProject,
projectFiles,
AutomaticTaskTemplateIds.Scan,
taskStatusEventArgsList,
messageEventArgsList);
this.CheckEvents(taskStatusEventArgsList, messageEventArgsList);
// convert files
automaticTask = this.RunTasks(
createdProject,
projectFiles,
AutomaticTaskTemplateIds.ConvertToTranslatableFormat,
taskStatusEventArgsList,
messageEventArgsList);
this.CheckEvents(taskStatusEventArgsList, messageEventArgsList);
// copy files to target languages
automaticTask = this.RunTasks(
createdProject,
projectFiles,
AutomaticTaskTemplateIds.CopyToTargetLanguages,
taskStatusEventArgsList,
messageEventArgsList);
this.CheckEvents(taskStatusEventArgsList, messageEventArgsList);
// from now on use target language files
projectFiles = createdProject.GetTargetLanguageFiles(targetLanguage);
// Apply Perfect Match
automaticTask = this.RunTasks(
createdProject,
projectFiles,
AutomaticTaskTemplateIds.PerfectMatch,
taskStatusEventArgsList,
messageEventArgsList);
this.CheckEvents(taskStatusEventArgsList, messageEventArgsList);
// analyze files
automaticTask = this.RunTasks(
createdProject,
projectFiles,
AutomaticTaskTemplateIds.AnalyzeFiles,
taskStatusEventArgsList,
messageEventArgsList);
this.CheckEvents(taskStatusEventArgsList, messageEventArgsList);
// translate files
automaticTask = this.RunTasks(
createdProject,
projectFiles,
AutomaticTaskTemplateIds.PreTranslateFiles,
taskStatusEventArgsList,
messageEventArgsList);
this.CheckEvents(taskStatusEventArgsList, messageEventArgsList);
// populate project TM
automaticTask = this.RunTasks(
createdProject,
projectFiles,
AutomaticTaskTemplateIds.PopulateProjectTranslationMemories,
taskStatusEventArgsList,
messageEventArgsList);
this.CheckEvents(taskStatusEventArgsList, messageEventArgsList);
}
