public void UpdateAnalysisTaskReportInfo(FileBasedProject project, AutomaticTask automaticTask)
{
try
{
_automaticTaskXml = BuildAutomaticTask(automaticTask);
string content;
using (var reader = new StreamReader(project.FilePath, Encoding.UTF8))
{
content = reader.ReadToEnd();
reader.Close();
}
var regexTasks = new Regex(@"(?<OpeningTag>\<Tasks\>)(?<Content>(.*|))(?<ClosingTag>\<\/Tasks\>)", RegexOptions.Singleline | RegexOptions.IgnoreCase);
var regexTasksMatch = regexTasks.Match(content);
if (regexTasksMatch.Success)
{
content = regexTasks.Replace(content, ReplaceReportInfo);
}
using (var writer = new StreamWriter(project.FilePath, false, Encoding.UTF8))
{
writer.Write(content);
writer.Flush();
writer.Close();
}
}
catch
{
// ignore catch all
}
}
public IateSettingsService()
{
var app = ApplicationHost <SdlTradosStudioApplication> .Application;
var projectsController = app.GetController <ProjectsController>();
_currentProject = projectsController.CurrentProject ?? projectsController.SelectedProjects.FirstOrDefault();
}
public void CreateReport(WizardContext wizardContext, string reportFile,
FileBasedProject selectedProject, string targetLanguageCode)
{
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = true,
Indent = false
};
var actionName = wizardContext.Action == Enumerators.Action.Export
? "Export"
: "Import";
var projectFiles = wizardContext.ProjectFiles.Where(a => a.Selected &&
string.Compare(a.TargetLanguage, targetLanguageCode,
StringComparison.CurrentCultureIgnoreCase) == 0).ToList();
using (var writer = XmlWriter.Create(reportFile, settings))
{
writer.WriteStartElement("task");
writer.WriteAttributeString("name", actionName);
writer.WriteAttributeString("created", wizardContext.DateTimeStampToString);
WriteReportTaskInfo(writer, wizardContext, selectedProject, targetLanguageCode);
foreach (var projectFile in projectFiles)
{
WriteReportFile(writer, wizardContext, projectFile);
}
WriteReportTotal(writer, wizardContext, projectFiles);
writer.WriteEndElement(); //task
}
}
public bool TryLoad(string cloudTag, FileBasedProject project, out List <IWord> words)
{
words = null;
string cacheFile = CreateCacheFilePath(cloudTag, project);
if (!File.Exists(cacheFile))
{
return(false);
}
try
{
XDocument doc = XDocument.Load(cacheFile);
int storedHash = Int32.Parse(doc.XPathSelectElement("/wordcloud/hash").Value);
int hash = GetWordCloudHash(project);
if (storedHash != hash)
{
return(false);
}
words = new List <IWord>();
foreach (XElement w in doc.XPathSelectElements("/wordcloud/words/word"))
{
words.Add(new Word {
Text = w.Attribute("text").Value, Occurrences = Int32.Parse(w.Attribute("count").Value)
});
}
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public void CreateTaskReport(TaskContext taskContext, string reportFile,
FileBasedProject selectedProject, string targetLanguageCode)
{
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = true,
Indent = false
};
var projectFiles = taskContext.ProjectFiles.Where(a => a.Selected &&
string.Compare(a.TargetLanguage, targetLanguageCode,
StringComparison.CurrentCultureIgnoreCase) == 0).ToList();
var reportName = "";
switch (taskContext.Action)
{
case Enumerators.Action.Convert:
reportName = "Create Transcreate Project Report";
break;
case Enumerators.Action.CreateBackTranslation:
reportName = "Create Back-Translation Project Report";
break;
case Enumerators.Action.Export:
reportName = "Export Translations Report";
break;
case Enumerators.Action.Import:
reportName = "Import Translations Report";
break;
case Enumerators.Action.ExportBackTranslation:
reportName = "Export Back-Translations Report";
break;
case Enumerators.Action.ImportBackTranslation:
reportName = "Import Back-Translations Report";
break;
}
using (var writer = XmlWriter.Create(reportFile, settings))
{
writer.WriteStartElement("task");
writer.WriteAttributeString("name", reportName);
writer.WriteAttributeString("created", taskContext.DateTimeStampToString);
WriteReportTaskInfo(writer, taskContext, selectedProject, targetLanguageCode);
foreach (var projectFile in projectFiles)
{
WriteReportFile(writer, taskContext, projectFile);
}
WriteReportTotal(writer, taskContext, projectFiles);
writer.WriteEndElement(); //task
}
}
private void UpdateFile(FileBasedProject project, Guid fileId, string newFileName)
#endregion
{
#region "GetFileProperties"
string fileInfo;
ProjectFile thisFile = project.GetFile(fileId);
fileInfo = "File name: " + thisFile.Name + "\n";
fileInfo += "File usage: " + thisFile.Role.ToString() + "\n";
fileInfo += "Belongs to project with the id: " + thisFile.ProjectId.ToString() + "\n";
fileInfo += "Language: " + thisFile.Language.DisplayName + "\n";
fileInfo += "Stored in folder: " + thisFile.LocalFilePath + "\n";
fileInfo += "Unique file id: " + thisFile.Id.ToString() + "\n";
MessageBox.Show(fileInfo);
#endregion
#region "AddNewFileVersion"
project.AddNewFileVersion(fileId, newFileName);
#endregion
#region "ReRunTasks"
Guid[] fileIds = { fileId };
project.RunAutomaticTask(fileIds, AutomaticTaskTemplateIds.ConvertToTranslatableFormat);
project.RunAutomaticTask(fileIds, AutomaticTaskTemplateIds.CopyToTargetLanguages);
#endregion
}
public void GetAnalyzeTaskSettings(FileBasedProject project)
{
#region "AnalysisTaskSettings"
ISettingsBundle settings = project.GetSettings();
AnalysisTaskSettings analyseSettings = settings.GetSettingsGroup <AnalysisTaskSettings>();
#endregion
#region "ReportCrossFileRepetitions"
analyseSettings.ReportCrossFileRepetitions.Value = true;
#endregion
#region "ReportInternalFuzzyMatchLeverage"
analyseSettings.ReportInternalFuzzyMatchLeverage.Value = true;
#endregion
#region "ExportFrequentSettings"
analyseSettings.ExportFrequentSegments.Value = true;
analyseSettings.FrequentSegmentsNoOfOccurrences.Value = 5;
#endregion
#region "ExportUnknownSegments"
analyseSettings.ExportUnknownSegments.Value = true;
analyseSettings.UnknownSegmentsMaximumMatchValue.Value = 50;
#endregion
#region "UpdateAnalyzeSettings"
project.UpdateSettings(settings);
#endregion
}
public void GetProjectStatistics(FileBasedProject project)
{
#region "GetProjectStatistics"
ProjectStatistics projStats = project.GetProjectStatistics();
#endregion
#region "TargetLanguageStatistics"
TargetLanguageStatistics[] targetStats = projStats.TargetLanguageStatistics;
#endregion
#region "trgInfo"
StringBuilder trgInfo = new StringBuilder();
for (int i = 0; i < targetStats.Length; i++)
{
ConfirmationStatistics confirmationStats = targetStats[i].ConfirmationStatistics;
Language trgLang = new Language(CultureInfo.GetCultureInfo("de-DE"));
Guid[] ids = project.GetTargetLanguageFiles(trgLang).GetIds();
project.RunAutomaticTask(ids, AutomaticTaskTemplateIds.TranslationCount);
trgInfo.Append("\nConfirmation statistics for: " + targetStats[i].TargetLanguage.DisplayName + "\n");
trgInfo.Append("Total word count: " + confirmationStats.Total.Words.ToString() + "\n");
trgInfo.Append("Words with untranslated status: " + confirmationStats[ConfirmationLevel.Unspecified].Words.ToString() + "\n");
trgInfo.Append("Words with draft status: " + confirmationStats[ConfirmationLevel.Draft].Words.ToString() + "\n");
trgInfo.Append("Words with translated status: " + confirmationStats[ConfirmationLevel.Translated].Words.ToString() + "\n");
}
MessageBox.Show(trgInfo.ToString());
#endregion
}
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);
this.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);
this.CheckEvents(taskStatusEventArgsList, messageEventArgsList);
AutomaticTask projectTmTask = project.RunAutomaticTask(
targetFiles.GetIds(),
AutomaticTaskTemplateIds.PopulateProjectTranslationMemories);
this.CheckEvents(taskStatusEventArgsList, messageEventArgsList);
}
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 ProjectDetails GetExternalProjectDetails(string path, string reportFolderPath)
{
try
{
var fileBasedProject = new FileBasedProject(path);
var projectInfo = fileBasedProject.GetProjectInfo();
var projectDetails = new ProjectDetails
{
ProjectName = projectInfo?.Name,
ProjectPath = projectInfo?.Uri.LocalPath,
Status = GetInternalProjectStatus(fileBasedProject),
ProjectLanguages = new Dictionary <string, bool>(),
ShouldBeExported = true,
ReportsFolderPath = reportFolderPath
};
foreach (var language in projectInfo?.TargetLanguages)
{
projectDetails.ProjectLanguages.Add(language.DisplayName, true);
}
ProjectController?.Close(fileBasedProject);
return(projectDetails);
}
catch (Exception ex)
{
_logger.Error($"GetExternalProjectDetails method: {ex.Message}\n {ex.StackTrace}");
}
return(new ProjectDetails());
}
/// <summary>
/// Create temporary bilingual files (sdlxliff) used to import the information in Studio translation memories
/// </summary>
private string CreateTemporarySdlXliffs(List <string> sourceTmFiles, List <string> targetTmFiles, CultureInfo targetCultureInfo, PackageModel package)
{
var pathToExtractFolder = CreateFolderToExtract(Path.GetDirectoryName(targetTmFiles[0]));
var targetLang = new Language(targetCultureInfo);
var projectInfo = new ProjectInfo
{
Name = $"TMExtractProject_{Guid.NewGuid()}",
LocalProjectFolder = pathToExtractFolder,
SourceLanguage = new Language(package.LanguagePairs[0].SourceLanguage),
TargetLanguages = new[] { targetLang }
};
var newProject =
new FileBasedProject(projectInfo, new ProjectTemplateReference(package.ProjectTemplate.Uri));
newProject.AddFiles(sourceTmFiles.ToArray());
var sourceFilesIds = newProject.GetSourceLanguageFiles().GetIds();
newProject.SetFileRole(sourceFilesIds, FileRole.Translatable);
var targetTms = newProject.AddFiles(targetTmFiles.ToArray());
newProject.RunAutomaticTask(targetTms?.GetIds(), AutomaticTaskTemplateIds.Scan);
var xliffCreationProgress = new XliffCreationProgress
{
BatchTaskIds = new List <string>(), TargetLanguage = targetLang.CultureInfo, TotalFileNumber = sourceTmFiles.Count
};
var taskSequence = newProject.RunAutomaticTasks(targetTms?.GetIds(),
new[]
{
AutomaticTaskTemplateIds.ConvertToTranslatableFormat,
AutomaticTaskTemplateIds.CopyToTargetLanguages
}, (sender, args) =>
{
xliffCreationProgress.BatchTaskIds.Clear();
xliffCreationProgress.BatchTaskIds.AddRange(args.TaskTemplateIds);
xliffCreationProgress.Progress = args.PercentComplete;
_eventAggregator.PublishEvent(xliffCreationProgress);
}, (sender, args) => { });
if (taskSequence.Status != TaskStatus.Failed)
{
return(pathToExtractFolder);
}
foreach (var subTask in taskSequence.SubTasks)
{
_logger.Error($"Name:{subTask.Name}");
foreach (var messages in subTask.Messages)
{
_logger.Error($"Exception: {messages?.Exception}");
_logger.Error($"Message: {messages?.Message}");
}
}
return(string.Empty);
}
public List <Model.AnalysisBand> GetAnalysisBands(FileBasedProject project)
{
var regex = new Regex(@"(?<min>[\d]*)([^\d]*)(?<max>[\d]*)", RegexOptions.IgnoreCase);
var analysisBands = new List <Model.AnalysisBand>();
var type = project.GetType();
var internalProjectField = type.GetField("_project", BindingFlags.NonPublic | BindingFlags.Instance);
if (internalProjectField != null)
{
dynamic internalDynamicProject = internalProjectField.GetValue(project);
foreach (var analysisBand in internalDynamicProject.AnalysisBands)
{
Match match = regex.Match(analysisBand.ToString());
if (match.Success)
{
var min = match.Groups["min"].Value;
var max = match.Groups["max"].Value;
analysisBands.Add(new Model.AnalysisBand
{
MinimumMatchValue = Convert.ToInt32(min),
MaximumMatchValue = Convert.ToInt32(max)
});
}
}
}
return(analysisBands);
}
public void CreateTaskReport(TaskContext taskContext, string reportFile,
FileBasedProject selectedProject, string targetLanguageCode)
{
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = true,
Indent = false
};
var projectFiles = taskContext.ProjectFiles.Where(a => a.Selected &&
string.Compare(a.TargetLanguage, targetLanguageCode,
StringComparison.CurrentCultureIgnoreCase) == 0).ToList();
var reportName = "";
switch (taskContext.Action)
{
case Enumerators.Action.Convert:
reportName = "Create Transcreate Project Report";
break;
case Enumerators.Action.CreateBackTranslation:
if (taskContext.Project is BackTranslationProject backTranslationProject && backTranslationProject.IsUpdate)
{
reportName = "Update Back-Translation Project Report";
}
else
{
reportName = "Create Back-Translation Project Report";
}
break;
private bool UpdateCustomerInfo(FileBasedProject project, Project xliffProject)
{
var customer = _customerProvider.GetProjectCustomer(project);
var customerName = customer?.Name ?? string.Empty;
var customerEmail = customer?.Email ?? string.Empty;
var xliffCustomerName = xliffProject.Customer?.Name?.Replace("[no client]", string.Empty) ?? string.Empty;
var xliffCustomerEmail = xliffProject.Customer?.Email ?? string.Empty;
if (customerName != xliffCustomerName || customerEmail != xliffCustomerEmail)
{
if (customer == null)
{
xliffProject.Customer = null;
}
else
{
xliffProject.Customer = new Customer
{
Id = customer.Id,
Name = customer.Name,
Email = customer.Email
};
}
return(true);
}
return(false);
}
private void UpdateProjectReports(WizardContext wizardContext, FileBasedProject project, AutomaticTask automaticTask)
{
if (project == null)
{
return;
}
try
{
_supressProjectControllerEvents = true;
_projectsController.Close(project);
_projectSettingsService.UpdateAnalysisTaskReportInfo(project, automaticTask);
_projectsController.Add(project.FilePath);
switch (wizardContext.Owner)
{
case Enumerators.Controller.Files:
_filesController.Activate();
break;
case Enumerators.Controller.Projects:
_projectsController.Activate();
break;
}
}
finally
{
_supressProjectControllerEvents = false;
}
}
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);
this.CheckEvents(taskStatusEventArgsList, messageEventArgsList);
AutomaticTask copyTask = project.RunAutomaticTask(
fileId,
AutomaticTaskTemplateIds.CopyToTargetLanguages);
this.CheckEvents(taskStatusEventArgsList, messageEventArgsList);
}
}
this.ProcessTargetLanguageFilesExtended(project, "de-DE");
this.ProcessTargetLanguageFilesExtended(project, "fr-FR");
}
/// <summary>
/// Create basic project from scratch, not using templates and add files from selected folder
/// </summary>
public void CreateProject(LocalProjectSettings settings)
{
try
{
////Create new project object
FileBasedProject createdProject = new FileBasedProject(
this.GetProjectInfo(
settings.ProjectName,
new Language(settings.SourceLanguage),
new Language[] { new Language(settings.TargetLanguage) }, settings.OutputPath));
////Add files from selected folder
createdProject.AddFolderWithFiles(settings.InputFolder, true);
////Start the tasks
this.RunTasks(createdProject, settings);
createdProject.Save();
////project is saved but not listed in Studio, this is by design.
}
catch (Exception ex)
{
throw new Exception("Problem during project creation", ex);
}
}
private FileBasedProject CreateProject(ProjectRequest request)
{
ProjectInfo projectInfo = new ProjectInfo
{
Name = request.Name,
LocalProjectFolder = GetProjectFolderPath(request.Name),
};
FileBasedProject project = new FileBasedProject(projectInfo,
new ProjectTemplateReference(request.ProjectTemplate.Uri));
// new ProjectTemplateReference(ProjectTemplate.Uri));
OnMessageReported(project, String.Format("Creating project {0}", request.Name));
//path to subdirectory
var subdirectoryPath =
request.Files[0].Substring(0, request.Files[0].IndexOf(request.Name, StringComparison.Ordinal)) +
request.Name;
ProjectFile[] projectFiles = project.AddFolderWithFiles(subdirectoryPath, true);
project.RunAutomaticTask(projectFiles.GetIds(), AutomaticTaskTemplateIds.Scan);
//when a template is created from a Single file project, task sequencies is null.
try
{
TaskSequence taskSequence = project.RunDefaultTaskSequence(projectFiles.GetIds(),
(sender, e)
=>
{
OnProgressChanged(_currentProgress + (double)e.PercentComplete / Requests.Count);
}
, (sender, e)
=>
{
OnMessageReported(project, e.Message);
});
project.Save();
if (taskSequence.Status == TaskStatus.Completed)
{
SuccessfulRequests.Add(Tuple.Create(request, project));
OnMessageReported(project, String.Format("Project {0} created successfully.", request.Name));
return(project);
}
else
{
OnMessageReported(project, String.Format("Project {0} creation failed.", request.Name));
return(null);
}
}
catch (Exception ex)
{
MessageBox.Show(
@"Please go to File -> Setup -> Project templates -> Select a template -> Edit -> Default Task Sequence -> Ok after that run again Content connector");
TelemetryService.Instance.AddException(ex);
}
return(project);
}
public List <Customer> GetProjectCustomers(FileBasedProject project)
{
var type = project.GetType();
var internalProjectField = type.GetField("_project", BindingFlags.NonPublic | BindingFlags.Instance);
if (internalProjectField != null)
{
dynamic internalDynamicProject = internalProjectField.GetValue(project);
dynamic studioCustomers = internalDynamicProject?.ProjectsProvider?.CustomerProvider?.Customers;
if (studioCustomers == null)
{
return(null);
}
var customersModels = new List <Customer>();
foreach (var studioCustomer in studioCustomers)
{
var customer = new Customer
{
Name = studioCustomer.Name,
Email = studioCustomer.Email,
Id = studioCustomer.Guid.ToString()
};
customersModels.Add(customer);
}
return(customersModels);
}
return(null);
}
public bool TryLoad(string cloudTag, FileBasedProject project, out List<IWord> words)
{
words = null;
string cacheFile = CreateCacheFilePath(cloudTag, project);
if (!File.Exists(cacheFile))
{
return false;
}
try
{
XDocument doc = XDocument.Load(cacheFile);
int storedHash = Int32.Parse(doc.XPathSelectElement("/wordcloud/hash").Value);
int hash = GetWordCloudHash(project);
if (storedHash != hash)
{
return false;
}
words = new List<IWord>();
foreach (XElement w in doc.XPathSelectElements("/wordcloud/words/word"))
{
words.Add(new Word { Text=w.Attribute("text").Value, Occurrences = Int32.Parse(w.Attribute("count").Value)});
}
return true;
}
catch (Exception ex)
{
return false;
}
}
private void AddMasterTM(FileBasedProject createdProject, string pathToTM)
{
TranslationProviderConfiguration config = createdProject.GetTranslationProviderConfiguration();
config.Entries.Add(this.GetTranslationProviderCascadeEntry(pathToTM));
createdProject.UpdateTranslationProviderConfiguration(config);
}
private static ProjectInfo GetProjectInfo(string projectPath)
{
var fileBasedProject = new FileBasedProject(projectPath);
var projectInfo = fileBasedProject?.GetProjectInfo();
return(projectInfo);
}
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"
this.ProcessTargetLanguageFiles(project, "de-DE");
this.ProcessTargetLanguageFiles(project, "fr-FR");
#endregion
}
public void ActivateProject(FileBasedProject project)
{
if (project == null)
{
return;
}
var projectId = project.GetProjectInfo().Id.ToString();
var selectedProjectId = _projectsController.CurrentProject?.GetProjectInfo().Id.ToString();
if (projectId != selectedProjectId)
{
if (CanActivateFileBasedProject())
{
var activateProjectMethod = _projectsController.GetType().GetMethod("ActivateProject",
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
activateProjectMethod?.Invoke(_projectsController, new object[] { project });
}
else
{
var internalProjectType = typeof(FileBasedProject).GetProperty("InternalProject",
BindingFlags.NonPublic | BindingFlags.Instance);
var projectInstance = internalProjectType?.GetValue(project);
var activateProjectMethod = _projectsController.GetType().GetMethod("ActivateProject",
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
activateProjectMethod?.Invoke(_projectsController, new[] { projectInstance });
}
}
Dispatcher.CurrentDispatcher.Invoke(delegate { }, DispatcherPriority.ContextIdle);
}
public void GetUpdateTmTaskSettings(FileBasedProject project)
{
#region "UpdateTmTaskSettings"
ISettingsBundle settings = project.GetSettings();
TranslationMemoryUpdateTaskSettings updateTmSettings = settings.GetSettingsGroup <TranslationMemoryUpdateTaskSettings>();
#endregion
#region "NewTranslations"
updateTmSettings.TmImportOptions.Value = TmImportOption.AlwaysAddNewTranslation;
#endregion
#region "Status"
updateTmSettings.UpdateWithApprovedSignOffSegments.Value = true;
updateTmSettings.UpdateWithApprovedTranslationSegments.Value = true;
updateTmSettings.UpdateWithTranslatedSegments.Value = true;
updateTmSettings.UpdateWithDraftSegments.Value = false;
updateTmSettings.UpdateWithRejectedSignOffSegments.Value = false;
updateTmSettings.UpdateWithRejectedTranslationSegments.Value = false;
updateTmSettings.UpdateWithUnspecifiedSegments.Value = false;
#endregion
#region "UpdateTaskSettings"
project.UpdateSettings(settings);
#endregion
}
public static List <Customer> GetStudioCustomers(FileBasedProject project)
{
var customers = new List <Customer>();
var type = project.GetType();
var internalProjectField = type.GetField("_project", BindingFlags.Instance | BindingFlags.NonPublic);
if (internalProjectField == null)
{
return(customers);
}
dynamic internalDynamicaProject = internalProjectField.GetValue(project);
dynamic customersList = internalDynamicaProject.ProjectsProvider?.CustomerProvider?.Customers;
if (customersList == null)
{
return(customers);
}
foreach (var customer in customersList)
{
customers.Add(new Customer {
Guid = customer.Guid, Name = customer.Name, Email = customer.Email
});
}
return(customers);
}
public static void SetCustomer(this FileBasedProject project, Customer customerModel)
{
var allCustomers = GetStudioCustomers(project);
var customer = allCustomers.FirstOrDefault(c =>
c.Name.Equals(customerModel.Name) && c.Guid.Equals(customerModel.Guid));
if (customer == null)
{
return;
}
var type = project.GetType();
var internalProjectField = type.GetField("_project", BindingFlags.Instance | BindingFlags.NonPublic);
if (internalProjectField == null)
{
return;
}
dynamic internalDynamicaProject = internalProjectField.GetValue(project);
dynamic customersList = internalDynamicaProject.ProjectsProvider?.CustomerProvider?.Customers;
if (customersList == null)
{
return;
}
foreach (var dynCustomer in customersList)
{
if (!dynCustomer.Guid.Equals(customer.Guid))
{
continue;
}
internalDynamicaProject.ChangeCustomer(dynCustomer);
break;
}
}
public void UpdateProjectQuote()
{
QuoteItems.Clear();
FileBasedProject project = ProjectsController.SelectedProjects.FirstOrDefault();
if (project != null)
{
ProjectStatistics stats = project.GetProjectStatistics();
QuoteItems.Clear();
QuoteItems.Columns.Clear();
QuoteItems.Columns.Add("Language", typeof(string));
QuoteItems.Columns.Add("Perfect", typeof(double));
QuoteItems.Columns.Add("Repetitions", typeof(double));
QuoteItems.Columns.Add("InContextExact", typeof(double));
QuoteItems.Columns.Add("Exact", typeof(double));
FuzzyCountData[] fuzzy = stats.TargetLanguageStatistics[0].AnalysisStatistics.Fuzzy;
for (int i = fuzzy.Length - 1; i >= 0; i--)
{
AnalysisBand band = fuzzy[i].Band;
QuoteItems.Columns.Add(GetBandName(band), typeof(double));
}
QuoteItems.Columns.Add("New", typeof(double));
QuoteItems.Columns.Add("Total", typeof(double));
AddItemRows(stats);
}
}
public void GetPretranslateTaskSettings(FileBasedProject project)
{
#region "PetranslateTaskSettings"
ISettingsBundle settings = project.GetSettings();
TranslateTaskSettings pretranslateSettings = settings.GetSettingsGroup <TranslateTaskSettings>();
#endregion
#region "MinimumScore"
pretranslateSettings.MinimumMatchScore.Value = 95;
#endregion
#region "ExactMatches"
pretranslateSettings.ConfirmAfterApplyingExactMatch.Value = true;
pretranslateSettings.LockExactMatchSegments.Value = false;
#endregion
#region "ContextMatches"
pretranslateSettings.ConfirmAfterApplyingInContextExactMatch.Value = true;
pretranslateSettings.LockContextMatchSegments.Value = true;
#endregion
#region "NoMatch"
pretranslateSettings.NoTranslationMemoryMatchFoundAction.Value = NoTranslationMemoryMatchFoundAction.CopySourceToTarget;
#endregion
#region "TranslationOverwrite"
pretranslateSettings.TranslationOverwriteMode.Value = TranslationUpdateMode.OverwriteExistingTranslation;
#endregion
#region "UpdateTaskSettings"
project.UpdateSettings(settings);
#endregion
}
protected override void Execute()
{
var projectInfo = new ProjectInfo
{
Name = "",
SourceLanguage = new Language(""),
TargetLanguages = new[] { new Language("") },
LocalProjectFolder = @"",
};
var fileBasedProject = new FileBasedProject(projectInfo);
var allProviders = TranslationProviderManager.GetTranslationProviderFactories(); //get a list of all providers
AddServerTm(fileBasedProject, "", "", "", false, "",
"");
var projectFiles = fileBasedProject.AddFiles(new[] { @"" });
fileBasedProject.RunAutomaticTasks(projectFiles.GetIds(), new[]
{
AutomaticTaskTemplateIds.Scan,
AutomaticTaskTemplateIds.ConvertToTranslatableFormat,
AutomaticTaskTemplateIds.CopyToTargetLanguages,
AutomaticTaskTemplateIds.PreTranslateFiles,
});
fileBasedProject.Save();
}
public void Save(string cloudTag, FileBasedProject project, List<IWord> words)
{
XDocument doc = new XDocument();
doc.Add(
new XElement("wordcloud",
new XElement("hash", GetWordCloudHash(project)),
new XElement("words",
from word in words
select new XElement("word", new XAttribute("text", word.Text), new XAttribute("count", word.Occurrences))))
);
string cacheFile = CreateCacheFilePath(cloudTag, project);
doc.Save(cacheFile);
}
private int GetWordCloudHash(FileBasedProject project)
{
return 1;
}
private string CreateCacheFilePath(string cloudTag, FileBasedProject project)
{
return Path.Combine(Path.GetDirectoryName(project.FilePath), Path.GetFileNameWithoutExtension(project.FilePath) + "-" + cloudTag + ".xml");
}
public ProjectTextExtractor(FileBasedProject project)
{
Project = project;
FileTypeManager = DefaultFileTypeManager.CreateInstance(true);
}
