/// <summary>
/// Clone the data of the 1st content control (that specified to save contents to copy) and append them to the end of the current selected content control
/// </summary>
public void CloneData()
{
// Get the "Content" content control, which is what we want to copy
SdtElement target_copy_content_control = content_control.Descendants <SdtElement>().Where(s => s.Descendants <SdtAlias>().FirstOrDefault().Val.ToString().ToLower() == StaticValues.repeatcontent_cc_name).FirstOrDefault();
content_control.AppendChild(target_copy_content_control.CloneNode(true));
}
void SetLogo(SdtElement element, byte[] image, WordprocessingDocument document)
{
try
{
// Assuming that the first image is the logo placeholder. This is a reasonable assumption.
var blip = element.Descendants <Blip>().FirstOrDefault();
string imgId = "LogoPicture";
//assuming only one headerpart will have images
var imagePart = document.MainDocumentPart.HeaderParts.First(p => p.ImageParts.Any())
.AddImagePart(ImagePartType.Png, imgId);
using (var imageStream = new MemoryStream(image))
{
imagePart.FeedData(imageStream);
}
if (blip != null)
{
blip.Embed = imgId;
}
}
catch (Exception e)
{
//do nothing - just image will not be replaced
}
}
/// <summary>
/// 複製範本Block,回傳List
/// </summary>
/// <param name="srcDocName">來源範本別名</param>
public List <OpenXmlElement> CopyBlockList(string srcDocName, string blockName)
{
try {
WordprocessingDocument srcDoc = tplDoc[srcDocName];
List <OpenXmlElement> arrElement = new List <OpenXmlElement>();
Tag elementTag = srcDoc.MainDocumentPart.RootElement.Descendants <Tag>()
.Where(
element => element.Val.Value.ToLower() == blockName.ToLower()
).SingleOrDefault();
if (elementTag != null)
{
SdtElement block = (SdtElement)elementTag.Parent.Parent;
SdtContentBlock blockCont = block.Descendants <SdtContentBlock>().FirstOrDefault();
if (blockCont != null)
{
IEnumerable <OpenXmlElement> childs = blockCont.ChildElements;
foreach (var item in childs)
{
arrElement.Add(item.CloneNode(true));
}
}
}
return(arrElement);
}
catch (Exception ex) {
throw new Exception("複製範本Block!!(" + blockName + ")", ex);
}
}
public static void ProcessRepeatingSection(WordprocessingDocument doc, string parentName,
Dictionary <string, IEnumerable <string> > sectionItems)
{
var parentSdt = FindSdt(doc.MainDocumentPart.Document.Body, parentName);
var sdtContent = FindSdtContent(parentSdt, parentName);
if (sdtContent.ChildElements.Count != 1)
{
throw new NotImplementedException($"[{parentName}] Can not handle repeating sections with {sdtContent.ChildElements.Count} elements in content");
}
var count = sectionItems.First().Value.Count();
var sourceRow = sdtContent.FirstChild;
for (var i = 0; i < count; i++)
{
SdtElement newRow = (SdtElement)sourceRow.CloneNode(true);
newRow.SdtProperties?.Elements <SdtId>().FirstOrDefault()?.Remove();
sourceRow.Parent.AppendChild(newRow);
foreach (var kvp in sectionItems)
{
var childSdt = FindSdt(newRow, kvp.Key);
var childSdtContent = FindSdtContent(childSdt, kvp.Key);
SetTextElement(childSdtContent, kvp.Key, kvp.Value.ElementAt(i));
KeepContentAndDeleteSdt(childSdt, childSdtContent);
}
}
sourceRow.Remove();
KeepContentAndDeleteSdt(parentSdt, sdtContent);
}
protected static string GetTagValue(SdtElement element, out string templateTagPart, out string tagGuidPart)
{
templateTagPart = string.Empty;
tagGuidPart = string.Empty;
Tag tag = OpenXmlHelper.GetTag(element);
string fullTag = (tag == null || (tag.Val.HasValue == false)) ? string.Empty : tag.Val.Value;
if (!string.IsNullOrEmpty(fullTag))
{
string[] tagParts = fullTag.Split(':');
if (tagParts.Length == 2)
{
templateTagPart = tagParts[0];
tagGuidPart = tagParts[1];
}
else if (tagParts.Length == 1)
{
templateTagPart = tagParts[0];
}
}
return(fullTag);
}
/// <summary>
/// Containers the placeholder found.
/// </summary>
/// <param name="placeholderTag">The placeholder tag.</param>
/// <param name="openXmlElementDataContext">The open XML element data context.</param>
protected override void ContainerPlaceholderFound(string placeholderTag, OpenXmlElementDataContext openXmlElementDataContext)
{
if (openXmlElementDataContext == null || openXmlElementDataContext.Element == null || openXmlElementDataContext.DataContext == null)
{
return;
}
string tagPlaceHolderValue = string.Empty;
string tagGuidPart = string.Empty;
GetTagValue(openXmlElementDataContext.Element as SdtElement, out tagPlaceHolderValue, out tagGuidPart);
string tagValue = string.Empty;
string content = string.Empty;
switch (tagPlaceHolderValue)
{
case PlaceholderContainerA:
SdtElement parentContainer = openXmlElementDataContext.Element as SdtElement;
// Sets the parentContainer from CustomXmlPart if refresh else saves the parentContainer markup to CustomXmlPart
this.GetParentContainer(ref parentContainer, tagPlaceHolderValue);
base.ContainerPlaceholderFound(placeholderTag, new OpenXmlElementDataContext()
{
Element = parentContainer, DataContext = openXmlElementDataContext.DataContext
});
break;
}
}
public static void SetContentValue(this SdtElement Element, string Content)
{
var first = true;
foreach (var run in Element.GetContent().OfType <Run>().ToArray())
{
if (first)
{
first = false;
run.Text(Content);
}
else
{
run.Remove();
}
}
//var content = Element.GetContent();
//var run = content as Run;
//if (run is null)
// run = content.Descendants<Run>().FirstOrDefault();
//if (run is null)
// throw new InvalidOperationException();
////var run = content as Run ?? content.Descendants<Run>().First();
//run.Text(Content);
}
public static IEnumerable <OpenXmlElement> GetContent(this SdtElement Element)
{
var first_content_element = Element.Descendants().First(e => e.Parent !.LocalName == "sdtContent" && e is not SdtElement);
var content_container = first_content_element.Parent;
return(content_container !.ChildElements);
}
public static void ReplaceWithContentValue(this SdtElement Element, string?Content = null)
{
var content = Element.GetContent().ToArray();
var first = true;
foreach (var content_element in content)
{
content_element.Remove();
if (Content == null || !first)
{
continue;
}
var run = content_element as Run ?? content_element.DescendantChilds <Run>().FirstOrDefault();
if (run is null)
{
continue;
}
first = false;
run.Text(Content);
Element.InsertAfterSelf(content_element);
}
Element.Remove();
}
protected SdtElement CloneElementAndSetContentInPlaceholders(OpenXmlElementDataContext openXmlElementDataContext)
{
if (openXmlElementDataContext == null)
{
throw new ArgumentNullException("openXmlElementDataContext");
}
if (openXmlElementDataContext.Element == null)
{
throw new ArgumentNullException("openXmlElementDataContext.element");
}
SdtElement clonedSdtElement = null;
if (openXmlElementDataContext.Element.Parent != null && openXmlElementDataContext.Element.Parent is Paragraph)
{
Paragraph clonedPara = openXmlElementDataContext.Element.Parent.InsertBeforeSelf(openXmlElementDataContext.Element.Parent.CloneNode(true) as Paragraph);
clonedSdtElement = clonedPara.Descendants <SdtElement>().First();
}
else
{
clonedSdtElement = openXmlElementDataContext.Element.InsertBeforeSelf(openXmlElementDataContext.Element.CloneNode(true) as SdtElement);
}
foreach (var v in clonedSdtElement.Elements())
{
this.SetContentInPlaceholders(new OpenXmlElementDataContext()
{
Element = v, DataContext = openXmlElementDataContext.DataContext
});
}
return(clonedSdtElement);
}
/// <summary>
/// Called when [place holder found].
/// </summary>
/// <param name="openXmlElementDataContext">The open XML element data context.</param>
private void OnPlaceHolderFound(OpenXmlElementDataContext openXmlElementDataContext)
{
string templateTagPart = string.Empty;
string tagGuidPart = string.Empty;
SdtElement element = openXmlElementDataContext.Element as SdtElement;
GetTagValue(element, out templateTagPart, out tagGuidPart);
if (this.generationInfo.PlaceHolderTagToTypeCollection.ContainsKey(templateTagPart))
{
switch (this.generationInfo.PlaceHolderTagToTypeCollection[templateTagPart])
{
case PlaceHolderType.None:
break;
case PlaceHolderType.NonRecursive:
this.NonRecursivePlaceholderFound(templateTagPart, openXmlElementDataContext);
break;
case PlaceHolderType.Recursive:
this.RecursivePlaceholderFound(templateTagPart, openXmlElementDataContext);
break;
case PlaceHolderType.Ignore:
this.IgnorePlaceholderFound(templateTagPart, openXmlElementDataContext);
break;
case PlaceHolderType.Container:
this.ContainerPlaceholderFound(templateTagPart, openXmlElementDataContext);
break;
}
}
}
public static string?GetAlias(this SdtElement run)
{
var properties = run.GetFirstChild <SdtProperties>() !;
var aliace = properties.GetFirstChild <SdtAlias>() !.Val;
return(aliace);
}
public void SetBackgroundColorOfTableCell(SdtElement contentControl, string color = "D9D9D9")
{
if (contentControl == null)
{
throw new ArgumentNullException("contentControl");
}
var tableCell = contentControl.Parent.Parent as TableCell;
if (tableCell != null)
{
var tableCellProperties = new TableCellProperties( );
var shading =
tableCellProperties.AppendChild(new Shading( )
{
Val = ShadingPatternValues.Solid,
Color = color,
Fill = "FFFFFF",
ThemeFill = ThemeColorValues.Background1
});
tableCell.AppendChild(tableCellProperties);
}
}
/// <summary>
/// Recursive placeholder found.
/// </summary>
/// <param name="placeholderTag">The placeholder tag.</param>
/// <param name="openXmlElementDataContext">The open XML element data context.</param>
protected override void RecursivePlaceholderFound(string placeholderTag, OpenXmlElementDataContext openXmlElementDataContext)
{
if (openXmlElementDataContext == null || openXmlElementDataContext.Element == null || openXmlElementDataContext.DataContext == null)
{
return;
}
string tagPlaceHolderValue = string.Empty;
string tagGuidPart = string.Empty;
GetTagValue(openXmlElementDataContext.Element as SdtElement, out tagPlaceHolderValue, out tagGuidPart);
string refTagValue = string.Empty;
string refControlValue = string.Empty;
XPathNavigator navigator = Parse(openXmlElementDataContext, tagPlaceHolderValue, ref refTagValue, ref refControlValue);
if (navigator != null)
{
XPathNodeIterator nodeIterator = navigator.SelectDescendants("field", (openXmlElementDataContext.DataContext as XmlNode).NamespaceURI, false);
while (nodeIterator.MoveNext())
{
XmlDocument e = new XmlDocument();
e.LoadXml(nodeIterator.Current.OuterXml);
SdtElement clonedElement = this.CloneElementAndSetContentInPlaceholders(new OpenXmlElementDataContext()
{
Element = openXmlElementDataContext.Element, DataContext = e.DocumentElement
});
}
}
openXmlElementDataContext.Element.Remove();
}
public static void SetSdtText(this SdtElement element, string text)
{
if (element.Descendants <Text>().FirstOrDefault().Text != null)
{
element.Descendants <Text>().FirstOrDefault().Text = text;
}
}
void SetLogo(SdtElement element, byte[] image, WordprocessingDocument document)
{
try
{
var blip = element.Descendants <Blip>().FirstOrDefault();
var imgId = "LogoPicture";
var existingImage = document.MainDocumentPart.GetPartById(blip.Embed);
var imagePart = document.MainDocumentPart.HeaderParts.First(p => p.ImageParts.Any())
.AddImagePart(ImagePartType.Png, imgId);
using (var imageStream = new MemoryStream(image))
{
imagePart.FeedData(imageStream);
}
if (blip != null)
{
blip.Embed = imgId;
}
}
catch (Exception e)
{
//do nothing - just image will not be replaced
}
}
public void AssignContentFromCustomXmlPartForDataboundControl(SdtElement element, XmlElement customPartDocElement)
{
// This fix is applied only for data bound content controls. It was found MergeDocuments method was not picking up data from CustomXmlPart. Thus
// default text of the content control was there in the Final report instead of the XPath value.
// This method copies the text from the CustomXmlPart using XPath specified while creating the Binding element and assigns that to the
// content control
var binding = element.SdtProperties.GetFirstChild <DataBinding>();
if (binding == null)
{
return;
}
if (binding.XPath.HasValue)
{
var path = binding.XPath.Value;
if (customPartDocElement != null)
{
var mgr = new XmlNamespaceManager(new NameTable());
mgr.AddNamespace("ns0", this.namespaceUri.ToString());
var node = customPartDocElement.SelectSingleNode(path, mgr);
if (node != null)
{
SetContentOfContentControl(element, node.InnerText);
}
}
}
}
public static WordprocessingDocument InsertText(this WordprocessingDocument doc, string contentControlTag, string text, TraceWriter log, List <string> messages)
{
try
{
SdtElement element = doc.MainDocumentPart.Document.Body.Descendants <SdtElement>()
.FirstOrDefault(sdt => sdt.SdtProperties.GetFirstChild <Tag>()?.Val == contentControlTag);
if (element == null)
{
string message = $"ContentControlTag \"{contentControlTag}\" doesn't exist.";
log.Info(message);
messages.Add(message);
}
else
{
element.Descendants <Text>().First().Text = text;
element.Descendants <Text>().Skip(1).ToList().ForEach(t => t.Remove());
}
return(doc);
}
catch (Exception ex)
{
string message = $"An error occurred replacing Plain Text ContentControlTag \"{contentControlTag}\". Please ensure its a Plain Text COntent Control.";
log.Info(message);
messages.Add(message);
return(doc);
}
}
/// <summary>
/// Recursive placeholder found.
/// </summary>
/// <param name="placeholderTag">The placeholder tag.</param>
/// <param name="openXmlElementDataContext">The open XML element data context.</param>
protected override void RecursivePlaceholderFound(string placeholderTag, OpenXmlElementDataContext openXmlElementDataContext, WordprocessingDocument document)
{
if (openXmlElementDataContext == null || openXmlElementDataContext.Element == null || openXmlElementDataContext.DataContext == null)
{
return;
}
string tagPlaceHolderValue = string.Empty;
string tagGuidPart = string.Empty;
GetTagValue(openXmlElementDataContext.Element as SdtElement, out tagPlaceHolderValue, out tagGuidPart);
switch (tagPlaceHolderValue)
{
case AddressLabelRow:
foreach (DummyAddressStickerRow row in openXmlElementDataContext.DataContext as IEnumerable <DummyAddressStickerRow> )
{
SdtElement clonedElement = this.CloneElementAndSetContentInPlaceholders(new OpenXmlElementDataContext()
{
Element = openXmlElementDataContext.Element, DataContext = row
}, document);
}
openXmlElementDataContext.Element.Remove();
break;
}
}
public void RemoveContentControlsAndKeepContents(OpenXmlCompositeElement compositeElement, XmlElement customXmlPartDocElement)
{
if (compositeElement == null)
{
throw new ArgumentNullException("compositeElement");
}
SdtElement acompositeElement = compositeElement as SdtElement;
if (acompositeElement != null)
{
var elementsList = this.RemoveContentControlAndKeepContents(acompositeElement, customXmlPartDocElement);
foreach (var innerCompositeElement in elementsList)
{
this.RemoveContentControlsAndKeepContents(innerCompositeElement, customXmlPartDocElement);
}
}
else
{
var childCompositeElements = compositeElement.Elements <OpenXmlCompositeElement>().ToList();
foreach (var childCompositeElement in childCompositeElements)
{
this.RemoveContentControlsAndKeepContents(childCompositeElement, customXmlPartDocElement);
}
}
}
/// <summary>
/// Gets the SDT content of content control.
/// </summary>
/// <param name="element">The element.</param>
/// <returns>Returns the sdt content of content control</returns>
public static OpenXmlCompositeElement GetSdtContentOfContentControl(SdtElement element)
{
var sdtRunELement = element as SdtRun;
var sdtBlockElement = element as SdtBlock;
var sdtCellElement = element as SdtCell;
var sdtRowElement = element as SdtRow;
if (sdtRunELement != null)
{
return(sdtRunELement.SdtContentRun);
}
if (sdtBlockElement != null)
{
return(sdtBlockElement.SdtContentBlock);
}
if (sdtCellElement != null)
{
return(sdtCellElement.SdtContentCell);
}
if (sdtRowElement != null)
{
return(sdtRowElement.SdtContentRow);
}
return(null);
}
/// <summary>
/// Gets the SDT content of content control.
/// </summary>
/// <param name="element">The element.</param>
/// <returns></returns>
public OpenXmlCompositeElement GetSdtContentOfContentControl(SdtElement element)
{
SdtRun sdtRunELement = element as SdtRun;
SdtBlock sdtBlockElement = element as SdtBlock;
SdtCell sdtCellElement = element as SdtCell;
SdtRow sdtRowElement = element as SdtRow;
if (sdtRunELement != null)
{
return(sdtRunELement.SdtContentRun);
}
else if (sdtBlockElement != null)
{
return(sdtBlockElement.SdtContentBlock);
}
else if (sdtCellElement != null)
{
return(sdtCellElement.SdtContentCell);
}
else if (sdtRowElement != null)
{
return(sdtRowElement.SdtContentRow);
}
return(null);
}
/// <summary>
/// Recursive placeholder found.
/// </summary>
/// <param name="placeholderTag">The placeholder tag.</param>
/// <param name="openXmlElementDataContext">The open XML element data context.</param>
protected override void RecursivePlaceholderFound(string placeholderTag, OpenXmlElementDataContext openXmlElementDataContext)
{
if (openXmlElementDataContext == null || openXmlElementDataContext.Element == null || openXmlElementDataContext.DataContext == null)
{
return;
}
string tagPlaceHolderValue = string.Empty;
string tagGuidPart = string.Empty;
GetTagValue(openXmlElementDataContext.Element as SdtElement, out tagPlaceHolderValue, out tagGuidPart);
if (this.placeHolderNameToContentControlXmlMetadataCollection.ContainsKey(tagPlaceHolderValue))
{
XmlNode node = GetNode(openXmlElementDataContext.DataContext, this.placeHolderNameToContentControlXmlMetadataCollection[tagPlaceHolderValue].ControlValueXPath);
foreach (XmlNode childNode in node.ChildNodes)
{
SdtElement clonedElement = this.CloneElementAndSetContentInPlaceholders(new OpenXmlElementDataContext()
{
Element = openXmlElementDataContext.Element, DataContext = childNode
});
}
openXmlElementDataContext.Element.Remove();
}
}
/// <summary>
/// Gets the SDT content of content control.
/// </summary>
/// <param name="element">The element.</param>
/// <returns></returns>
public OpenXmlCompositeElement GetSdtContentOfContentControl(SdtElement element)
{
SdtRun sdtRunELement = element as SdtRun;
SdtBlock sdtBlockElement = element as SdtBlock;
SdtCell sdtCellElement = element as SdtCell;
SdtRow sdtRowElement = element as SdtRow;
if (sdtRunELement != null)
{
var contentRun = sdtRunELement.SdtContentRun;
if (contentRun == null && sdtRunELement.FirstChild is SdtRun)
{
contentRun = (sdtRunELement.FirstChild as SdtRun).SdtContentRun;
}
return(contentRun);
}
else if (sdtBlockElement != null)
{
return(sdtBlockElement.SdtContentBlock);
}
else if (sdtCellElement != null)
{
return(sdtCellElement.SdtContentCell);
}
else if (sdtRowElement != null)
{
return(sdtRowElement.SdtContentRow);
}
return(null);
}
protected Tag SetSdtElementTag(SdtElement sdtElement, Tag newTag)
{
Tag oldTag = sdtElement.SdtProperties.Elements <Tag>().SingleOrDefault();
oldTag = newTag;
return(newTag);
}
public void Write(SdtElement marker, Text text)
{
var parent = marker.Parent;
var run = Generate(text);
parent.InsertAfter(run, marker);
}
/// <summary>
/// Sets the tag value.
/// </summary>
/// <param name="element">The element.</param>
/// <param name="fullTagValue">The full tag value.</param>
protected static void SetTagValue(SdtElement element, string fullTagValue)
{
// Set the tag for the content control
if (!string.IsNullOrEmpty(fullTagValue))
{
OpenXmlHelper.SetTagValue(element, fullTagValue);
}
}
/// <summary>
/// Sets the content of content control.
/// </summary>
/// <param name="contentControl">The content control.</param>
/// <param name="content">The content.</param>
public void SetContentOfContentControl(SdtElement contentControl, string content)
{
if (contentControl == null)
{
throw new ArgumentNullException(nameof(contentControl));
}
content = string.IsNullOrEmpty(content) ? string.Empty : content;
bool isCombobox = contentControl.SdtProperties.Descendants <SdtContentDropDownList>().FirstOrDefault() != null;
if (isCombobox)
{
OpenXmlCompositeElement openXmlCompositeElement = GetSdtContentOfContentControl(contentControl);
Run run = CreateRun(openXmlCompositeElement, content);
SetSdtContentKeepingPermissionElements(openXmlCompositeElement, run);
}
else
{
OpenXmlCompositeElement openXmlCompositeElement = GetSdtContentOfContentControl(contentControl);
contentControl.SdtProperties.RemoveAllChildren <ShowingPlaceholder>();
List <Run> runs = new List <Run>();
if (content.Contains(Environment.NewLine))
{
List <string> lines = content.Split(Environment.NewLine.ToCharArray()).ToList();
foreach (string line in lines)
{
Run run = CreateRun(openXmlCompositeElement, line);
if (string.IsNullOrEmpty(line))
{
run.AppendChild(new Break());
}
runs.Add(run);
}
}
else
{
runs.Add(CreateRun(openXmlCompositeElement, content));
}
if (openXmlCompositeElement is SdtContentCell)
{
AddRunsToSdtContentCell(openXmlCompositeElement as SdtContentCell, runs);
}
else if (openXmlCompositeElement is SdtContentBlock)
{
Paragraph para = CreateParagraph(openXmlCompositeElement, runs);
SetSdtContentKeepingPermissionElements(openXmlCompositeElement, para);
}
else
{
SetSdtContentKeepingPermissionElements(openXmlCompositeElement, runs);
}
}
}
/// <summary>
/// Gets the text from content control.
/// </summary>
/// <param name="contentControl">The content control.</param>
/// <returns></returns>
public string GetTextFromContentControl(SdtElement contentControl)
{
string result = null;
if (contentControl != null)
{
if (contentControl is SdtRun)
{
if (IsContentControlMultiline(contentControl))
{
var runs = contentControl.Descendants <SdtContentRun>().First().Elements()
.Where(elem => elem is Run || elem is InsertedRun);
List <string> runTexts = new List <string>();
if (runs != null)
{
foreach (var run in runs)
{
foreach (var runChild in run.Elements())
{
Text runText = runChild as Text;
Break runBreak = runChild as Break;
if (runText != null)
{
runTexts.Add(runText.Text);
}
else if (runBreak != null)
{
runTexts.Add(Environment.NewLine);
}
}
}
}
StringBuilder stringBuilder = new StringBuilder();
foreach (string item in runTexts)
{
stringBuilder.Append(item);
}
result = stringBuilder.ToString();
}
else
{
result = contentControl.InnerText;
}
}
else
{
result = contentControl.InnerText;
}
}
return(result);
}
/// <summary>
/// Gets the tag.
/// </summary>
/// <param name="element">The SDT element.</param>
/// <returns>
/// Returns Tag of content control
/// </returns>
public static Tag GetTag(SdtElement element)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
return(element.SdtProperties.Elements <Tag>().FirstOrDefault());
}
