public void GetSegments_TaggedText_SameAsSource()
{
var segments = Parser.ParseFile(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TaggedFile.txt"));
var file = new File
{
SourceCulture = CultureInfo.GetCultureInfo("en-us"),
TargetCulture = CultureInfo.GetCultureInfo("fr")
};
var xliff = new Xliff
{
File = file
};
foreach (var segment in segments)
{
xliff.AddTranslation(segment, segment, "MTEdge");
}
var targetSegments = xliff.GetTargetSegments();
for (int i = 0; i < segments.Length; i++)
{
Assert.AreEqual(segments[i].ToString(), targetSegments[i].ToString());
}
}
private static void UpdateTransUnitContextInfo(Xliff xliff)
{
foreach (var file in xliff.Files)
{
foreach (var transUnit in file.Body.TransUnits)
{
if (transUnit.Contexts.Count <= 0)
{
continue;
}
foreach (var context in transUnit.Contexts)
{
var existingContext = file.Header.Contexts.FirstOrDefault(a => a.Id == context.Id);
if (existingContext != null)
{
context.ContextType = existingContext.ContextType;
context.DisplayName = existingContext.DisplayName;
context.DisplayCode = existingContext.DisplayCode;
context.Description = existingContext.Description;
context.MetaData = existingContext.MetaData;
}
}
}
}
}
public Xliff ReadXliff(string filePath)
{
var xliff = new Xliff();
var xmlTextReader = new XmlTextReader(filePath);
var xmlReaderSettings = new XmlReaderSettings
{
ValidationType = ValidationType.None,
IgnoreWhitespace = true,
IgnoreComments = true
};
using (var xmlReader = XmlReader.Create(xmlTextReader, xmlReaderSettings))
{
var index = 0;
while (xmlReader.Read())
{
switch (xmlReader.NodeType)
{
case XmlNodeType.Element:
if (index == 0 && string.Compare(xmlReader.Name, "xliff", StringComparison.OrdinalIgnoreCase) == 0)
{
index++;
while (xmlReader.MoveToNextAttribute())
{
if (string.Compare(xmlReader.Name, "version", StringComparison.OrdinalIgnoreCase) == 0)
{
xliff.Version = xmlReader.Value;
}
else if (string.Compare(xmlReader.Name, NsPrefix + ":support", StringComparison.OrdinalIgnoreCase) == 0)
{
var success = Enum.TryParse(xmlReader.Value, true, out Enumerators.XLIFFSupport support);
xliff.Support = success ? support : Enumerators.XLIFFSupport.none;
}
else if (string.Compare(xmlReader.Name, NsPrefix + ":version", StringComparison.OrdinalIgnoreCase) == 0)
{
xliff.SpecificVersion = xmlReader.Value;
}
}
}
else if (string.Compare(xmlReader.Name, NsPrefix + ":doc-info", StringComparison.OrdinalIgnoreCase) == 0)
{
var xmlReaderSub = xmlReader.ReadSubtree();
xliff.DocInfo = ReadDocInfo(xmlReaderSub);
xmlReaderSub.Close();
}
else if (string.Compare(xmlReader.Name, "file", StringComparison.OrdinalIgnoreCase) == 0)
{
var xmlReaderSub = xmlReader.ReadSubtree();
xliff.Files.Add(ReadFile(xmlReaderSub));
xmlReaderSub.Close();
}
break;
}
}
}
xliff.DocInfo.Comments = Comments;
return(xliff);
}
private Dictionary <string, List <string> > GetParagraphMap(Xliff xliffData)
{
var paragraphMap = new Dictionary <string, List <string> >();
foreach (var file in xliffData.Files)
{
foreach (var transUnit in file.Body.TransUnits)
{
if (paragraphMap.ContainsKey(transUnit.Id))
{
continue;
}
var segmentIds = new List <string>();
foreach (var segmentPair in transUnit.SegmentPairs)
{
segmentIds.Add(segmentPair.Id);
}
paragraphMap.Add(transUnit.Id, segmentIds);
}
}
return(paragraphMap);
}
public void ETSApi_FetchTranslationNoTags_ValidTranslation()
{
var xliffDocument = new Xliff(engFraLP.SourceCulture, engFraLP.TargetCulture);
xliffDocument.AddSourceText(StringResource.BasicText);
var translatedXliffText = ETSTranslatorHelper.GetTranslation(apiKeyTranslationOptions, engFraLP, xliffDocument);
var translatedXliff = Sdl.Community.Toolkit.LanguagePlatform.XliffConverter.Converter.ParseXliffString(translatedXliffText);
Assert.IsTrue(translatedXliff.GetTargetSegments().Any());
Assert.AreEqual(
StringResource.BasicTranslation,
translatedXliff.GetTargetSegments()[0].ToString());
var token = ETSTranslatorHelper.GetAuthToken(basicAuthTranslationOptions, userCredentials);
basicAuthTranslationOptions.ApiToken = token;
translatedXliffText = ETSTranslatorHelper.GetTranslation(basicAuthTranslationOptions, engFraLP, xliffDocument);
translatedXliff = Sdl.Community.Toolkit.LanguagePlatform.XliffConverter.Converter.ParseXliffString(translatedXliffText);
Assert.IsTrue(translatedXliff.GetTargetSegments().Any());
Assert.AreEqual(
StringResource.BasicTranslation,
translatedXliff.GetTargetSegments()[0].ToString());
}
/// <summary>
/// Get the translation of an xliff file using the ETS API.
/// </summary>
/// <param name="options"></param>
/// <param name="languageDirection"></param>
/// <param name="xliffFile"></param>
/// <returns></returns>
public static string GetTranslation(TranslationOptions options,
LanguagePair languageDirection,
Xliff xliffFile)
{
Log.Logger.Trace("");
var text = xliffFile.ToString();
var queryString = HttpUtility.ParseQueryString(string.Empty);
var encodedInput = text.Base64Encode();
lock (optionsLock)
{
if (options.ApiVersion == APIVersion.Unknown)
{
SetETSApiVersion(options);
}
}
if (options.ApiVersion == APIVersion.v1)
{
queryString["sourceLanguageId"] = languageDirection.SourceCulture.ToETSCode();
queryString["targetLanguageId"] = languageDirection.TargetCulture.ToETSCode();
queryString["text"] = encodedInput;
}
else
{
// If LPPreferences doesn't contain the target language (source is always the same), figure out the
// preferred LP. Previously set preferred LPs will stay, so this won't get run each time if you have
// multiple LPs.
if (!options.LPPreferences.ContainsKey(languageDirection.TargetCulture))
{
options.SetPreferredLanguages(new LanguagePair[] { languageDirection });
if (!options.LPPreferences.ContainsKey(languageDirection.TargetCulture))
{
throw new Exception("There are no language pairs currently accessible via ETS.");
}
}
queryString["languagePairId"] = options.LPPreferences[languageDirection.TargetCulture].LanguagePairId;
queryString["input"] = encodedInput;
}
queryString["inputFormat"] = "application/x-xliff";
Log.Logger.Debug("Sending translation request for: {0}", encodedInput);
string jsonResult;
try
{
jsonResult = ContactETSServer(ETSPost, options, "translations/quick", queryString);
}
catch (Exception e)
{
Log.Logger.Error($"{Constants.Translation}: {e.Message}\n {e.StackTrace}\n Encoded Input: {encodedInput}");
throw;
}
var encodedTranslation = JsonConvert.DeserializeObject <ETSTranslationOutput>(jsonResult).Translation;
var decodedTranslation = encodedTranslation.Base64Decode();
Log.Logger.Debug("Resultant translation is: {0}", encodedTranslation);
return(decodedTranslation);
}
public void GetSegments_NoTarget_NullTargetSegments()
{
var segments = Parser.ParseFile(
Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TaggedFile.txt"));
var file = new File
{
SourceCulture = CultureInfo.GetCultureInfo("en-us"),
TargetCulture = CultureInfo.GetCultureInfo("fr")
};
var xliff = new Xliff
{
File = file
};
foreach (var segment in segments)
{
xliff.AddSourceSegment(segment);
}
var targetSegments = xliff.GetTargetSegments();
foreach (var segment in targetSegments)
{
Assert.IsNull(segment);
}
}
public void MTEdgeApi_FetchTranslationNoTags_ValidTranslation()
{
var file = new File
{
SourceCulture = engFraLP.SourceCulture,
TargetCulture = engFraLP.TargetCulture
};
var xliffDocument = new Xliff
{
File = file
};
xliffDocument.AddSourceText(UTStringResource.BasicText);
var translatedXliffText = SDLMTEdgeTranslatorHelper.GetTranslation(apiKeyTranslationOptions, engFraLP, xliffDocument);
var translatedXliff = Converter.ParseXliffString(translatedXliffText);
Assert.IsTrue(translatedXliff.GetTargetSegments().Any());
Assert.AreEqual(UTStringResource.BasicTranslation, translatedXliff.GetTargetSegments()[0].ToString());
var token = SDLMTEdgeTranslatorHelper.GetAuthToken(basicAuthTranslationOptions, userCredentials);
basicAuthTranslationOptions.ApiToken = token;
translatedXliffText = SDLMTEdgeTranslatorHelper.GetTranslation(basicAuthTranslationOptions, engFraLP, xliffDocument);
translatedXliff = Converter.ParseXliffString(translatedXliffText);
Assert.IsTrue(translatedXliff.GetTargetSegments().Any());
Assert.AreEqual(UTStringResource.BasicTranslation, translatedXliff.GetTargetSegments()[0].ToString());
}
public void ETSApi_FetchTranslation_InvalidTranslation()
{
var xliffDocument = new Xliff(engFraLP.SourceCulture, engFraLP.TargetCulture);
xliffDocument.AddSourceText(StringResource.BasicText);
ETSTranslatorHelper.GetTranslation(apiKeyTranslationOptions, engInvLP, xliffDocument);
}
public bool WriteFile(Xliff xliff, string outputFilePath, bool includeTranslations)
{
if (_writer == null)
{
return(false);
}
return(_writer.WriteFile(xliff, outputFilePath, includeTranslations));
}
public static string Serialize(Xliff ObjectToSerialize)
{
XmlSerializer xmlSerializer = new XmlSerializer(ObjectToSerialize.GetType());
using (StringWriter textWriter = new StringWriter())
{
xmlSerializer.Serialize(textWriter, ObjectToSerialize);
return(textWriter.ToString());
}
}
private void WriteCommentDefinitions(Xliff xliff, XmlWriter writer)
{
writer.WriteStartElement(NsPrefix, "cmt-defs", null);
foreach (var comments in xliff.DocInfo.Comments)
{
WriteCommentDefinition(writer, comments);
}
writer.WriteEndElement(); //cmt-defs
}
private void AlignParagraphIds(Xliff xliffData, IReadOnlyList <string> paragraphIds)
{
var i = 0;
foreach (var file in xliffData.Files)
{
foreach (var transUnit in file.Body.TransUnits)
{
transUnit.Id = paragraphIds[i++];
}
}
}
public ContentWriter(Xliff xliff, SegmentBuilder segmentBuilder,
ImportOptions importOptions, List <AnalysisBand> analysisBands)
{
_xliff = xliff;
_segmentBuilder = segmentBuilder;
_importOptions = importOptions;
_analysisBands = analysisBands;
Comments = _xliff.DocInfo.Comments;
ConfirmationStatistics = new ConfirmationStatistics();
TranslationOriginStatistics = new TranslationOriginStatistics();
}
static void Main()
{
/// RotorEnigma Ia = RotorEnigma.I;
/// Ia.InitialPosition = Ia.OperatingAlphabet[5];
/// Hexa h = new Hexa(byte.MaxValue);
///
/// Enigma enigma1 = new Enigma(Reflector.B, Ia, RotorEnigma.II, RotorEnigma.VIII);
/// enigma1.ToString();
/// string test = enigma1.Process("HELLO WORLD !");
/// enigma1.Reset();
/// string rslt0 = enigma1.Process(test);
///
/// Enigma enigma3 = enigma1.Clone(true);
/// string rslt3 = enigma3.Process(test);
string[] tbl = new string[] {
HashKey.DigestFile(HashAlgorithmEnum.MD5, "XLIFF_2.xlf"),
HashKey.DigestFile(HashAlgorithmEnum.SHA1, "XLIFF_2.xlf"),
HashKey.DigestFile(HashAlgorithmEnum.SHA256, "XLIFF_2.xlf"),
HashKey.DigestFile(HashAlgorithmEnum.SHA384, "XLIFF_2.xlf"),
HashKey.DigestFile(HashAlgorithmEnum.SHA512, "XLIFF_2.xlf"),
HashKey.DigestFile(HashAlgorithmEnum.KeyedHashAlgorithm, "XLIFF_2.xlf"),
HashKey.DigestFile(HashAlgorithmEnum.RIPEMD160, "XLIFF_2.xlf"),
};
Chromatik.Unicode.Unicode.Load("en");
tbl.ForEach(Incremente);
//System.Globalization.Localization.QtTranslation trs = System.Globalization.Localization.QtTranslation.LoadTranslation(@"for_translation_sigil_sigil_fr.ts.xml");
//trs.Save("test.ts.xml");
;
Xliff xliff = Xliff.LoadXliff("XLIFF_2.xlf");
string fI = xliff.IDs[1];
XliffFile fS = xliff.Identifieds[1];
xliff[0].ID = "f3";
xliff[0].ID = "f2";
XmlDocument xml = XmlDocumentCreate.DocumentXML("<xml><span>kkkkkkk</span> <span de=\"\">yyyy</span><i> 65246541 </i><span>sdfwsfd</span></xml>");
XmlDocumentWriter.Document("test.0.xml", xml, DocumentType.HTML5);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
public void MTEdgeApi_FetchTranslationEmoji_ValidTranslation()
{
var xliffDocument = new Xliff(engFraLP.SourceCulture, engFraLP.TargetCulture);
xliffDocument.AddSourceText(UTStringResource.BasicEmojiTest);
xliffDocument.Version = "v1.0";
var translatedXliffText = SDLMTEdgeTranslatorHelper.GetTranslation(apiKeyTranslationOptions, engFraLP, xliffDocument);
var translatedXliff = Toolkit.LanguagePlatform.XliffConverter.Converter.ParseXliffString(translatedXliffText);
Assert.IsTrue(translatedXliff.GetTargetSegments().Any());
Assert.AreEqual(UTStringResource.BasicEmojiTranslation, translatedXliff.GetTargetSegments()[0].ToString());
}
public void ETSApi_FetchTranslationEmoji_ValidTranslation()
{
var xliffDocument = new Xliff(engFraLP.SourceCulture, engFraLP.TargetCulture, encodeUtf16: true);
xliffDocument.AddSourceText(StringResource.BasicEmojiTest);
var translatedXliffText = ETSTranslatorHelper.GetTranslation(apiKeyTranslationOptions, engFraLP, xliffDocument);
var translatedXliff = Sdl.Community.Toolkit.LanguagePlatform.XliffConverter.Converter.ParseXliffString(translatedXliffText);
Assert.IsTrue(translatedXliff.GetTargetSegments().Any());
Assert.AreEqual(StringResource.BasicEmojiTranslation, translatedXliff.GetTargetSegments()[0].ToString());
}
private void WriteDocInfo(Xliff xliff, XmlWriter writer)
{
writer.WriteStartElement(NsPrefix, "doc-info", null);
writer.WriteAttributeString("project-id", xliff.DocInfo.ProjectId);
writer.WriteAttributeString("document-id", xliff.DocInfo.DocumentId);
writer.WriteAttributeString("source", xliff.DocInfo.Source);
writer.WriteAttributeString("source-language", xliff.DocInfo.SourceLanguage);
writer.WriteAttributeString("target-language", xliff.DocInfo.TargetLanguage);
writer.WriteAttributeString("created", GetDateToString(xliff.DocInfo.Created));
writer.WriteEndElement(); //doc-info
}
public Xliff CreateXliffFile(Segment[] segments)
{
var xliffDocument = new Xliff(SourceLanguage, TargetLanguage);
foreach (var seg in segments)
{
if (seg != null)
{
xliffDocument.AddSourceSegment(seg);
}
}
return(xliffDocument);
}
public bool WriteFile(Xliff xliff, string outputFilePath, bool includeTranslations)
{
Comments = xliff.DocInfo.Comments;
IncludeTranslations = includeTranslations;
UpdateGenericPlaceholdersIds(xliff);
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = false,
Indent = false
};
var version = "1.2";
var sdlSupport = Enumerators.XLIFFSupport.xliff12sdl.ToString();
var sdlVersion = version + ".1";
using (var writer = XmlWriter.Create(outputFilePath, settings))
{
writer.WriteStartElement("xliff");
writer.WriteAttributeString("version", version);
writer.WriteAttributeString("xmlns", NsPrefix, null, "http://schemas.sdl.com/xliff");
writer.WriteAttributeString(NsPrefix, "support", null, sdlSupport);
writer.WriteAttributeString(NsPrefix, "version", null, sdlVersion);
WriteDocInfo(xliff, writer);
foreach (var xliffFile in xliff.Files)
{
writer.WriteStartElement("file");
writer.WriteAttributeString("original", xliffFile.Original);
writer.WriteAttributeString("source-language", xliffFile.SourceLanguage);
if (includeTranslations)
{
writer.WriteAttributeString("target-language", xliffFile.TargetLanguage);
}
//writer.WriteAttributeString("datatype", xliffFile.DataType);
writer.WriteAttributeString("datatype", "xml");
WriterFileHeader(writer, xliffFile);
WriteFileBody(writer, xliffFile);
writer.WriteEndElement(); // file
}
writer.WriteEndElement(); //xliff
}
return(true);
}
/// <summary>
/// Prepares a source translation string for request. It ultimately removes all the tags data,
/// storing them temporarily in a dictionary, which then can be used to reinstate the tags' text.
/// Function taken from previous ETS Plugin.
/// </summary>
/// <param name="segments"></param>
/// <returns>Xliff</returns>
public Xliff CreateXliffFile(Segment[] segments)
{
Log.Logger.Trace("");
var xliffDocument = new Xliff(languageDirection.SourceCulture, languageDirection.TargetCulture);
foreach (var seg in segments)
{
if (seg != null)
{
xliffDocument.AddSourceSegment(seg);
}
}
return(xliffDocument);
}
public void AddSourceText_NullSourceText_ThrowsException()
{
var file = new File
{
SourceCulture = CultureInfo.GetCultureInfo("en-us"),
TargetCulture = CultureInfo.GetCultureInfo("fr")
};
var xliff = new Xliff
{
File = file
};
xliff.AddSourceText(null);
}
internal ContentReader(string projectId, string inputPath, bool ignoreTags, SegmentBuilder segmentBuilder,
ExportOptions exportOptions, List <AnalysisBand> analysisBands)
{
_projectId = projectId;
_inputPath = inputPath;
_ignoreTags = ignoreTags;
_segmentBuilder = segmentBuilder;
_exportOptions = exportOptions;
_analysisBands = analysisBands;
Xliff = new Xliff();
ConfirmationStatistics = new ConfirmationStatistics();
TranslationOriginStatistics = new TranslationOriginStatistics();
}
public void AddTranslation_NullSourceSegment_ThrowsException()
{
var file = new File
{
SourceCulture = CultureInfo.GetCultureInfo("en-us"),
TargetCulture = CultureInfo.GetCultureInfo("fr")
};
var xliff = new Xliff
{
File = file
};
xliff.AddTranslation(null, new Segment(xliff.File.SourceCulture), "MTEdge");
}
public bool UpdateFile(Xliff xliff, string filePathInput, string filePathOutput)
{
var converter = _fileTypeManager.GetConverterToDefaultBilingual(filePathInput, filePathOutput, null);
var contentWriter = new ContentWriter(xliff, _segmentBuilder, _importOptions, _analysisBands);
converter.AddBilingualProcessor(contentWriter);
converter.SynchronizeDocumentProperties();
converter.Parse();
ConfirmationStatistics = contentWriter.ConfirmationStatistics;
TranslationOriginStatistics = contentWriter.TranslationOriginStatistics;
return(true);
}
public XliffContentWriter(Xliff xliff, SegmentBuilder segmentBuilder,
ImportOptions importOptions, List <AnalysisBand> analysisBands, List <string> tagIds,
bool importBackTranslations)
{
_xliff = xliff;
_segmentBuilder = segmentBuilder;
_importOptions = importOptions;
_analysisBands = analysisBands;
_importBackTranslations = importBackTranslations;
_segmentBuilder.ExistingTagIds = tagIds;
Comments = _xliff.DocInfo.Comments ?? new Dictionary <string, List <IComment> >();
ConfirmationStatistics = new ConfirmationStatistics();
TranslationOriginStatistics = new TranslationOriginStatistics();
}
public void MTEdgeApi_FetchTranslation_InvalidTranslation()
{
var file = new File
{
SourceCulture = engFraLP.SourceCulture,
TargetCulture = engFraLP.TargetCulture
};
var xliffDocument = new Xliff
{
File = file
};
xliffDocument.AddSourceText(UTStringResource.BasicText);
SDLMTEdgeTranslatorHelper.GetTranslation(apiKeyTranslationOptions, engInvLP, xliffDocument);
}
private void UpdateGenericPlaceholderIds(Xliff xliff)
{
var lastId = 0;
foreach (var xliffFile in xliff.Files)
{
foreach (var transUnit in xliffFile.Body.TransUnits)
{
foreach (var segmentPair in transUnit.SegmentPairs)
{
var ids = new List <int>();
foreach (var element in segmentPair.Source.Elements)
{
if (element is ElementGenericPlaceholder genericPlaceholder)
{
ids.Add(++lastId);
genericPlaceholder.TagId = string.Format("lb{0}", lastId);
}
}
var targetLbIndex = 0;
foreach (var element in segmentPair.Target.Elements)
{
if (element is ElementGenericPlaceholder genericPlaceholder)
{
int id;
if (targetLbIndex < ids.Count)
{
id = ids[targetLbIndex];
}
else
{
ids.Add(++lastId);
id = lastId;
}
targetLbIndex++;
genericPlaceholder.TagId = string.Format("x{0}", id);
}
}
}
}
}
}
public bool UpdateFile(Xliff xliff, string filePathInput, string filePathOutput, bool importBackTranslations = false)
{
var fileTypeManager = DefaultFileTypeManager.CreateInstance(true);
var converter = fileTypeManager.GetConverterToDefaultBilingual(filePathInput, filePathOutput, null);
var tagIds = GetTagIds(filePathInput);
var contentWriter = new XliffContentWriter(xliff, _segmentBuilder, _importOptions, _analysisBands, tagIds, importBackTranslations);
converter.AddBilingualProcessor(contentWriter);
converter.SynchronizeDocumentProperties();
converter.Parse();
ConfirmationStatistics = contentWriter.ConfirmationStatistics;
TranslationOriginStatistics = contentWriter.TranslationOriginStatistics;
return(true);
}
private bool ContainsEmptyTranslations(Xliff data)
{
foreach (var file in data.Files)
{
foreach (var transUnit in file.Body.TransUnits)
{
if ((from segmentPair in transUnit.SegmentPairs
let sourceText = GetSegmentText(segmentPair.Source.Elements, true)
let targetText = GetSegmentText(segmentPair.Target.Elements, true)
where !string.IsNullOrWhiteSpace(sourceText) || !string.IsNullOrWhiteSpace(targetText)
select targetText).Any(string.IsNullOrWhiteSpace))
{
return(true);
}
}
}
return(false);
}
