public void TestMakeHtmlContentProcessedInnerTableCell()
{
const string HtmlContent = @"<p>Html test</p>";
const string HtmlEscapedString = @"
<html>
<head/>
<body>
<p>Html test</p>
</body>
</html>
";
var tablecell = new XElement(WordMl.TableCellName, new XElement(WordMl.ParagraphName, "//test/path"));
var htmlContentTag = new XElement(
WordMl.SdtName,
new XElement(
WordMl.SdtPrName, new XElement(
WordMl.TagName,
new XAttribute(WordMl.ValAttributeName, "htmlcontent"))),
new XElement(
WordMl.SdtContentName, tablecell));
var document = new XElement(WordMl.BodyName, htmlContentTag);
var actualProcessedElement = HtmlContentProcessor.MakeHtmlContentProcessed(htmlContentTag, HtmlEscapedString);
Assert.AreEqual(tablecell.Name, actualProcessedElement.Name);
Assert.IsNotNull(actualProcessedElement.Element(WordMl.SdtName));
Assert.AreEqual(HtmlContentProcessor.ProcessedHtmlContentTagName,
actualProcessedElement.Element(WordMl.SdtName)
.Element(WordMl.SdtPrName)
.Element(WordMl.TagName)
.Attribute(WordMl.ValAttributeName)
.Value);
Assert.AreEqual(HttpUtility.HtmlDecode(HtmlEscapedString), actualProcessedElement.Element(WordMl.SdtName).Element(WordMl.SdtContentName).Value);
}
public void TestMakeHtmlContentProcessed()
{
const string HtmlContent = @"<p>Html test</p>";
const string HtmlEscapedString = @"
<html>
<head/>
<body>
<p>Html test</p>
</body>
</html>
";
var htmlContentTag = new XElement(
WordMl.SdtName,
new XElement(
WordMl.SdtPrName, new XElement(
WordMl.TagName,
new XAttribute(WordMl.ValAttributeName, "htmlcontent"))),
new XElement(
WordMl.SdtContentName, HtmlEscapedString));
var body = new XElement(WordMl.BodyName, htmlContentTag);
var actualProcessedElement = HtmlContentProcessor.MakeHtmlContentProcessed(htmlContentTag, htmlContentTag.GetExpression());
Assert.IsNotNull(actualProcessedElement);
Assert.AreEqual(HtmlContentProcessor.ProcessedHtmlContentTagName,
actualProcessedElement.Element(WordMl.SdtPrName)
.Element(WordMl.TagName)
.Attribute(WordMl.ValAttributeName)
.Value);
Assert.AreEqual(HtmlEscapedString, HtmlEscapedString);
}
public virtual void ReplaceAltChunks()
{
var document = PartXml.Document;
var htmlChunks = HtmlContentProcessor.GenerateAltChunks(document.Root);
using (var package = Package.Open(this.docxStream, FileMode.Open, FileAccess.ReadWrite))
{
for (var i = 1; i <= htmlChunks.Count; i++)
{
DocxPartResolver.CreateAfChunkPart(package, i, htmlChunks[i - 1]);
}
}
}
public override XElement Parse(ITagProcessor parentProcessor, XElement startElement)
{
this.ValidateStartTag(startElement, "HtmlContent");
var tag = new HtmlContentTag()
{
Expression = startElement.Value, TagNode = startElement
};
var processor = new HtmlContentProcessor()
{
HtmlTag = tag
};
parentProcessor.AddProcessor(processor);
return(startElement);
}
public void TestGenerateAltChunksDeletingParagraph()
{
const string ExpectedHtmlString = "<html>altchunks test</html>";
var htmlProcessedElement = new XElement(WordMl.SdtName,
new XElement(WordMl.SdtPrName,
new XElement(WordMl.TagName,
new XAttribute(WordMl.ValAttributeName,
HtmlContentProcessor
.ProcessedHtmlContentTagName))),
new XElement(WordMl.SdtContentName, ExpectedHtmlString));
var paragraph = new XElement(WordMl.ParagraphName, htmlProcessedElement);
var root = new XElement(WordMl.BodyName, paragraph);
var actualGeneratedChunks = HtmlContentProcessor.GenerateAltChunks(root);
Assert.IsNotNull(actualGeneratedChunks);
Assert.AreEqual(ExpectedHtmlString, actualGeneratedChunks[0]);
Assert.AreEqual(1, actualGeneratedChunks.Count);
Assert.IsFalse(root.Descendants().Any(el => el.IsSdt()));
Assert.IsFalse(root.Descendants().Any(el => el.Name.Equals(WordMl.ParagraphName)));
}
public void TestProcess()
{
const string HtmlEscapedString = @"
<html>
<head/>
<body>
<p>Html test</p>
</body>
</html>
";
const string path = "//test/htmlcontent";
var data = new XElement("test", new XElement("htmlcontent", HtmlEscapedString));
var htmlContentTag = new XElement(
WordMl.SdtName,
new XElement(
WordMl.SdtPrName, new XElement(
WordMl.TagName,
new XAttribute(WordMl.ValAttributeName, "htmlcontent"))),
new XElement(
WordMl.SdtContentName, path));
var document = new XElement("body", htmlContentTag);
var processor = new HtmlContentProcessor()
{
DataReader = new DataReader(data),
HtmlTag = new HtmlContentTag()
{
Expression = path,
TagNode = htmlContentTag
}
};
processor.Process();
Assert.AreEqual(HtmlContentProcessor.ProcessedHtmlContentTagName,
htmlContentTag.Element(WordMl.SdtPrName)
.Element(WordMl.TagName)
.Attribute(WordMl.ValAttributeName)
.Value);
Assert.AreNotEqual(path, htmlContentTag.Element(WordMl.SdtContentName).Value);
}
public void TestGenerateAltChunksAddingEmptyParagraphInTableCell()
{
const string ExpectedHtmlString = "<html>altchunks table cell test</html>";
const string rsidR = "00FFFFFF";
var htmlProcessedElement = new XElement(WordMl.SdtName,
new XElement(WordMl.SdtPrName,
new XElement(WordMl.TagName,
new XAttribute(WordMl.ValAttributeName,
HtmlContentProcessor
.ProcessedHtmlContentTagName))),
new XElement(WordMl.SdtContentName, ExpectedHtmlString));
var tableCell = new XElement(WordMl.TableCellName, htmlProcessedElement);
var tableRow = new XElement(WordMl.TableRowName, new XAttribute(WordMl.RsidRPropertiesName, rsidR), tableCell);
var root = new XElement(WordMl.BodyName, new XElement(WordMl.TableName, tableRow));
var actualGeneratedChunks = HtmlContentProcessor.GenerateAltChunks(root);
var actualAltChunkElement =
root.Element(WordMl.TableName)
.Element(WordMl.TableRowName)
.Element(WordMl.TableCellName)
.Elements()
.SingleOrDefault(el => el.Name.Equals(WordMl.AltChunkName));
Assert.IsNotNull(actualAltChunkElement);
Assert.IsNotNull(actualGeneratedChunks);
Assert.AreEqual(ExpectedHtmlString, actualGeneratedChunks[0]);
Assert.AreEqual(1, actualGeneratedChunks.Count);
Assert.IsFalse(root.Descendants().Any(el => el.IsSdt()));
var actualLastElement =
root.Element(WordMl.TableName)
.Element(WordMl.TableRowName)
.Element(WordMl.TableCellName)
.Elements()
.Last();
Assert.IsNotNull(actualLastElement);
Assert.AreEqual(WordMl.ParagraphName, actualLastElement.Name);
}
private XElement ProcessElements(IEnumerable <ItemRepeaterElement> itemRepeaterElements, DataReader dataReader, XElement start, XElement parent, int index, out ICollection <XElement> elementsBeforeNestedRepeaters, bool nested = false)
{
XElement result = null;
XElement previous = start;
ICollection <XElement> tempElementsBeforeItemRepeaters = new List <XElement>();
foreach (var itemRepeaterElement in itemRepeaterElements)
{
if (!itemRepeaterElement.IsVisible || itemRepeaterElement.IsItemIf || itemRepeaterElement.IsEndItemIf)
{
continue;
}
if (itemRepeaterElement.IsItemHtmlContent)
{
result = HtmlContentProcessor.MakeHtmlContentProcessed(itemRepeaterElement.XElement, dataReader.ReadText(itemRepeaterElement.Expression), true);
}
else if (itemRepeaterElement.IsIndex)
{
result = DocxHelper.CreateTextElement(itemRepeaterElement.XElement,
itemRepeaterElement.XElement.Parent,
index.ToString(CultureInfo.CurrentCulture),
!nested
);
}
else if (itemRepeaterElement.IsItem && itemRepeaterElement.HasExpression)
{
result = DocxHelper.CreateTextElement(itemRepeaterElement.XElement,
itemRepeaterElement.XElement.Parent,
dataReader.ReadText(itemRepeaterElement.Expression),
!nested
);
}
else
{
var element = new XElement(itemRepeaterElement.XElement);
element.RemoveNodes();
result = element;
if (itemRepeaterElement.HasElements)
{
ICollection <XElement> bisectNestedElements = new List <XElement>();
this.ProcessElements(itemRepeaterElement.Elements, dataReader, null, result, index, out bisectNestedElements, true);
if (bisectNestedElements.Count != 0)
{
tempElementsBeforeItemRepeaters.Add(bisectNestedElements.ElementAt(0));
}
}
else
{
element.Value = itemRepeaterElement.XElement.Value;
}
}
if (previous != null)
{
previous.AddAfterSelf(result);
previous = result;
}
else
{
parent.Add(result);
}
if (itemRepeaterElement.IsBeforeNestedRepeater)
{
tempElementsBeforeItemRepeaters.Add(result);
}
}
elementsBeforeNestedRepeaters = tempElementsBeforeItemRepeaters;
return(result);
}
private XElement ProcessElements(IEnumerable <ItemRepeaterElement> elements, DataReader dataReader, XElement start, XElement parent, int index, ref XElement nestedRepeaterEndElement, ref XElement endIfElement, bool nestedElement = false)
{
XElement result = null;
XElement previous = start;
foreach (var itemRepeaterElement in elements)
{
var flgStucturedElementProcessed = this.CheckAndProcessStartIfElementForContinue(itemRepeaterElement,
dataReader,
ref endIfElement)
||
this.CheckAndProcessEndIfElementForContinue(itemRepeaterElement,
ref endIfElement)
||
this.CheckAndProcessEndItemRepeaterElementForContinue(
itemRepeaterElement, ref nestedRepeaterEndElement) ||
this.CheckTableElementForContinue(itemRepeaterElement);
if (!flgStucturedElementProcessed)
{
var flgNestedElementCheckedForContinue = this.CheckNestedConditionElementForContinue(
itemRepeaterElement, endIfElement)
||
this.CheckNestedElementForContinue(elements.First(),
itemRepeaterElement,
nestedRepeaterEndElement);
if (!flgNestedElementCheckedForContinue)
{
if (itemRepeaterElement.IsItemHtmlContent)
{
result = HtmlContentProcessor.MakeHtmlContentProcessed(itemRepeaterElement.XElement,
dataReader.ReadText(
itemRepeaterElement.Expression),
true);
}
else if (itemRepeaterElement.IsItemRepeater)
{
var itemRepeaterTag = new ItemRepeaterTag()
{
StartItemRepeater = itemRepeaterElement.StartTag,
EndItemRepeater = itemRepeaterElement.EndTag,
Source = itemRepeaterElement.Expression
};
var itemRepeaterGenerator = new ItemRepeaterGenerator();
previous = itemRepeaterGenerator.Generate(itemRepeaterTag,
dataReader.GetReaders(itemRepeaterTag.Source),
previous, parent);
nestedRepeaterEndElement = itemRepeaterTag.EndItemRepeater;
result = null;
}
else if (itemRepeaterElement.IsIndex)
{
result = DocxHelper.CreateTextElement(itemRepeaterElement.XElement,
itemRepeaterElement.XElement.Parent,
index.ToString(CultureInfo.CurrentCulture),
!nestedElement);
}
else if (itemRepeaterElement.IsItem)
{
result = DocxHelper.CreateTextElement(itemRepeaterElement.XElement,
itemRepeaterElement.XElement.Parent,
dataReader.ReadText(itemRepeaterElement.Expression),
dataReader.ReadAttribute(itemRepeaterElement.Expression, "style"),
!nestedElement);
}
else if (itemRepeaterElement.IsItemTable)
{
result = ItemTableGenerator.ProcessItemTableElement(itemRepeaterElement.StartTag, itemRepeaterElement.EndTag,
dataReader);
if (nestedElement)
{
previous.AddAfterSelf(result);
previous = result;
result = null;
}
}
else
{
var element = new XElement(itemRepeaterElement.XElement);
element.RemoveNodes();
result = element;
if (itemRepeaterElement.HasElements)
{
var parsedLastElement = this.ProcessElements(itemRepeaterElement.Elements, dataReader,
previous,
result, index, ref nestedRepeaterEndElement,
ref endIfElement, true);
if (itemRepeaterElement.Elements.Any(ire => ire.XElement.IsSdt()) && DocxHelper.IsEmptyParagraph(result))
{
result = null;
}
if (itemRepeaterElement.Elements.Any(ire => ire.IsItemTable) ||
itemRepeaterElement.Elements.Any(
ire =>
ire.IsItemRepeater && !CheckInlineWrappingMode(ire.StartTag, ire.EndTag)))
{
previous = parsedLastElement;
}
}
else
{
element.Value = itemRepeaterElement.XElement.Value;
}
}
if (result != null)
{
if (!nestedElement)
{
previous.AddAfterSelf(result);
previous = result;
}
else
{
parent.Add(result);
}
}
}
else
{
result = null;
}
}
else
{
result = null;
}
}
return(result ?? previous);
}
