private void AddMasterTM(FileBasedProject createdProject, string pathToTM)
{
TranslationProviderConfiguration config = createdProject.GetTranslationProviderConfiguration();
config.Entries.Add(this.GetTranslationProviderCascadeEntry(pathToTM));
createdProject.UpdateTranslationProviderConfiguration(config);
}
private IProject PrepareStudioProject(PackageModel transitPackage)
{
var target = _fileService.GetStudioTargetLanguages(transitPackage.LanguagePairs);
Directory.CreateDirectory(transitPackage.Location); //if the location is set using project template feature this folder does not exist
var projectInfo = new ProjectInfo
{
Name = transitPackage.Name,
LocalProjectFolder = transitPackage.Location,
SourceLanguage = new Language(transitPackage.LanguagePairs[0].SourceLanguage),
TargetLanguages = target,
DueDate = transitPackage.DueDate,
ProjectOrigin = Resources.ProjectOrigin,
IconPath = _iconPath
};
var newProject = CreateNewProject(projectInfo, new ProjectTemplateReference(transitPackage.ProjectTemplate.Uri));
if (transitPackage.Customer != null)
{
((FileBasedProject)newProject).SetCustomer(transitPackage.Customer);
}
//Add StarTransit package source files. The same on all language pairs
newProject.AddFiles(transitPackage.LanguagePairs[0].SourceFile.ToArray());
//set the file role(user to display project details in Studio view)
var sourceFilesIds = newProject.GetSourceLanguageFiles().GetIds();
newProject.SetFileRole(sourceFilesIds, FileRole.Translatable);
_tmConfig = newProject.GetTranslationProviderConfiguration();
return(newProject);
}
/// <summary>
/// Add a server TM to be used for anaysis. The project languages are
/// set according to the TM.
/// </summary>
private void AddServerTm(FileBasedProject project, string serverAddress, string organizationPath, string tmName, bool useWindowsSecurity, string username, string password)
#endregion
{
#region "TranslationProviderConfiguration"
Uri tmAddress = new Uri(String.Format("sdltm.{1}{2}/{3}", serverAddress, organizationPath, tmName));
TranslationProviderConfiguration config = project.GetTranslationProviderConfiguration();
#endregion
#region "TranslationProviderCascadeEntryForServerTM"
TranslationProviderCascadeEntry tm = new TranslationProviderCascadeEntry
(
new TranslationProviderReference(tmAddress),
true,
false,
false
);
config.Entries.Add(tm);
project.UpdateTranslationProviderConfiguration(config);
#endregion
#region "CredentialsForServerTm"
project.Credentials.AddCredential(new Uri(serverAddress), String.Format("user={0};password={1};type=CustomUser", username, password, useWindowsSecurity ? "WindowsUser" : "CustomUser"));
project.UpdateTranslationProviderConfiguration(config);
#endregion
}
public MessageModel CreateProject(PackageModel package)
{
_messageModel = new MessageModel();
try
{
_penaltiesTmsList = new List <StarTranslationMemoryMetadata>();
_machineTransList = new List <StarTranslationMemoryMetadata>();
_tmConfig = new TranslationProviderConfiguration();
var target = GetTargetLanguages(package.LanguagePairs);
var projectInfo = new ProjectInfo
{
Name = package.Name,
LocalProjectFolder = package.Location,
SourceLanguage = new Language(package.LanguagePairs[0].SourceLanguage),
TargetLanguages = target,
DueDate = package.DueDate
};
var newProject = new FileBasedProject(projectInfo, new ProjectTemplateReference(package.ProjectTemplate.Uri));
if (package.Customer != null)
{
newProject.SetCustomer(package.Customer);
}
//Add StarTransit package source files. The same on all language pairs
var sourceProjectFiles = newProject.AddFiles(package.LanguagePairs[0].SourceFile.ToArray());
//set the file role(user to display project details in Studio view)
var sourceFilesIds = newProject.GetSourceLanguageFiles().GetIds();
newProject.SetFileRole(sourceFilesIds, FileRole.Translatable);
_tmConfig = newProject.GetTranslationProviderConfiguration();
_fileTypeManager = DefaultFileTypeManager.CreateInstance(true);
var targetProjectFiles = new List <ProjectFile>();
_messageModel = SetLanguagePairInformation(newProject, package, targetProjectFiles);
if (_messageModel is null || !_messageModel.IsProjectCreated)
{
if (Directory.Exists(Path.GetDirectoryName(newProject.FilePath)))
{
CreateMetadataFolder(package.Location, package.PathToPrjFile);
Controller.RefreshProjects();
}
_messageModel.IsProjectCreated = true;
_messageModel.Message = "Project was successfully created!";
_messageModel.Title = "Informative message";
}
}
catch (Exception ex)
{
Log.Logger.Error($"CreateModel method: {ex.Message}\n {ex.StackTrace}");
return(null);
}
return(_messageModel);
}
public MessageModel CreateProject(PackageModel package)
{
try
{
var target = GetTargetLanguages(package.LanguagePairs);
var projectInfo = new ProjectInfo
{
Name = package.Name,
LocalProjectFolder = package.Location,
SourceLanguage = new Language(package.LanguagePairs[0].SourceLanguage),
TargetLanguages = target,
DueDate = package.DueDate,
ProjectOrigin = "Star Transit project",
IconPath = _iconPath
};
var newProject = CreateNewProject(projectInfo, new ProjectTemplateReference(package.ProjectTemplate.Uri));
if (package.Customer != null)
{
((FileBasedProject)newProject).SetCustomer(package.Customer);
}
//Add StarTransit package source files. The same on all language pairs
newProject.AddFiles(package.LanguagePairs[0].SourceFile.ToArray());
//set the file role(user to display project details in Studio view)
var sourceFilesIds = newProject.GetSourceLanguageFiles().GetIds();
newProject.SetFileRole(sourceFilesIds, FileRole.Translatable);
_tmConfig = newProject.GetTranslationProviderConfiguration();
_messageModel = SetLanguagePairInformation(newProject, package);
if (_messageModel is null || _messageModel.Message is null)
{
if (Directory.Exists(newProject?.GetProjectInfo()?.LocalProjectFolder))
{
CreateMetadataFolder(package.Location, package.PathToPrjFile);
_projectsController?.RefreshProjects();
}
if (_messageModel != null)
{
_messageModel.IsProjectCreated = true;
_messageModel.Message = "Project was successfully created!";
_messageModel.Title = "Informative message";
}
}
}
catch (Exception ex)
{
Log.Logger.Error($"CreateModel method: {ex.Message}\n {ex.StackTrace}");
return(null);
}
return(_messageModel);
}
public ProjectService()
{
_fileService = new FileService();
_messageModel = new MessageModel();
_penaltiesTmsList = new List <StarTranslationMemoryMetadata>();
_machineTransList = new List <StarTranslationMemoryMetadata>();
_tmConfig = new TranslationProviderConfiguration();
_targetProjectFiles = new List <ProjectFile>();
}
public ProjectService()
{
_fileService = new FileService();
_messageModel = new MessageModel();
_tmConfig = new TranslationProviderConfiguration();
var studioVersion = new StudioVersionService().GetStudioVersion();
_initialFolderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), studioVersion.StudioDocumentsFolderName, "Translation Memories");
}
/// <summary>
/// Validates the translation provider configuration.
/// </summary>
/// <param name="providerConfig">The provider configuration.</param>
private void ValidateTranslationProviderConfiguration(TranslationProviderConfiguration providerConfig)
{
foreach (TranslationProviderCascadeEntry entry in providerConfig.Entries)
{
if (entry.PerformUpdate && !entry.PerformNormalSearch)
{
entry.PerformNormalSearch = true;
}
}
}
public void Execute()
{
var projectInfo = new ProjectInfo
{
Name = "TestProject",
SourceLanguage = new Language(CultureInfo.GetCultureInfo("en-US")), //import Sdl.core.globalization.dll
TargetLanguages = new[] { new Language(CultureInfo.GetCultureInfo("de-DE")), },
//file path where you want to save the project
LocalProjectFolder = $@""
};
//import Sdl.ProjectAutomation.FileBased
var fileBasedProject = new FileBasedProject(projectInfo);
//HERE YOU NEED TO ADD THE PATH FOR FILES YOU WANT TO INCLUDE IN YOUR PROJECT
var filesPath = new[] { @"C" };
//add files to project
var projectFiles = fileBasedProject.AddFiles(filesPath);
//Translation provider configuration
var translationProviderConfig = new TranslationProviderConfiguration();
var entry = new TranslationProviderCascadeEntry(
@"En-DeTM.sdltm", true, true, true);
translationProviderConfig.Entries.Add(entry);
fileBasedProject.UpdateTranslationProviderConfiguration(translationProviderConfig);
//we need to run automatic task to create the project in studio
fileBasedProject.RunAutomaticTask(projectFiles.GetIds(), AutomaticTaskTemplateIds.Scan);
var taskSequence = fileBasedProject.RunAutomaticTasks(projectFiles.GetIds(),
new[]
{
AutomaticTaskTemplateIds.ConvertToTranslatableFormat,
AutomaticTaskTemplateIds.CopyToTargetLanguages, AutomaticTaskTemplateIds.PerfectMatch,
AutomaticTaskTemplateIds.PreTranslateFiles,
});
if (taskSequence.Status == TaskStatus.Completed)
{
//project was created succesfully
}
else
{
if (taskSequence.Status.Equals(TaskStatus.Failed))
{
foreach (var subTask in taskSequence.SubTasks)
{
}
}
}
fileBasedProject.Save();
}
public ProjectService(IFileTypeManager fileTypeManager, Helpers helpers)
{
_fileTypeManager = fileTypeManager;
if (helpers != null)
{
_projectsController = helpers.GetProjectsController();
_iconPath = string.IsNullOrEmpty(_iconPath) ? helpers.GetIconPath() : _iconPath;
}
_messageModel = new MessageModel();
_penaltiesTmsList = new List <StarTranslationMemoryMetadata>();
_machineTransList = new List <StarTranslationMemoryMetadata>();
_tmConfig = new TranslationProviderConfiguration();
_targetProjectFiles = new List <ProjectFile>();
}
public void AddBeglobalEnterpriseMT(FileBasedProject project, string host, string port, string accountid, string apiKey, string touchpointId, string userId)
{
Uri uri = new Uri(String.Format(@"languageweavermt.https://{0}-{1}@{2}:{3}/aspmodel=REST&touchpointId={4}", accountid, userId, host, port, touchpointId));
TranslationProviderConfiguration tmConfig = project.GetTranslationProviderConfiguration();
tmConfig.Entries.Add
(
new TranslationProviderCascadeEntry
(
new TranslationProviderReference(uri), false, true, true, 0
)
);
project.Credentials.AddCredential(uri, apiKey);
project.UpdateTranslationProviderConfiguration(tmConfig);
}
public void AddFileBasedTMWithPassword(FileBasedProject project, string pathIncludingFileName, string password)
{
Uri uri = new Uri(String.Concat("sdltm.file://", pathIncludingFileName));
TranslationProviderConfiguration tmConfig = project.GetTranslationProviderConfiguration();
tmConfig.Entries.Add
(
new TranslationProviderCascadeEntry
(
new TranslationProviderReference(uri), true, true, true, 0
)
);
project.Credentials.AddCredential(uri, password);
project.UpdateTranslationProviderConfiguration(tmConfig);
}
public void AddBeglobalCommunityMT(FileBasedProject project)
{
TranslationProviderConfiguration tmConfig = project.GetTranslationProviderConfiguration();
Uri BeGlobalCommunityUri = new Uri("beglobalcommunity://");
tmConfig.Entries.Add
(
new TranslationProviderCascadeEntry
(
new TranslationProviderReference(BeGlobalCommunityUri), false, true, true, 0
)
);
project.UpdateTranslationProviderConfiguration(tmConfig);
}
/// <summary>
/// Merges the translation providers.
/// </summary>
/// <param name="sourceProviderConfig">The source provider configuration.</param>
/// <param name="targetProviderConfig">The target provider configuration.</param>
private void MergeTranslationProviders(TranslationProviderConfiguration sourceProviderConfig, TranslationProviderConfiguration targetProviderConfig)
{
// Remember where we're going to insert the translation providers
int indexToInsert = 0;
// Look at each translation provider in the source project
foreach (TranslationProviderCascadeEntry sourceCascadeEntry in sourceProviderConfig.Entries)
{
// See if we can match the translation provider to one already there
bool foundEntry = targetProviderConfig.Entries.Any(targetCascadeEntry => sourceCascadeEntry.MainTranslationProvider.Uri == targetCascadeEntry.MainTranslationProvider.Uri);
// If we didn't find the translation provider then add a new one to the target project
if (!foundEntry)
{
targetProviderConfig.Entries.Insert(indexToInsert++, sourceCascadeEntry);
}
}
}
/// <summary>
/// Adds the TM that should be used for the analysis. The project languages are
/// set according to the TM.
/// </summary>
#region "AddTmFunction"
private void AddTm(FileBasedProject project, string tmFilePath)
#endregion
{
#region "TranslationProviderConfiguration"
TranslationProviderConfiguration config = project.GetTranslationProviderConfiguration();
#endregion
#region "TranslationProviderCascadeEntry"
TranslationProviderCascadeEntry tm = new TranslationProviderCascadeEntry(
tmFilePath,
true,
true,
false);
config.Entries.Add(tm);
project.UpdateTranslationProviderConfiguration(config);
#endregion
}
private void AddServerBasedTM(FileBasedProject project, Uri uri, string path, string tmname)
{
TranslationProviderConfiguration tmConfig = project.GetTranslationProviderConfiguration();
tmConfig.Entries.Add
(
new TranslationProviderCascadeEntry
(
new TranslationProviderReference(new Uri(String.Format("{0}{1}/{2}", uri, path, tmname))),
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(uri, "user=myuser;password=mypassword;type=CustomUser");
project.UpdateTranslationProviderConfiguration(tmConfig);
}
public void AddGoogleMT(FileBasedProject project, string apiKey)
{
Uri GoogleUri = new Uri("googlemt://");
TranslationProviderConfiguration tmConfig = project.GetTranslationProviderConfiguration();
tmConfig.Entries.Add
(
new TranslationProviderCascadeEntry
(
new TranslationProviderReference(GoogleUri), false, true, true, 0
)
);
//Add the Google Api key. To get an Api Key you will need to sign up with Google for the
//Google Translate API V2 service.
project.Credentials.AddCredential(GoogleUri, apiKey);
project.UpdateTranslationProviderConfiguration(tmConfig);
}
public void AddMasterTMs(FileBasedProject project, string path)
{
#region "TranslationProviderConfiguration"
Language trgLangDe = new Language(CultureInfo.GetCultureInfo("de-DE"));
Language trgLangFr = new Language(CultureInfo.GetCultureInfo("fr-FR"));
TranslationProviderConfiguration tmConfigEnDe = project.GetTranslationProviderConfiguration(trgLangDe);
TranslationProviderConfiguration tmConfigEnFr = project.GetTranslationProviderConfiguration(trgLangFr);
#endregion
#region "ConfigureTms"
TranslationProviderCascadeEntry[] tmEntriesEnDe =
{
new TranslationProviderCascadeEntry(path + "Software En-De.sdltm", true, true, true, 0),
new TranslationProviderCascadeEntry(path + "General En-De.sdltm", true, true, true, 2),
};
TranslationProviderCascadeEntry[] tmEntriesEnFr =
{
new TranslationProviderCascadeEntry(path + "Software En-Fr.sdltm", true, true, true, 0),
new TranslationProviderCascadeEntry(path + "General En-Fr.sdltm", true, true, true, 2)
};
#endregion
#region "AddTmsAndUpdate"
for (int i = 0; i < tmEntriesEnDe.Length; i++)
{
tmConfigEnDe.Entries.Add(tmEntriesEnDe[i]);
}
for (int i = 0; i < tmEntriesEnFr.Length; i++)
{
tmConfigEnDe.Entries.Add(tmEntriesEnFr[i]);
}
project.UpdateTranslationProviderConfiguration(trgLangDe, tmConfigEnDe);
project.UpdateTranslationProviderConfiguration(trgLangFr, tmConfigEnFr);
#endregion
}
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>
/// Executes this instance.
/// </summary>
protected override void Execute()
{
string grammarCheckerSettingsId = "GrammarCheckerSettings";
string numberVerifierSettingsId = "NumberVerifierSettings";
IExtensionPoint globalVerifiersExtensionPoint = PluginManager.DefaultPluginRegistry.GetExtensionPoint <GlobalVerifierAttribute>();
foreach (IExtension extension in globalVerifiersExtensionPoint.Extensions)
{
IGlobalVerifier globalVerifier = (IGlobalVerifier)extension.CreateInstance();
string settingsGroupId = globalVerifier.SettingsId;
if (settingsGroupId.Contains("Grammar"))
{
grammarCheckerSettingsId = settingsGroupId;
}
if (settingsGroupId.Contains("Number"))
{
numberVerifierSettingsId = settingsGroupId;
}
}
// Show the dialog
ApplyTemplateForm applyTemplateForm = new ApplyTemplateForm(Controller);
if (applyTemplateForm.ShowDialog() == DialogResult.OK)
{
// This is the template that the user selected
ApplyTemplate selectedTemplate = applyTemplateForm.ActiveTemplate;
// Create list of projects
List <FileBasedProject> selectedProjects = new List <FileBasedProject>();
if (applyTemplateForm.ApplyToSelected)
{
selectedProjects.AddRange(Controller.SelectedProjects);
}
else
{
if (Controller.CurrentProject != null)
{
selectedProjects.Add(Controller.CurrentProject);
}
}
// Check if we have any projects
if (selectedProjects.Count == 0)
{
MessageBox.Show(applyTemplateForm.ApplyToSelected ? PluginResources.No_Projects_Selected : PluginResources.No_Current_Project, PluginResources.Plugin_Name, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// Work through all projects
StringBuilder projectsList = new StringBuilder();
projectsList.AppendLine(PluginResources.Settings_Applied);
foreach (FileBasedProject targetProject in selectedProjects)
{
// Temporary folder path
string tempFolder = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N"));
// This is the current project and it's related information
ProjectInfo targetProjectInfo = targetProject.GetProjectInfo();
projectsList.AppendLine(targetProjectInfo.Name);
ISettingsBundle targetSettingsBundle = targetProject.GetSettings();
// This is the source project - check if it's a loaded one
FileBasedProject sourceProject = Controller.GetAllProjects().FirstOrDefault(loadedProject => String.Compare(loadedProject.FilePath, selectedTemplate.FileLocation, StringComparison.OrdinalIgnoreCase) == 0);
// Not found so load it from the filing system
if (sourceProject == null)
{
if (string.IsNullOrEmpty(selectedTemplate.FileLocation))
{
if (selectedTemplate.Id != Guid.Empty)
{
// Create a new project based on a template configured in Studio
ProjectTemplateReference projectTemplate = new ProjectTemplateReference(selectedTemplate.Uri);
string savedFolder = targetProjectInfo.LocalProjectFolder;
targetProjectInfo.LocalProjectFolder = tempFolder;
sourceProject = new FileBasedProject(targetProjectInfo, projectTemplate);
targetProjectInfo.LocalProjectFolder = savedFolder;
}
}
else
{
if (Path.GetExtension(selectedTemplate.FileLocation).ToLowerInvariant() == ".sdltpl")
{
// Create a new project based on a file-based template
ProjectTemplateReference projectTemplate = new ProjectTemplateReference(selectedTemplate.FileLocation);
string savedFolder = targetProjectInfo.LocalProjectFolder;
targetProjectInfo.LocalProjectFolder = tempFolder;
sourceProject = new FileBasedProject(targetProjectInfo, projectTemplate);
targetProjectInfo.LocalProjectFolder = savedFolder;
}
else
{
// Load a project from the filing system
sourceProject = new FileBasedProject(selectedTemplate.FileLocation);
}
}
}
// Get the information from the source project
ProjectInfo sourceProjectInfo = sourceProject.GetProjectInfo();
ISettingsBundle sourceSettingsBundle = sourceProject.GetSettings();
// Copy all languages translation providers
if (selectedTemplate.TranslationProvidersAllLanguages != ApplyTemplateOptions.Keep)
{
try
{
// Update the "all languages" node
TranslationProviderConfiguration sourceProviderConfig = sourceProject.GetTranslationProviderConfiguration();
if (selectedTemplate.TranslationProvidersAllLanguages == ApplyTemplateOptions.Merge)
{
TranslationProviderConfiguration targetProviderConfig = targetProject.GetTranslationProviderConfiguration();
MergeTranslationProviders(sourceProviderConfig, targetProviderConfig);
ValidateTranslationProviderConfiguration(targetProviderConfig);
targetProject.UpdateTranslationProviderConfiguration(targetProviderConfig);
}
else
{
ValidateTranslationProviderConfiguration(sourceProviderConfig);
targetProject.UpdateTranslationProviderConfiguration(sourceProviderConfig);
}
}
catch (Exception e)
{
MessageBox.Show(e.Message, PluginResources.TPAL_Failed, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
// Copy language-specific translation providers
if (selectedTemplate.TranslationProvidersSpecificLanguages != ApplyTemplateOptions.Keep)
{
if (sourceProjectInfo.SourceLanguage.Equals(targetProjectInfo.SourceLanguage))
{
foreach (Language sourceTargetLanguage in sourceProjectInfo.TargetLanguages)
{
foreach (Language targetTargetLanguage in targetProjectInfo.TargetLanguages)
{
if (sourceTargetLanguage.Equals(targetTargetLanguage))
{
try
{
// Copy translation providers
TranslationProviderConfiguration sourceProviderConfig = sourceProject.GetTranslationProviderConfiguration(sourceTargetLanguage);
if (selectedTemplate.TranslationProvidersSpecificLanguages == ApplyTemplateOptions.Merge)
{
TranslationProviderConfiguration targetProviderConfig = targetProject.GetTranslationProviderConfiguration(targetTargetLanguage);
MergeTranslationProviders(sourceProviderConfig, targetProviderConfig);
ValidateTranslationProviderConfiguration(targetProviderConfig);
targetProject.UpdateTranslationProviderConfiguration(targetTargetLanguage, targetProviderConfig);
}
else
{
ValidateTranslationProviderConfiguration(sourceProviderConfig);
targetProject.UpdateTranslationProviderConfiguration(targetTargetLanguage, sourceProviderConfig);
}
}
catch (Exception e)
{
MessageBox.Show(e.Message, string.Format(PluginResources.TPSL_Failed, targetTargetLanguage.DisplayName), MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
}
}
}
}
// Copy TM settings for all languages
if (selectedTemplate.TranslationMemoriesAllLanguages == ApplyTemplateOptions.Overwrite)
{
try
{
// Update the translation memory filter settings
CopySettingsGroup(sourceSettingsBundle, targetSettingsBundle, "TranslationMemorySettings", targetProject, null);
}
catch (Exception e)
{
MessageBox.Show(e.Message, PluginResources.TMAL_Failed, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
// Copy TM settings for specific languages
if (selectedTemplate.TranslationMemoriesSpecificLanguages == ApplyTemplateOptions.Overwrite)
{
if (sourceProjectInfo.SourceLanguage.Equals(targetProjectInfo.SourceLanguage))
{
foreach (Language sourceTargetLanguage in sourceProjectInfo.TargetLanguages)
{
foreach (Language targetTargetLanguage in targetProjectInfo.TargetLanguages)
{
if (sourceTargetLanguage.Equals(targetTargetLanguage))
{
try
{
// Now copy translation memory settings - different section
ISettingsBundle sourceTmSettings = sourceProject.GetSettings(sourceTargetLanguage);
ISettingsBundle targetTmSettings = targetProject.GetSettings(targetTargetLanguage);
CopySettingsGroup(sourceTmSettings, targetTmSettings, "TranslationMemorySettings", targetProject, targetTargetLanguage);
}
catch (Exception e)
{
MessageBox.Show(e.Message, string.Format(PluginResources.TMSL_Failed, targetTargetLanguage.DisplayName), MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
}
}
}
}
// Copy terminology termbases
if (selectedTemplate.TerminologyTermbases != ApplyTemplateOptions.Keep)
{
TermbaseConfiguration sourceTermbaseConfig = sourceProject.GetTermbaseConfiguration();
TermbaseConfiguration targetTermbaseConfig = targetProject.GetTermbaseConfiguration();
if (selectedTemplate.TerminologyTermbases == ApplyTemplateOptions.Merge)
{
MergeTermbases(sourceTermbaseConfig, targetTermbaseConfig);
}
else
{
targetTermbaseConfig.TermbaseServerUri = sourceTermbaseConfig.TermbaseServerUri;
targetTermbaseConfig.Termbases.Clear();
targetTermbaseConfig.LanguageIndexes.Clear();
MergeTermbases(sourceTermbaseConfig, targetTermbaseConfig);
}
// Updating with zero termbases throws an exception
if (targetTermbaseConfig.Termbases.Count > 0)
{
try
{
targetProject.UpdateTermbaseConfiguration(targetTermbaseConfig);
}
catch (Exception e)
{
MessageBox.Show(e.Message, PluginResources.TBTB_Failed, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
}
// Copy terminology settings
if (selectedTemplate.TerminologySearchSettings == ApplyTemplateOptions.Overwrite)
{
TermbaseConfiguration sourceTermbaseConfig = sourceProject.GetTermbaseConfiguration();
TermbaseConfiguration targetTermbaseConfig = targetProject.GetTermbaseConfiguration();
targetTermbaseConfig.TermRecognitionOptions = sourceTermbaseConfig.TermRecognitionOptions;
// Updating with zero termbases throws an exception
if (targetTermbaseConfig.Termbases.Count > 0)
{
try
{
targetProject.UpdateTermbaseConfiguration(targetTermbaseConfig);
}
catch (Exception e)
{
MessageBox.Show(e.Message, PluginResources.TBSS_Failed, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
}
// Copy QA verification settings where applicable
if (selectedTemplate.VerificationQaChecker30 == ApplyTemplateOptions.Overwrite)
{
try
{
CopySettingsGroup(sourceSettingsBundle, targetSettingsBundle, "QAVerificationSettings", targetProject, null);
}
catch (Exception e)
{
MessageBox.Show(e.Message, PluginResources.QAQA_Failed, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
// Copy tag verification settings where applicable
if (selectedTemplate.VerificationTagVerifier == ApplyTemplateOptions.Overwrite)
{
try
{
CopySettingsGroup(sourceSettingsBundle, targetSettingsBundle, "SettingsTagVerifier", targetProject, null);
}
catch (Exception e)
{
MessageBox.Show(e.Message, PluginResources.QATG_Failed, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
// Copy term verification settings where applicable
if (selectedTemplate.VerificationTerminologyVerifier == ApplyTemplateOptions.Overwrite)
{
try
{
CopySettingsGroup(sourceSettingsBundle, targetSettingsBundle, "SettingsTermVerifier", targetProject, null);
}
catch (Exception e)
{
MessageBox.Show(e.Message, PluginResources.QATV_Failed, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
// Copy number verification settings where applicable
if (selectedTemplate.VerificationNumberVerifier == ApplyTemplateOptions.Overwrite)
{
try
{
CopySettingsGroup(sourceSettingsBundle, targetSettingsBundle, numberVerifierSettingsId, targetProject, null);
}
catch (Exception e)
{
MessageBox.Show(e.Message, PluginResources.QANV_Failed, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
// Copy grammar checking settings where applicable
if (selectedTemplate.VerificationGrammarChecker == ApplyTemplateOptions.Overwrite)
{
try
{
CopySettingsGroup(sourceSettingsBundle, targetSettingsBundle, grammarCheckerSettingsId, targetProject, null);
}
catch (Exception e)
{
MessageBox.Show(e.Message, PluginResources.QAGC_Failed, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
// Copy file type settings where applicable
if (selectedTemplate.FileTypes == ApplyTemplateOptions.Overwrite)
{
try
{
var copiedTypes = new List <string>();
foreach (ProjectFile projectFile in targetProject.GetTargetLanguageFiles())
{
if (!copiedTypes.Contains(projectFile.FileTypeId))
{
copiedTypes.Add(projectFile.FileTypeId);
CopySettingsGroup(sourceSettingsBundle, targetSettingsBundle, projectFile.FileTypeId, targetProject, null);
}
}
}
catch (Exception e)
{
MessageBox.Show(e.Message, PluginResources.FTTS_Failed, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
// Copy batch tasks settings where applicable
if (selectedTemplate.BatchTasksAllLanguages == ApplyTemplateOptions.Overwrite)
{
try
{
// Update the translation memory filter settings
CopySettingsGroup(sourceSettingsBundle, targetSettingsBundle, "PseudoTranslateSettings", targetProject, null);
CopySettingsGroup(sourceSettingsBundle, targetSettingsBundle, "AnalysisTaskSettings", targetProject, null);
CopySettingsGroup(sourceSettingsBundle, targetSettingsBundle, "VerificationSettings", targetProject, null);
CopySettingsGroup(sourceSettingsBundle, targetSettingsBundle, "TranslateTaskSettings", targetProject, null);
CopySettingsGroup(sourceSettingsBundle, targetSettingsBundle, "TranslationMemoryUpdateTaskSettings", targetProject, null);
}
catch (Exception e)
{
MessageBox.Show(e.Message, PluginResources.BTAL_Failed, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
if (selectedTemplate.BatchTasksSpecificLanguages == ApplyTemplateOptions.Overwrite)
{
// Update specific language pairs where possible
if (sourceProjectInfo.SourceLanguage.Equals(targetProjectInfo.SourceLanguage))
{
foreach (Language sourceTargetLanguage in sourceProjectInfo.TargetLanguages)
{
foreach (Language targetTargetLanguage in targetProjectInfo.TargetLanguages)
{
if (sourceTargetLanguage.Equals(targetTargetLanguage))
{
try
{
// Now copy translation memory settings - different section
ISettingsBundle sourceTmSettings = sourceProject.GetSettings(sourceTargetLanguage);
ISettingsBundle targetTmSettings = targetProject.GetSettings(targetTargetLanguage);
CopySettingsGroup(sourceTmSettings, targetTmSettings, "PseudoTranslateSettings", targetProject, targetTargetLanguage);
CopySettingsGroup(sourceTmSettings, targetTmSettings, "AnalysisTaskSettings", targetProject, targetTargetLanguage);
CopySettingsGroup(sourceTmSettings, targetTmSettings, "VerificationSettings", targetProject, targetTargetLanguage);
CopySettingsGroup(sourceTmSettings, targetTmSettings, "TranslateTaskSettings", targetProject, targetTargetLanguage);
CopySettingsGroup(sourceTmSettings, targetTmSettings, "TranslationMemoryUpdateTaskSettings", targetProject, targetTargetLanguage);
}
catch (Exception e)
{
MessageBox.Show(e.Message, string.Format(PluginResources.BTSL_Failed, targetTargetLanguage.DisplayName), MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
}
}
}
}
// Remove the temporary folder if it exists
if (Directory.Exists(tempFolder))
{
Directory.Delete(tempFolder, true);
}
// Use reflection to synch the project to the server
try
{
var project = typeof(FileBasedProject).GetField("_project", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(targetProject);
project.GetType().GetMethod("UpdateServerProjectSettings").Invoke(project, null);
}
catch
{
}
}
// Tell the user we're done
MessageBox.Show(projectsList.ToString(), PluginResources.Plugin_Name, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
// Save the project templates anyway
applyTemplateForm.SaveProjectTemplates();
}
