private bool CheckLanguageSupport(AbstractHumanTranslationService humanService, TranslationSettings settings)
{
var sourceLanguage = settings.SourceLanguage;
if (!humanService.CheckSourceLanguageAvailability(sourceLanguage))
{
AddError(String.Format(ResHelper.GetString("translationservice.sourcelanguagenotsupported"), sourceLanguage));
return(false);
}
var unavailableLanguages = humanService.CheckTargetLanguagesAvailability(settings.TargetLanguages);
if (unavailableLanguages.Count > 0)
{
AddError(String.Format(ResHelper.GetString("translationservice.targetlanguagenotsupported"), String.Join(", ", unavailableLanguages)));
return(false);
}
return(true);
}
/// <summary>
/// Submits submission to translation service.
/// </summary>
/// <param name="itemCount">Number of items</param>
/// <param name="submission">Submission info object</param>
/// <param name="charCount">Number of characters</param>
/// <param name="wordCount">Number of words</param>
/// <param name="submissionFileName">Submission file name</param>
/// <param name="humanService">Translation service info</param>
/// <param name="contactService">Indicates if service should be contacted</param>
private void SubmitSubmissionToService(int itemCount, TranslationSubmissionInfo submission, int charCount, int wordCount, string submissionFileName, AbstractHumanTranslationService humanService, bool contactService)
{
submission.SubmissionCharCount = charCount;
submission.SubmissionWordCount = wordCount;
submission.SubmissionItemCount = itemCount;
submission.SubmissionParameter = submissionFileName;
AddLog(ResHelper.GetString("content.submitingtranslation"));
if (contactService)
{
string error = humanService.CreateSubmission(submission);
if (!string.IsNullOrEmpty(error))
{
AddError(LocalizationHelper.GetString("ContentRequest.TranslationFailed") + " \"" + error + "\"");
}
}
// Update submission after submitting to service to save ticket
submission.Update();
}
/// <summary>
/// Translates document(s).
/// </summary>
private void Translate(object parameter)
{
var parameters = parameter as AsyncParameters;
if ((parameters == null) || nodeIds.Count < 1)
{
return;
}
AbstractMachineTranslationService machineService = null;
AbstractHumanTranslationService humanService = null;
TranslationSubmissionInfo submission = null;
string submissionFileName = "";
int charCount = 0;
int wordCount = 0;
int refreshId = 0;
int itemCount = 0;
int pageCount = 0;
bool oneSubmission = translationElem.CreateSeparateSubmission;
bool success = false;
bool separateSubmissionCreated = false;
TreeProvider tree = new TreeProvider();
tree.AllowAsyncActions = false;
try
{
// Begin log
AddLog(ResHelper.GetString("contentrequest.starttranslate", parameters.UICulture));
// Prepare translation settings
var settings = PrepareTranslationSettings();
// Check selected service
var service = TranslationServiceInfoProvider.GetTranslationServiceInfo(translationElem.SelectedService);
if (service == null)
{
return;
}
// Set if we need target tag (Translations.com workaround)
settings.GenerateTargetTag = service.TranslationServiceGenerateTargetTag;
if (service.TranslationServiceIsMachine)
{
machineService = AbstractMachineTranslationService.GetTranslationService(service, CurrentSiteName);
}
else
{
humanService = AbstractHumanTranslationService.GetTranslationService(service, CurrentSiteName);
}
bool langSupported = (humanService == null) || CheckLanguageSupport(humanService, settings);
if (!langSupported)
{
return;
}
if ((machineService != null) || (humanService != null))
{
var data = tree.SelectNodes()
.CombineWithDefaultCulture(false)
.Published(false)
.Culture(settings.SourceLanguage)
.WhereIn("NodeID", nodeIds)
.OnSite(CurrentSiteName)
.OrderBy("NodeLevel, NodeAliasPath")
.Column("NodeID");
if (!DataHelper.DataSourceIsEmpty(data))
{
var processedNodes = new List <int>();
// Translate the documents
foreach (DataRow dr in data.Tables[0].Rows)
{
int nodeId = ValidationHelper.GetInteger(dr["NodeID"], 0);
// Get document in source language
var node = DocumentHelper.GetDocument(nodeId, settings.SourceLanguage, false, tree);
if (node == null)
{
// Document doesn't exist in source culture, skip it
continue;
}
var targetLanguages = GetTargetLanguages(settings.TargetLanguages, node).ToList();
if (!targetLanguages.Any())
{
continue;
}
if ((submission == null) && (humanService != null))
{
// Create new submission if not exists for human translation service
submission = TranslationServiceHelper.CreateSubmissionInfo(settings, service, MembershipContext.AuthenticatedUser.UserID, SiteInfoProvider.GetSiteID(CurrentSiteName), node.GetDocumentName());
}
// Handle duplicities
if (processedNodes.Contains(nodeId))
{
continue;
}
processedNodes.Add(nodeId);
bool targetLanguageVersionCreated = false;
bool logged = false;
string encodedPath = HTMLHelper.HTMLEncode(node.NodeAliasPath);
foreach (var targetLanguage in targetLanguages)
{
// Log only once per document
if (!logged)
{
AddLog(String.Format(ResHelper.GetString("content.translating"), encodedPath, settings.SourceLanguage));
logged = true;
}
itemCount++;
targetLanguageVersionCreated = true;
if (humanService != null)
{
if (String.IsNullOrEmpty(submissionFileName))
{
submissionFileName = node.NodeAlias;
}
var targetNode = TranslationServiceHelper.CreateTargetCultureNode(node, targetLanguage, true, false, !settings.TranslateAttachments);
TranslationSubmissionItemInfo submissionItem;
using (new CMSActionContext {
TouchParent = false
})
{
// Do not touch parent because all updated information are saved after last item
submissionItem = TranslationServiceHelper.CreateSubmissionItemInfo(settings, submission, node, targetNode.DocumentID, targetLanguage);
}
charCount += submissionItem.SubmissionItemCharCount;
wordCount += submissionItem.SubmissionItemWordCount;
}
else
{
// Prepare local settings to translate per one target language
var localSettings = settings.Clone();
localSettings.TargetLanguages.Clear();
localSettings.TargetLanguages.Add(targetLanguage);
// Translate page via machine translator
TranslationServiceHelper.Translate(machineService, localSettings, node);
}
}
// Each page has own submission if human service is used
if (!oneSubmission && (humanService != null))
{
if (itemCount > 0)
{
SubmitSubmissionToService(itemCount, submission, charCount, wordCount, submissionFileName, humanService, true);
// Reset counters
itemCount = 0;
charCount = 0;
wordCount = 0;
// Reset submission file name
submissionFileName = null;
// At least one submission was created
separateSubmissionCreated = true;
}
else
{
// No documents were submitted to translation delete empty submission
TranslationSubmissionInfoProvider.DeleteTranslationSubmissionInfo(submission);
}
// Reset submission to create new for next page
submission = null;
}
if (targetLanguageVersionCreated)
{
// Check if at least one target language version was created
pageCount++;
}
// Store parent ID to refresh UI
refreshId = node.NodeParentID;
}
success = true;
}
else
{
AddError(ResHelper.GetString("TranslateDocument.NoSourceDocuments", parameters.UICulture));
}
}
else
{
AddError(ResHelper.GetString("TranslateDocument.TranslationServiceNotFound", parameters.UICulture));
}
}
catch (ThreadAbortException ex)
{
if (CMSThread.Stopped(ex))
{
// When canceled
AddError(ResHelper.GetString("TranslateDocument.TranslationCanceled", parameters.UICulture));
}
else
{
// Log error
LogExceptionToEventLog(ex, parameters.UICulture);
}
}
catch (Exception ex)
{
// Log error
LogExceptionToEventLog(ex, parameters.UICulture);
}
finally
{
var showAllAlreadyTranslatedError = false;
if (itemCount > 0)
{
// All pages are submitted via only one submission or using machine service
if ((humanService != null) && (submission != null))
{
// Set submission name if more pages are translated
if (pageCount > 1)
{
submission.SubmissionName += " " + string.Format(GetString("translationservices.submissionnamesuffix"), pageCount - 1);
// Do not localize the file name
submissionFileName += string.Format(" (and {0} more)", pageCount - 1);
}
SubmitSubmissionToService(itemCount, submission, charCount, wordCount, submissionFileName, humanService, success);
}
}
else if (oneSubmission)
{
TranslationSubmissionInfoProvider.DeleteTranslationSubmissionInfo(submission);
// Log error only if the translation was successfully processed
if (success)
{
showAllAlreadyTranslatedError = true;
}
}
else if (!separateSubmissionCreated)
{
// Separate submissions were used and no one was created
showAllAlreadyTranslatedError = true;
}
if (showAllAlreadyTranslatedError)
{
AddError(ResHelper.GetString("TranslateDocument.DocumentsAlreadyTranslated", parameters.UICulture));
}
if (parameters.IsDialog)
{
ctlAsyncLog.Parameter = "wopener.location.replace(wopener.location); CloseDialog(); if (wopener.RefreshTree) { wopener.RefreshTree(null, null);}";
}
else
{
if (string.IsNullOrEmpty(CurrentError))
{
// Overwrite refreshId variable if sub-levels are visible
if (parameters.AllLevels && Parameters.ContainsKey("refreshnodeid"))
{
refreshId = ValidationHelper.GetInteger(Parameters["refreshnodeid"], 0);
}
// Refresh tree
ctlAsyncLog.Parameter = "RefreshTree(" + refreshId + ", " + refreshId + "); \n" + "SelectNode(" + refreshId + ");";
}
else
{
ctlAsyncLog.Parameter = "RefreshTree(null, null);";
}
}
}
}
/// <summary>
/// Translates document(s).
/// </summary>
private void Translate(object parameter)
{
if (parameter == null || nodeIds.Count < 1)
{
return;
}
int refreshId = 0;
TreeProvider tree = new TreeProvider(currentUser);
tree.AllowAsyncActions = false;
try
{
// Begin log
AddLog(ResHelper.GetString("contentrequest.starttranslate", currentCulture));
bool oneSubmission = chkSeparateSubmissions.Checked;
// Prepare translation settings
TranslationSettings settings = new TranslationSettings();
settings.TargetLanguage = targetCulture;
settings.TranslateWebpartProperties = SettingsKeyProvider.GetBoolValue(CMSContext.CurrentSiteName + ".CMSTranslateWebpartProperties");
settings.SourceLanguage = translationElem.FromLanguage;
settings.Instructions = translationElem.Instructions;
settings.Priority = translationElem.Priority;
settings.TranslateAttachments = translationElem.ProcessBinary;
settings.ProcessBinary = translationElem.ProcessBinary;
settings.TranslationDeadline = translationElem.Deadline;
settings.TranslationServiceName = translationElem.SelectedService;
using (CMSTransactionScope tr = new CMSTransactionScope())
{
// Get the translation provider
AbstractMachineTranslationService machineService = null;
AbstractHumanTranslationService humanService = null;
TranslationSubmissionInfo submission = null;
TranslationServiceInfo ti = TranslationServiceInfoProvider.GetTranslationServiceInfo(translationElem.SelectedService);
if (ti != null)
{
if (oneSubmission)
{
if (ti.TranslationServiceIsMachine)
{
machineService = AbstractMachineTranslationService.GetTranslationService(ti, CurrentSiteName);
}
else
{
humanService = AbstractHumanTranslationService.GetTranslationService(ti, CurrentSiteName);
if (oneSubmission)
{
submission = TranslationServiceHelper.CreateSubmissionInfo(settings, ti, CMSContext.CurrentUser.UserID, CMSContext.CurrentSiteID, "Document submission " + DateTime.Now);
}
}
}
bool langSupported = true;
if (humanService != null)
{
if (!humanService.IsLanguageSupported(settings.TargetLanguage))
{
AddError(ResHelper.GetString("translationservice.targetlanguagenotsupported"));
langSupported = false;
}
}
if (langSupported)
{
if (!oneSubmission || (machineService != null) || (humanService != null))
{
// Prepare the where condition
string where = SqlHelperClass.GetWhereCondition("NodeID", (int[])nodeIds.ToArray(typeof(int)));
string columns = "NodeID, NodeAliasPath, DocumentCulture, NodeParentID";
string submissionFileName = "";
string submissionName = "";
int charCount = 0;
int wordCount = 0;
int docCount = 0;
// Get the documents in target culture to be able to check if "Skip already translated" option is on
// Combine both, source and target culture (at least one hit has to be found - to find the source of translation)
where = SqlHelperClass.AddWhereCondition(where, "DocumentCulture = N'" + settings.SourceLanguage + "' OR DocumentCulture = N'" + settings.TargetLanguage + "'");
DataSet ds = tree.SelectNodes(CMSContext.CurrentSiteName, "/%", TreeProvider.ALL_CULTURES, true, null, where, "NodeAliasPath DESC", TreeProvider.ALL_LEVELS, false, 0, columns);
if (!DataHelper.DataSourceIsEmpty(ds))
{
List <int> processedNodes = new List <int>();
// Translate the documents
foreach (DataRow dr in ds.Tables[0].Rows)
{
refreshId = ValidationHelper.GetInteger(dr["NodeParentID"], 0);
int nodeId = ValidationHelper.GetInteger(dr["NodeID"], 0);
if (!processedNodes.Contains(nodeId))
{
processedNodes.Add(nodeId);
string aliasPath = ValidationHelper.GetString(dr["NodeAliasPath"], "");
string culture = ValidationHelper.GetString(dr["DocumentCulture"], "");
if (chkSkipTranslated.Checked)
{
if (culture == settings.TargetLanguage)
{
// Document already exists in requested culture, skip it
AddLog(string.Format(ResHelper.GetString("content.translatedalready"), HTMLHelper.HTMLEncode(aliasPath + " (" + culture + ")")));
continue;
}
}
AddLog(string.Format(ResHelper.GetString("content.translating"), HTMLHelper.HTMLEncode(aliasPath + " (" + culture + ")")));
TreeNode node = DocumentHelper.GetDocument(nodeId, settings.SourceLanguage, true, null);
// Save the first document as a base for submission name
if (string.IsNullOrEmpty(submissionName))
{
submissionName = node.GetDocumentName();
}
if (string.IsNullOrEmpty(submissionFileName))
{
submissionFileName = node.NodeAlias;
}
docCount++;
// Submit the document
if (machineService != null)
{
TranslationServiceHelper.Translate(machineService, settings, node);
}
else
{
if (oneSubmission && (humanService != null))
{
TreeNode targetNode = TranslationServiceHelper.CreateTargetCultureNode(node, settings.TargetLanguage, true, false);
TranslationSubmissionItemInfo submissionItem = TranslationServiceHelper.CreateSubmissionItemInfo(settings, submission, node, targetNode.DocumentID);
charCount += submissionItem.SubmissionItemCharCount;
wordCount += submissionItem.SubmissionItemWordCount;
}
else
{
TranslationServiceHelper.SubmitToTranslation(settings, node, out submission);
}
}
}
}
if (docCount > 0)
{
if (oneSubmission && (humanService != null))
{
AddLog(ResHelper.GetString("content.submitingtranslation"));
// Set submission name
int itemCount = processedNodes.Count;
if (itemCount > 1)
{
submissionName += " " + string.Format(GetString("translationservices.submissionnamesuffix"), itemCount - 1);
}
submission.SubmissionName = submissionName;
submission.SubmissionCharCount = charCount;
submission.SubmissionWordCount = wordCount;
submission.SubmissionItemCount = itemCount;
submission.SubmissionParameter = submissionFileName;
string err = humanService.CreateSubmission(submission);
if (!string.IsNullOrEmpty(err))
{
AddError(err);
}
// Save submission with ticket
TranslationSubmissionInfoProvider.SetTranslationSubmissionInfo(submission);
}
}
else
{
TranslationSubmissionInfoProvider.DeleteTranslationSubmissionInfo(submission);
AddError(ResHelper.GetString("TranslateDocument.DocumentsAlreadyTranslated", currentCulture));
}
}
}
else
{
AddError(ResHelper.GetString("TranslateDocument.TranslationServiceNotFound", currentCulture));
}
}
}
tr.Commit();
}
}
catch (ThreadAbortException ex)
{
string state = ValidationHelper.GetString(ex.ExceptionState, string.Empty);
if (state == CMSThread.ABORT_REASON_STOP)
{
// When canceled
AddError(ResHelper.GetString("TranslateDocument.TranslationCanceled", currentCulture));
}
else
{
// Log error
LogExceptionToEventLog(ex);
}
}
catch (Exception ex)
{
// Log error
LogExceptionToEventLog(ex);
}
finally
{
if (isModal)
{
ctlAsync.Parameter = "wopener.location.replace(wopener.location); CloseDialog();";
}
else
{
if (string.IsNullOrEmpty(CurrentError))
{
// Refresh tree
ctlAsync.Parameter = "RefreshTree(" + refreshId + ", " + refreshId + "); \n" + "SelectNode(" + refreshId + ");";
}
else
{
ctlAsync.Parameter = "RefreshTree(null, null);";
}
}
}
}
/// <summary>
/// Submits submission to translation service.
/// </summary>
/// <param name="itemCount">Number of items</param>
/// <param name="submission">Submission info object</param>
/// <param name="charCount">Number of characters</param>
/// <param name="wordCount">Number of words</param>
/// <param name="submissionFileName">Submission file name</param>
/// <param name="humanService">Translation service info</param>
/// <param name="contactService">Indicates if service should be contacted</param>
private void SubmitSubmissionToService(int itemCount, TranslationSubmissionInfo submission, int charCount, int wordCount, string submissionFileName, AbstractHumanTranslationService humanService, bool contactService)
{
submission.SubmissionCharCount = charCount;
submission.SubmissionWordCount = wordCount;
submission.SubmissionItemCount = itemCount;
submission.SubmissionParameter = submissionFileName;
AddLog(ResHelper.GetString("content.submitingtranslation"));
if (contactService)
{
string error = humanService.CreateSubmission(submission);
if (!string.IsNullOrEmpty(error))
{
AddError(LocalizationHelper.GetString("ContentRequest.TranslationFailed") + " \"" + error + "\"");
}
}
// Update submission after submitting to service to save ticket
submission.Update();
}
/// <summary>
/// Clears the cache to apply the settings to the web site.
/// </summary>
private void ClearCache(string keyName, object keyValue)
{
var clearCache = false;
var clearOutputCache = false;
var clearCSSCache = false;
var clearPartialCache = false;
string serviceBaseName = null;
var serviceEnabled = false;
// Clear the cached items
switch (keyName.ToLowerCSafe())
{
case "cmsemailsenabled":
if ((mSiteId <= 0) && (keyValue.ToString().EqualsCSafe("false", true)))
{
// Stop current sending of e-mails and newsletters if e-mails are disabled in global settings
EmailHelper.Queue.CancelSending();
ModuleCommands.CancelNewsletterSending();
}
break;
case "cmslogsize":
// Log size changed
EventLogProvider.Clear();
break;
case "cmscacheminutes":
case "cmscachepageinfo":
case "cmscacheimages":
case "cmsmaxcachefilesize":
case "cmsdefaultaliaspath":
case "cmsdefaultculturecode":
case "cmscombinewithdefaultculture":
// Clear cache upon change
clearCache = true;
break;
case "cmspagekeywordsprefix":
case "cmspagedescriptionprefix":
case "cmspagetitleformat":
case "cmspagetitleprefix":
case "cmscontrolelement":
case "cmsenableoutputcache":
case "cmsfilesystemoutputcacheminutes":
// Clear output cache upon change
clearOutputCache = true;
break;
case "cmsenablepartialcache":
// Clear output cache upon change
clearPartialCache = true;
break;
case "cmsresourcecompressionenabled":
case "cmsstylesheetminificationenabled":
case "cmsresolvemacrosincss":
// Clear the CSS styles
clearCSSCache = true;
break;
case "cmsuseexternalservice":
case "cmsservicehealthmonitoringinterval":
case "cmsenablehealthmonitoring":
// Restart Health Monitoring service
{
serviceBaseName = WinServiceHelper.HM_SERVICE_BASENAME;
serviceEnabled = HealthMonitoringHelper.UseExternalService;
// Clear status of health monitoring
HealthMonitoringHelper.Clear();
}
break;
case "cmsprogressivecaching":
CacheHelper.ProgressiveCaching = ValidationHelper.GetBoolean(keyValue, false);
break;
case "cmsscheduleruseexternalservice":
case "cmsschedulerserviceinterval":
case "cmsschedulertasksenabled":
// Restart Scheduler service
serviceBaseName = WinServiceHelper.SCHEDULER_SERVICE_BASENAME;
serviceEnabled = SchedulingHelper.UseExternalService;
break;
case "cmsresizeimagestodevice":
CacheHelper.TouchKey(DeviceProfileInfoProvider.DEVICE_IMAGE_CACHE_KEY);
break;
case "cmstranslationscomurl":
case "cmstranslationscomusername":
case "cmstranslationscompassword":
case "cmstranslationscomprojectcode":
AbstractHumanTranslationService.ClearHashtables();
break;
case "cmsuseeventloglistener":
if (ValidationHelper.GetBoolean(keyValue, false))
{
EventLogSourceHelper.RegisterDefaultEventLogListener();
}
else
{
EventLogSourceHelper.UnregisterDefaultEventLogListener();
}
break;
}
// Clear the cache to apply the settings to the web site
if (clearCache)
{
CacheHelper.ClearCache(null);
}
// Restart windows service
else if (serviceBaseName != null)
{
try
{
WinServiceItem def = WinServiceHelper.GetServiceDefinition(serviceBaseName);
if (def != null)
{
if (serviceEnabled)
{
WinServiceHelper.RestartService(def.GetServiceName());
}
else
{
WinServiceHelper.DeleteServiceFile(def.GetServiceName());
}
}
}
catch (Exception ex)
{
EventLogProvider.LogException("Settings", "RestartService", ex);
}
}
else
{
// Clear only cache portions
if (clearOutputCache)
{
CacheHelper.ClearFullPageCache();
}
if (clearCSSCache)
{
CacheHelper.ClearCSSCache();
}
if (clearPartialCache)
{
CacheHelper.ClearPartialCache();
}
}
}
