public string MergeJson2Docx(JsonConversionData jsonFileData, DocxConversionData docxFileData)
{
string ResponseMessage = "fail";
if (jsonFileData.TotalStrings2Translate != docxFileData.TotalStrings2Translate)
{
return("MERGE FAILED: Docx file and Json file do not the same number of strings to merge.");
}
IEnumerable <string> DocxStrings = null;
try
{
//Merge Json data into Docx File.
DocxStrings = textMerger.Merge(jsonFileData, docxFileData);
}
catch (Exception e)
{
return(e.Message);
}
if (DocxStrings.Count() == jsonFileData.TotalStrings2Translate)
{
ResponseMessage = "Success";
}
return(ResponseMessage);
}
public void MergeJson2Docx_TranslatedStringsMatchJsonStringCountTest()
{
var resultStrings = new List <string>();
resultStrings.Add("Result string 1");
resultStrings.Add("Result string 2");
resultStrings.Add("Result string 3");
resultStrings.Add("Result string 4");
resultStrings.Add("Result string 5");
var mockTextMerger = new Mock <IDocxTextMerger>();
mockTextMerger.Setup(tb => tb.Merge(It.IsAny <JsonConversionData>(), It.IsAny <DocxConversionData>(), It.IsAny <bool>()))
.Returns(resultStrings);
var sut = new MergeService(mockTextMerger.Object);
var jsonFileData = new JsonConversionData(fullJsonTestFilePath)
{
TotalStrings2Translate = 5
};
var docxFileData = new DocxConversionData(fullDocxTestFilePath)
{
TotalStrings2Translate = 5
};
var result = sut.MergeJson2Docx(jsonFileData, docxFileData);
Assert.AreEqual(result, "Success");
}
public IEnumerable <string> Merge(JsonConversionData jsonFileData, DocxConversionData docxFileData, Boolean ignoreHidden = false)
{
if (docxFileData == null)
{
throw new ArgumentNullException("docxFileData", "DocxConversionData cannot be null.");
}
if (jsonFileData == null)
{
throw new ArgumentNullException("jsonFileData", "JsonFileData cannot be null.");
}
string docxConversionDataFullPath = docxFileData.FullPath;
using (WordprocessingDocument doc = WordprocessingDocument.Open(docxConversionDataFullPath, true))
{
var strings2Translate = textExtractionService.ExtractText(doc, ignoreHidden);
for (int j = 0; j < docxFileData.TotalStrings2Translate; j++)
{
int indexInDocument = j + 1;
var newValue = (string)jsonFileData.JsonData["lines"][j];
strings2Translate.Take(indexInDocument).Last().Text = newValue;
}
IEnumerable <string> outputStrings2Translate = strings2Translate.Select(text => text.Text);
return(outputStrings2Translate);
}
}
public void TestExportJson()
{
//make sure test files exist
TestingJsonFileTest();
TestingTestDocxFile();
var jsonIoService = new JsonIoService();
//Test Service Methods
DocxConversionData docxFileData = docxFileService.CreateCleanedCopy(FullDocxTestFilePath, false);
JsonConversionData jsonFileData = docxJsonService.ExportStringsToJsonFile(docxFileData);
File.Delete(jsonFileData.FullPath);
jsonIoService.SaveJson(jsonFileData);
Assert.AreEqual("Success", jsonFileData.Messages[0]);
//Validate Json being exported has a valid schema
Assert.IsTrue(File.Exists(jsonFileData.FullPath));
var rawFileContents = File.ReadAllLines(jsonFileData.FullPath);
Assert.IsNotNull(rawFileContents);
//Clean Up file that was created
File.Delete(docxFileData.FullPath);
File.Delete(jsonFileData.FullPath);
}
public Json2Docx(string fullJsonTestFilePath,
string fullDocxTestFilePath,
IDocxFileService docxFileService,
IDocxJsonService jsonService,
IMergeService mergeService)
{
JsonConversionData jsonFileData = jsonService.BuildJsonConversionData(fullJsonTestFilePath);
//Handle Errors
if (jsonFileData.Messages[0] != "Success")
{
Response = jsonFileData.Messages[0];
return;
}
DocxConversionData docxFileData = docxFileService.CreateCleanedCopy(fullDocxTestFilePath, false);
//Handle Errors
if (docxFileData.Messages[0] != "Success")
{
Response = docxFileData.Messages[0];
return;
}
Response = mergeService.MergeJson2Docx(jsonFileData, docxFileData);
if (Response == "Success")
{
//rename DocxFile
string docxConversionDataFullPath = docxFileData.FullPath;
string mergedFileName = docxFileData.GetTranslatedFullPath(DateTime.Now);
try
{
File.Move(docxConversionDataFullPath, mergedFileName);
if (File.Exists(mergedFileName))
{
FilePath = mergedFileName;
}
else
{
Response = "Error saving merged Docx file: " + mergedFileName;
}
}
catch (Exception e)
{
Response = e.Message;
}
}
}
public void MergeJson2Docx_TextBuilderExceptionHandledTest()
{
var exceptionMessage = "This is the exception message.";
var mockTextMerger = new Mock <IDocxTextMerger>();
mockTextMerger.Setup(tm => tm.Merge(It.IsAny <JsonConversionData>(), It.IsAny <DocxConversionData>(), It.IsAny <bool>()))
.Throws(new ArgumentNullException("docxFileData", exceptionMessage));
var sut = new MergeService(mockTextMerger.Object);
var jsonFileData = new JsonConversionData(fullJsonTestFilePath);
var docxFileData = new DocxConversionData(fullDocxTestFilePath);
var result = sut.MergeJson2Docx(jsonFileData, docxFileData);
Assert.AreEqual(0, result.IndexOf(exceptionMessage));
}
public void TestBuildDocxConversionData()
{
//Make sure Test File Exists
TestingTestDocxFile();
//Test Service Method
DocxConversionData docxFileData = docxFileService.CreateCleanedCopy(FullDocxTestFilePath, false);
Assert.IsNotNull(docxFileData);
Assert.AreEqual("Success", docxFileData.Messages[0]);
Assert.IsTrue(docxFileData.TotalStrings2Translate > 0);
Assert.IsTrue(File.Exists(docxFileData.FullPath));
//Clean Up file that was created
File.Delete(docxFileData.FullPath);
}
public void TestMergeJson2Docx()
{
//make sure test files exist
TestingJsonFileTest();
TestingTestDocxFile();
JsonConversionData jsonFileData = docxJsonService.BuildJsonConversionData(FullJsonTestFilePath);
DocxConversionData docxFileData = docxFileService.CreateCleanedCopy(FullDocxTestFilePath, false);
var mergeService = new MergeService(new DocxTextMerger(new DocumentTextRunExtractionService()));
string ResponseMessage = mergeService.MergeJson2Docx(jsonFileData, docxFileData);
Assert.AreEqual(ResponseMessage, "Success");
Assert.IsTrue(File.Exists(docxFileData.FullPath));
//Clean Up file that was created
File.Delete(docxFileData.FullPath);
}
public JsonConversionData ExportStringsToJsonFile(DocxConversionData docxFileData)
{
if (docxFileData == null)
{
throw new ArgumentNullException("The DocxConversionData cannot be null.");
}
JsonConversionData jsonFileData = new JsonConversionData(docxFileData.FullPath);
//Validate there is something to convert/translate in the Docx file
if (docxFileData.Strings2Translate?.Count() == 0)
{
jsonFileData.Messages.Add("Docx File is Empty and has nothing to translate");
return(jsonFileData);
}
jsonFileData.JsonData = JObject.Parse(@"{
'id': 'spf.io_convertion_data',
'timestamp': " + DateTime.Now.ToString("yyyyMMddHHmmssffff") + @",
'extractedFrom': '" + docxFileData.FileName + docxFileData.FileExtension + @"',
'lines': []
}");
JArray JsonLineArray = (JArray)jsonFileData.JsonData["lines"];
foreach (string TranslationString in docxFileData.Strings2Translate)
{
JsonLineArray.Add(TranslationString);
}
jsonFileData.TotalStrings2Translate = jsonFileData.JsonData["lines"].Count();
//Validate there is something to convert/translate in the Docx file
if (docxFileData.TotalStrings2Translate == jsonFileData.TotalStrings2Translate)
{
jsonFileData.Messages.Add("Success");
}
else
{
jsonFileData.Messages.Add("The creation of the Json Data from the docx file failed.");
}
return(jsonFileData);
}
public void MergeJson2Docx_EnsureStringCountsMatchTest()
{
var mockTextMerger = new Mock <IDocxTextMerger>();
var sut = new MergeService(mockTextMerger.Object);
var jsonFileData = new JsonConversionData(fullJsonTestFilePath)
{
TotalStrings2Translate = 5
};
var docxFileData = new DocxConversionData(fullDocxTestFilePath)
{
TotalStrings2Translate = 3
};
var result = sut.MergeJson2Docx(jsonFileData, docxFileData);
Assert.AreEqual(result.IndexOf("MERGE FAILED"), 0);
}
public void TestConvertDocx2Json()
{
//make sure test files exist
TestingTestDocxFile();
//Valid Schema for Json Data to be exported exported
//NOTE: I used https://jsonschema.net/ to help me build the schema
JsonSchema schema = JsonSchema.Parse(ValueRepository.JsonSchema);
//Test Service Methods
DocxConversionData docxFileData = docxFileService.CreateCleanedCopy(FullDocxTestFilePath, false);
JsonConversionData jsonFileData = docxJsonService.ExportStringsToJsonFile(docxFileData);
Assert.AreEqual("Success", jsonFileData.Messages[0]);
//Validate Json being exported has a valid schema
Assert.IsTrue(jsonFileData.JsonData.IsValid(schema));
//Validate that exported Json contains the same number of strings to be translated
Assert.AreEqual(jsonFileData.TotalStrings2Translate, docxFileData.TotalStrings2Translate);
//Clean Up file that was created
File.Delete(docxFileData.FullPath);
}
public JsonConversionData ExtractStringsToJsonFile(string fullFilePath)
{
if (string.IsNullOrEmpty(fullFilePath))
{
throw new ArgumentOutOfRangeException("The file path cannot be null or empty.");
}
//Extract Docx data out information from Docx file
DocxConversionData cleanedDocxFileData = docxFileService.CreateCleanedCopy(fullFilePath, true);
//Handle Errors
if (cleanedDocxFileData.Messages[0] != "Success")
{
var errorResult = new JsonConversionData(fullFilePath);
errorResult.Messages.Add(cleanedDocxFileData.Messages[0]);
return(errorResult);
}
// We don't need the "cleaned" copy of the docx any longer, so delete it
if (File.Exists(cleanedDocxFileData.FullPath))
{
File.Delete(cleanedDocxFileData.FullPath);
}
// We want the json file we create to have the same name as the original file, so
// restore the original path in our data object
var origFileData = new DocxConversionData(fullFilePath)
{
TotalStrings2Translate = cleanedDocxFileData.TotalStrings2Translate,
Strings2Translate = cleanedDocxFileData.Strings2Translate
};
origFileData.Messages.AddRange(cleanedDocxFileData.Messages);
//translate data to target language
List <string> TranslatedStrings = new List <string>();
foreach (string line in origFileData.Strings2Translate)
{
string TranslatedLine = TextTranslator.TranslateText(line, "es", "en");
TranslatedStrings.Add(TranslatedLine);
}
origFileData.Strings2Translate = (IEnumerable <string>)TranslatedStrings;
//Convert docx data to json data
JsonConversionData jsonFileData = docxJSonService.ExportStringsToJsonFile(origFileData);
//Handle Errors
//if (jsonFileData.Messages[0] != "Success")
//{
// return jsonFileData;
//}
//Delete any Json file that might have the same name as the new one we are creating.
if (File.Exists(jsonFileData.FullPath))
{
try
{
File.Delete(jsonFileData.FullPath);
}
catch (Exception e)
{
var errorResult = new JsonConversionData(fullFilePath);
errorResult.Messages.Add(e.Message);
return(errorResult);
}
}
//Export Json data to file
var result = jsonIoService.SaveJson(jsonFileData);
//Handle Errors
if (result != "Success")
{
jsonFileData.Messages.Insert(0, "Failed");
}
return(jsonFileData);
}
public DocxConversionData CreateCleanedCopy(string fullPath, bool ignoreHidden)
{
if (string.IsNullOrEmpty(fullPath))
{
throw new ArgumentNullException("path variable cannot be null or empty");
}
// ensure we have a valid path to a docx file
if (!validator.IsValid(fullPath))
{
return(null);
}
var origFileData = new DocxConversionData(fullPath);
var cleanedFileName = origFileData.FileName + "_cleaned" + origFileData.FileExtension;
var cleanedFileData = new DocxConversionData(Path.Join(origFileData.FilePath, cleanedFileName));
try
{
// ensure there is not an orphaned copy already on disk
File.Delete(cleanedFileData.FullPath);
// Make a copy of the original using the "cleaned" file name
File.Copy(origFileData.FullPath, cleanedFileData.FullPath);
//Clean Document of extra tags
using (WordprocessingDocument doc = WordprocessingDocument.Open(cleanedFileData.FullPath, true))
{
OpenXmlPowerTools.SimplifyMarkupSettings settings = new OpenXmlPowerTools.SimplifyMarkupSettings
{
AcceptRevisions = true,
NormalizeXml = false, //setting this to false reduces translation quality, but if true some documents have XML format errors when opening
RemoveBookmarks = true,
RemoveComments = true,
RemoveContentControls = true,
RemoveEndAndFootNotes = true,
RemoveFieldCodes = false, //FieldCode remove pagination
RemoveGoBackBookmark = true,
//RemoveHyperlinks = false,
RemoveLastRenderedPageBreak = true,
RemoveMarkupForDocumentComparison = true,
RemovePermissions = false,
RemoveProof = true,
RemoveRsidInfo = true,
RemoveSmartTags = true,
RemoveSoftHyphens = true,
RemoveWebHidden = true,
ReplaceTabsWithSpaces = false
};
OpenXmlPowerTools.MarkupSimplifier.SimplifyMarkup(doc, settings);
//Extract Strings for translation
var textBlocks = textExtractor.ExtractText(doc, ignoreHidden);
//var textBlocks = textExtractor.ExtractParagraph(doc, ignoreHidden);
cleanedFileData.Strings2Translate = textBlocks.Select(para => para.InnerText);
}
//Total the number of strings for translation
cleanedFileData.TotalStrings2Translate = cleanedFileData.Strings2Translate.Count();
if (File.Exists(cleanedFileData.FullPath))
{
cleanedFileData.Messages.Add("Success");
}
else
{
cleanedFileData.Messages.Add("Docx data failed to build properly.");
}
}
catch (Exception e)
{
cleanedFileData.Messages.Add(e.Message);
}
return(cleanedFileData);
}
