public SearchResults[] SearchTranslationUnitsMasked(SearchSettings settings, TranslationUnit[] translationUnits,
bool[] mask)
{
var sdlMtFileAndSegmentIds = new FileAndSegmentIds
{
FilePath = GetSdlXliffFilePath(translationUnits[0].FileProperties) ??
Path.GetFileName(translationUnits[0]?.FileProperties.FileConversionProperties.OriginalFilePath),
Segments = translationUnits.ToDictionary(tu => tu.DocumentSegmentPair.Properties.Id, tu => tu.SourceSegment.ToString())
};
if (translationUnits == null)
{
throw new ArgumentNullException(nameof(translationUnits), @"TranslationUnits in SearchSegmentsMasked");
}
if (mask == null || mask.Length != translationUnits.Length)
{
throw new ArgumentException("Mask in SearchSegmentsMasked");
}
_translationUnits.Clear();
_translationUnits.AddRange(translationUnits);
return(SearchSegments(translationUnits.Select(tu => tu?.SourceSegment).ToArray(), mask, sdlMtFileAndSegmentIds));
}
private static void RemoveSegmentsThatMustNotBeTranslated(FileAndSegmentIds fileAndSegmentIds, List <MTCloudSegment> mtCloudSegments)
{
var segmentEntries = new List <(SegmentId, string)>();
foreach (var index in mtCloudSegments.Select(seg => seg.Index))
{
var segmentId = fileAndSegmentIds.Segments.Keys.ElementAt((int)index);
segmentEntries.Add((segmentId, fileAndSegmentIds.Segments[segmentId]));
}
fileAndSegmentIds.Segments = segmentEntries.ToDictionary(se => se.Item1, se => se.Item2);
}
public Segment[] TranslateSegments(Segment[] sourceSegments, FileAndSegmentIds fileAndSegmentIds)
{
var xliffDocument = CreateXliffFile(sourceSegments);
var model = _translationProvider.Options.LanguageMappings?.FirstOrDefault(l =>
l.SourceTradosCode.Equals(_languageDirection?.SourceCulture?.Name, StringComparison.InvariantCultureIgnoreCase) &&
l.TargetTradosCode.Equals(_languageDirection?.TargetCulture?.Name, StringComparison.InvariantCultureIgnoreCase));
var targetSegments = Task.Run(async() => await _translationProvider.TranslationService.TranslateText(
xliffDocument.ToString(), model, fileAndSegmentIds)).Result;
return(targetSegments ?? new Segment[0]);
}
private bool GetTranslations(IReadOnlyList <MTCloudSegment> mtCloudSegments, FileAndSegmentIds fileAndSegmentIds)
{
var translations = TranslateSegments(mtCloudSegments.Select(segment => segment.Segment).ToArray(), fileAndSegmentIds);
if (translations.Any() && translations[0] != null)
{
for (var i = 0; i < mtCloudSegments.Count; i++)
{
mtCloudSegments[i].Translation = translations[i];
mtCloudSegments[i].SearchResult = CreateSearchResult(mtCloudSegments[i].Segment, translations[i]);
}
return(true);
}
return(false);
}
public async Task <Segment[]> TranslateText(string text, LanguageMappingModel model, FileAndSegmentIds fileAndSegments)
{
if (string.IsNullOrEmpty(model?.SelectedModel?.Model))
{
throw new Exception(PluginResources.Message_No_model_selected);
}
CheckConnection();
var uri = new Uri($"{Constants.MTCloudTranslateAPIUri}/v4/mt/translations/async");
var request = GetRequestMessage(HttpMethod.Post, uri);
var engineModel = model.SelectedModel.Model;
var translationRequestModel = new TranslationRequest
{
Input = new[] { text },
SourceLanguageId = model.SelectedSource.CodeName,
TargetLanguageId = model.SelectedTarget.CodeName,
Model = engineModel,
InputFormat = "xliff",
QualityEstimation = engineModel.ToLower().Contains("qe") ? 1 : 0
};
if (!model.SelectedDictionary.Name.Equals(PluginResources.Message_No_dictionary_available) &&
!model.SelectedDictionary.Name.Equals(PluginResources.Message_No_dictionary))
{
translationRequestModel.Dictionaries = new[] { model.SelectedDictionary?.DictionaryId };
}
var content = JsonConvert.SerializeObject(translationRequestModel);
request.Content = new StringContent(content, new UTF8Encoding(), "application/json");
var response = await _httpClient.SendRequest(request);
var translationResponse = await _httpClient.GetResult <TranslationResponse>(response);
if (response is null)
{
return(null);
}
var responseMessage = await CheckTranslationStatus(translationResponse?.RequestId);
var translations = await _httpClient.GetResult <TranslationResponse>(responseMessage);
var translation = translations?.Translation?.FirstOrDefault();
if (translation == null)
{
return(null);
}
var translatedXliff = Converter.ParseXliffString(translation);
if (translatedXliff == null)
{
return(null);
}
var targetSegments = translatedXliff.GetTargetSegments();
var segmentIds = fileAndSegments.Segments.Keys.ToList();
OnTranslationReceived(new TranslationData
{
TargetSegments =
segmentIds.Select((segmentId, index) => (segmentId, target: targetSegments[index].Segment.ToString())).ToDictionary(
x => x.segmentId,
x => x.target),
TranslationOriginData = new TranslationOriginData
{
Model = translations.Model,
QualityEstimations = segmentIds.Select((segmentId, index) => (segmentId, targetSegments[index].QualityEstimation))
/// <summary>
/// Translate an array of segments.
/// </summary>
/// <param name="segments">Array of segments to be translated (depending on the value of the
/// corresponding mask)</param>
/// <param name="mask">Whether to translate a segment or not</param>
/// <param name="fileAndSegmentIds"></param>
/// <param name="settings"></param>
/// <returns></returns>
public SearchResults[] SearchSegments(Segment[] segments, bool[] mask, FileAndSegmentIds fileAndSegmentIds = null)
{
var results = new SearchResults[segments.Length];
var mtCloudSegments = new List <MTCloudSegment>();
var alreadyTranslatedSegments = new List <MTCloudSegment>();
if (!_translationProvider.Options.ResendDraft)
{
// Re-send draft segment logic
for (var segmentIndex = 0; segmentIndex < segments.Length; segmentIndex++)
{
if (mask != null && !mask[segmentIndex])
{
results[segmentIndex] = null;
fileAndSegmentIds?.Segments.Remove(fileAndSegmentIds.Segments.Keys.ElementAt(segmentIndex));
continue;
}
var existsMergedSegments = CheckMergedSegments(results, CurrentSegmentPair, segmentIndex);
if (existsMergedSegments)
{
continue;
}
// Set translation unit based on segment index: when the first 10 segments are translated for the first time,
// then the TU index is the same as segment index
var correspondingTu = _translationUnits[segmentIndex];
var currentSegment = correspondingTu.TargetSegment == null
? CurrentSegmentPair
: correspondingTu.DocumentSegmentPair;
if (IsDraftOrTranslated(currentSegment) && !IsTargetEqualToSource(currentSegment))
{
alreadyTranslatedSegments.Add(CreateTranslatedSegment(segments, segmentIndex));
}
else
{
mtCloudSegments.Add(CreateMTCloudSegments(segments, segmentIndex));
}
}
if (mtCloudSegments.Count > 0)
{
var hasTranslations = GetTranslations(mtCloudSegments, fileAndSegmentIds);
if (hasTranslations)
{
SetSearchResults(results, mtCloudSegments);
}
}
if (alreadyTranslatedSegments.Count > 0)
{
SetSearchResults(results, alreadyTranslatedSegments);
}
}
else
{
var translations = TranslateSegments(segments.ToArray(), fileAndSegmentIds);
if (translations.Any(translation => translation != null))
{
var translationIndex = 0;
for (var i = 0; i < segments.Length; i++)
{
results[i] = new SearchResults();
if (segments[i] != null)
{
results[i].SourceSegment = segments[i].Duplicate();
results[i].Add(CreateSearchResult(segments[i], translations[translationIndex]));
translationIndex++;
}
else
{
results[i].SourceSegment = new Segment();
results[i].Add(CreateSearchResult(new Segment(), new Segment()));
}
}
}
}
return(results);
}
/// <summary>
/// Translate an array of segments.
/// </summary>
/// <param name="segments">Array of segments to be translated (depending on the value of the
/// corresponding mask)</param>
/// <param name="mask">Whether to translate a segment or not</param>
/// <param name="fileAndSegmentIds"></param>
/// <param name="settings"></param>
/// <returns></returns>
public SearchResults[] SearchSegments(Segment[] segments, bool[] mask, FileAndSegmentIds fileAndSegmentIds = null)
{
var results = new SearchResults[segments.Length];
var mtCloudSegments = new List <MTCloudSegment>();
var alreadyTranslatedSegments = new List <MTCloudSegment>();
if (!_translationProvider.Options.ResendDraft)
{
// Re-send draft segment logic
for (var segmentIndex = 0; segmentIndex < segments.Length; segmentIndex++)
{
if (mask != null && !mask[segmentIndex])
{
results[segmentIndex] = null;
continue;
}
var activeSegmentPair = _editorController?.ActiveDocument?.ActiveSegmentPair;
var existsMergedSegments = CheckMergedSegments(results, activeSegmentPair, segmentIndex);
if (existsMergedSegments)
{
continue;
}
// Set translation unit based on segment index: when the first 10 segments are translated for the first time,
// then the TU index is the same as segment index
var correspondingTu = _translationUnits[segmentIndex];
// If activeSegmentPair is not null, it means the user translates segments through Editor
// If activeSegmentPair is null, it means the user executes Pre-Translate Batch task, so he does not navigate through segments in editor
var documentLastOpenPath = _translationUnits[0]?.DocumentProperties?.LastOpenedAsPath;
if (documentLastOpenPath == null || documentLastOpenPath.Equals(_editorController?.ActiveDocument?.ActiveFile?.LocalFilePath))
{
if (activeSegmentPair != null && (activeSegmentPair.Target.Count > 0 || activeSegmentPair.Properties.IsLocked))
{
alreadyTranslatedSegments.Add(CreateTranslatedSegment(segments, segmentIndex));
}
// In case user copies the source to target and run the pre-translation, do nothing and continue the flow.
else if (correspondingTu != null && IsSameSourceTarget(correspondingTu))
{
// do nothing
}
// If is already translated or is locked, then the request to server should not be done and it should not be translated
else if (activeSegmentPair == null && correspondingTu != null && (correspondingTu.DocumentSegmentPair.Target.Count > 0 || correspondingTu.DocumentSegmentPair.Properties.IsLocked))
{
alreadyTranslatedSegments.Add(CreateTranslatedSegment(segments, segmentIndex));
}
else
{
mtCloudSegments.Add(CreateMTCloudSegments(segments, segmentIndex));
}
}
else
{
mtCloudSegments.Add(CreateMTCloudSegments(segments, segmentIndex));
}
}
if (mtCloudSegments.Count > 0)
{
var hasTranslations = GetTranslations(mtCloudSegments, fileAndSegmentIds);
if (hasTranslations)
{
SetSearchResults(results, mtCloudSegments);
}
}
if (alreadyTranslatedSegments.Count > 0)
{
SetSearchResults(results, alreadyTranslatedSegments);
}
}
else
{
var translations = TranslateSegments(segments.ToArray(), fileAndSegmentIds);
if (translations.Any(translation => translation != null))
{
var translationIndex = 0;
for (var i = 0; i < segments.Length; i++)
{
results[i] = new SearchResults();
if (segments[i] != null)
{
results[i].SourceSegment = segments[i].Duplicate();
results[i].Add(CreateSearchResult(segments[i], translations[translationIndex]));
translationIndex++;
}
else
{
results[i].SourceSegment = new Segment();
results[i].Add(CreateSearchResult(new Segment(), new Segment()));
}
}
}
}
return(results);
}
