/// <summary>
/// Validat the specified document.
/// </summary>
/// <param name="document">The document to be validated.</param>
/// <returns>Return results in ValidationResult.</returns>
internal ValidationResult Validate(OpenXmlPackage document)
{
this.TargetDocument = document;
this.PrepareValidation();
this.ValidationContext.Package = document;
// integrate the package validation.
ValidatePackageStructure(document);
foreach (var part in PartsToBeValidated)
{
// travser from the part root element (by DOM or by Reader) in post-order
// that means validate the children firt, then validate the parent
// the validation engine call bookkeep information
this.ValidatePart(part);
}
this.FinishValidation();
return this.ValidationResult;
}
private static bool ValidateOpenXmlDocument(OpenXmlPackage package )
{
string errorDesc = "";
try
{
OpenXmlValidator validator = new OpenXmlValidator();
int count = 0;
foreach (ValidationErrorInfo error in validator.Validate(package))
{
count++;
errorDesc += String.Format("Error: {0}", count) + Environment.NewLine;
errorDesc += String.Format("Description: {0}", error.Description) + Environment.NewLine;
errorDesc += String.Format("Path: {0}", error.Path.XPath) + Environment.NewLine;
errorDesc += String.Format("Part: {0}", error.Part.Uri) + Environment.NewLine;
errorDesc += "-------------------------------------------" + Environment.NewLine;
}
}
catch (Exception ex)
{
errorDesc += ex.Message;
}
if (!string.IsNullOrEmpty(errorDesc))
{
throw new Exception(errorDesc);
}
return true;
}
/// <summary>
/// Detect the document type.
/// </summary>
/// <param name="openXmlPackage">The Open XML package to be detected.</param>
/// <returns>The type of the Open XML package.</returns>
internal static OpenXmlDocumentType GetDocumentType(OpenXmlPackage openXmlPackage)
{
if (openXmlPackage is WordprocessingDocument)
{
return OpenXmlDocumentType.Wordprocessing;
}
else if (openXmlPackage is SpreadsheetDocument)
{
return OpenXmlDocumentType.Spreadsheet;
}
else if (openXmlPackage is PresentationDocument)
{
return OpenXmlDocumentType.Presentation;
}
else
{
return OpenXmlDocumentType.Invalid;
}
}
private void setPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Modified = DateTime.Now;
document.PackageProperties.LastModifiedBy = "Гос. инспекция по семеноводству, ...";
document.PackageProperties.LastPrinted = DateTime.Now;
}
private void SetPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Creator = "GACERO";
document.PackageProperties.Created = System.Xml.XmlConvert.ToDateTime("2005-11-08T18:47:16Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.Modified = System.Xml.XmlConvert.ToDateTime("2013-11-14T14:14:34Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.LastModifiedBy = "Carlos Porcel";
document.PackageProperties.LastPrinted = System.Xml.XmlConvert.ToDateTime("2011-09-08T16:54:52Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
}
private static string GetDocumentName(OpenXmlPackage document)
{
return document.GetType().Name;
}
private void SetPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Creator = "David";
document.PackageProperties.Revision = "1";
document.PackageProperties.Created = System.Xml.XmlConvert.ToDateTime("2012-05-19T23:53:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.Modified = System.Xml.XmlConvert.ToDateTime("2012-05-19T23:54:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.LastModifiedBy = "David";
}
private void SetPackageProperties(OpenXmlPackage document)
{
}
private void ValidatePackageStructure(OpenXmlPackage document, ValidationContext context)
{
var documentName = document.GetType().Name;
#pragma warning disable CS0618 // Type or member is obsolete
var packageValidationSettings = new OpenXmlPackageValidationSettings();
#pragma warning restore CS0618 // Type or member is obsolete
packageValidationSettings.EventHandler += OnPackageValidationError;
document.Validate(packageValidationSettings, _validationSettings.FileFormat);
#pragma warning disable CS0618 // Type or member is obsolete
void OnPackageValidationError(Object sender, OpenXmlPackageValidationEventArgs e)
#pragma warning restore CS0618 // Type or member is obsolete
{
var errorInfo = new ValidationErrorInfo
{
ErrorType = ValidationErrorType.Package,
Id = "Pkg_" + e.MessageId
};
string name;
switch (errorInfo.Id)
{
case "Pkg_PartIsNotAllowed":
Debug.Assert(e.SubPart != null);
name = e.Part != null?GetPartNameAndUri(e.Part) : documentName;
errorInfo.Description = String.Format(CultureInfo.CurrentUICulture, ValidationResources.Pkg_PartIsNotAllowed, name, GetPartNameAndUri(e.SubPart));
break;
case "Pkg_RequiredPartDoNotExist":
errorInfo.Description = string.Format(CultureInfo.CurrentUICulture, ValidationResources.Pkg_RequiredPartDoNotExist, e.PartClassName);
break;
case "Pkg_OnlyOnePartAllowed":
name = e.Part != null?GetPartNameAndUri(e.Part) : documentName;
errorInfo.Description = String.Format(CultureInfo.CurrentUICulture, ValidationResources.Pkg_OnlyOnePartAllowed, name, e.PartClassName);
#if DEBUG
Debug.Assert(e.SubPart != null);
errorInfo.RelatedPart = e.SubPart;
#endif
break;
case "Pkg_ExtendedPartIsOpenXmlPart":
Debug.Assert(e.SubPart != null);
errorInfo.Description = string.Format(CultureInfo.CurrentUICulture, ValidationResources.Pkg_ExtendedPartIsOpenXmlPart, GetPartUri(e.SubPart));
break;
case "Pkg_DataPartReferenceIsNotAllowed":
Debug.Assert(e.DataPartReferenceRelationship != null);
name = e.Part != null?GetPartNameAndUri(e.Part) : documentName;
errorInfo.Description = String.Format(CultureInfo.CurrentUICulture, ValidationResources.Pkg_PartIsNotAllowed, name, e.DataPartReferenceRelationship.Uri);
break;
case "Pkg_InvalidContentTypePart": // won't get this error.
default:
Debug.Assert(false, "Invalid package validation event.");
break;
}
if (e.Part != null)
{
errorInfo.Part = e.Part;
errorInfo.Path = new XmlPath(e.Part);
}
errorInfo.RelatedPart = e.SubPart;
context.AddError(errorInfo);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="OpenXmlPackageTreeViewItem"/> class
/// that is empty.
/// </summary>
public OpenXmlPackageTreeViewItem(OpenXmlPackage pkg)
: base(pkg.Parts != null && pkg.Parts.Count() > 0)
{
_package = pkg;
}
/// <summary>
/// Search document for paragraphs using a particular style or containing particular text.
/// </summary>
/// <param name="document"></param>
/// <param name="styleSearchString"></param>
/// <param name="contentSearchString"></param>
/// <param name="isRegularExpression"></param>
/// <param name="caseInsensitive"></param>
/// <returns></returns>
static public MatchInfo[] SearchInDocument(this OpenXmlPackage document,
IEnumerable <string> styleSearchString, IEnumerable <string> contentSearchString,
bool isRegularExpression, bool caseInsensitive)
{
WordprocessingDocument doc = document as WordprocessingDocument;
if (doc == null)
{
throw new InvalidOperationException("Searching only supported for Wordprocessing documents.");
}
XNamespace w =
"http://schemas.openxmlformats.org/wordprocessingml/2006/main";
XName r = w + "r";
XName ins = w + "ins";
RegexOptions options;
Regex[] regularExpressions = null;
if (isRegularExpression && contentSearchString != null)
{
if (caseInsensitive)
{
options = RegexOptions.IgnoreCase | RegexOptions.Compiled;
}
else
{
options = RegexOptions.Compiled;
}
regularExpressions = contentSearchString
.Select(s => new Regex(s, options)).ToArray();
}
var defaultStyleName = (string)doc
.MainDocumentPart
.StyleDefinitionsPart
.GetXDocument()
.Root
.Elements(w + "style")
.Where(style =>
(string)style.Attribute(w + "type") == "paragraph" &&
(string)style.Attribute(w + "default") == "1")
.First()
.Attribute(w + "styleId");
var q1 = doc
.MainDocumentPart
.GetXDocument()
.Root
.Element(w + "body")
.Elements()
.Select((p, i) =>
{
var styleNode = p
.Elements(w + "pPr")
.Elements(w + "pStyle")
.FirstOrDefault();
var styleName = styleNode != null ?
(string)styleNode.Attribute(w + "val") :
defaultStyleName;
return(new
{
Element = p,
Index = i,
StyleName = styleName
});
}
);
var q2 = q1
.Select(i =>
{
string text = null;
if (i.Element.Name == w + "p")
{
text = i.Element.Elements()
.Where(z => z.Name == r || z.Name == ins)
.Descendants(w + "t")
.StringConcatenate(element => (string)element);
}
else
{
text = i.Element
.Descendants(w + "p")
.StringConcatenate(p => p
.Elements()
.Where(z => z.Name == r || z.Name == ins)
.Descendants(w + "t")
.StringConcatenate(element => (string)element),
Environment.NewLine
);
}
return(new
{
Element = i.Element,
StyleName = i.StyleName,
Index = i.Index,
Text = text
});
}
);
var q3 = q2
.Select(i =>
new MatchInfo
{
ElementNumber = i.Index + 1,
Content = i.Text,
Style = ContainsAnyStyles(GetAllStyleIdsAndNames(doc, i.StyleName).Distinct(), styleSearchString),
Pattern = ContainsAnyContent(i.Text, contentSearchString, regularExpressions, isRegularExpression, caseInsensitive),
IgnoreCase = caseInsensitive
}
)
.Where(i => (styleSearchString == null || i.Style != null) && (contentSearchString == null || i.Pattern != null));
return(q3.ToArray());
}
/// <summary>
/// Removes personal information from the document.
/// </summary>
/// <param name="document"></param>
public static void RemovePersonalInformation(this OpenXmlPackage document)
{
WordprocessingDocument doc = document as WordprocessingDocument;
if (doc == null)
{
throw new InvalidOperationException("Removal of personal information only supported for Wordprocessing documents.");
}
XNamespace x = "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties";
XDocument extendedFileProperties = doc.ExtendedFilePropertiesPart.GetXDocument();
extendedFileProperties.Elements(x + "Properties").Elements(x + "Company").Remove();
XElement totalTime = extendedFileProperties.Elements(x + "Properties").Elements(x + "TotalTime").FirstOrDefault();
if (totalTime != null)
{
totalTime.Value = "0";
}
XNamespace dc = "http://purl.org/dc/elements/1.1/";
XNamespace cp = "http://schemas.openxmlformats.org/package/2006/metadata/core-properties";
XDocument coreFileProperties = doc.CoreFilePropertiesPart.GetXDocument();
foreach (var textNode in coreFileProperties.Elements(cp + "coreProperties")
.Elements(dc + "creator")
.Nodes()
.OfType <XText>())
{
textNode.Value = "";
}
foreach (var textNode in coreFileProperties.Elements(cp + "coreProperties")
.Elements(cp + "lastModifiedBy")
.Nodes()
.OfType <XText>())
{
textNode.Value = "";
}
XElement revision = coreFileProperties.Elements(cp + "coreProperties").Elements(cp + "revision").FirstOrDefault();
if (revision != null)
{
revision.Value = "1";
}
// add w:removePersonalInformation, w:removeDateAndTime to DocumentSettingsPart
XNamespace w = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
XDocument documentSettings = doc.MainDocumentPart.DocumentSettingsPart.GetXDocument();
// add the new elements in the right position. Add them after the following three elements
// (which may or may not exist in the xml document).
XElement settings = documentSettings.Root;
XElement lastOfTop3 = settings.Elements()
.Where(e => e.Name == w + "writeProtection" ||
e.Name == w + "view" ||
e.Name == w + "zoom")
.InDocumentOrder()
.LastOrDefault();
if (lastOfTop3 == null)
{
// none of those three exist, so add as first children of the root element
settings.AddFirst(
settings.Elements(w + "removePersonalInformation").Any() ?
null :
new XElement(w + "removePersonalInformation"),
settings.Elements(w + "removeDateAndTime").Any() ?
null :
new XElement(w + "removeDateAndTime")
);
}
else
{
// one of those three exist, so add after the last one
lastOfTop3.AddAfterSelf(
settings.Elements(w + "removePersonalInformation").Any() ?
null :
new XElement(w + "removePersonalInformation"),
settings.Elements(w + "removeDateAndTime").Any() ?
null :
new XElement(w + "removeDateAndTime")
);
}
}
internal CreateOpenXmlPackageContext(OpenXmlPackage package, Document document)
{
_package = package.ThrowIfNull(nameof(package));
_document = document.ThrowIfNull(nameof(document));
}
public PowerToolsBlock(OpenXmlPackage package)
{
_package = package ?? throw new ArgumentNullException(nameof(package));
_package.BeginPowerToolsBlock();
}
/// <summary>
/// Resets the main window controls and loads a requested OpenXml based file.
/// </summary>
private void OpenOfficeDocument()
{
const string docxIdUri = "/word/document.xml";
const string xlsxIdUri = "/xl/workbook.xml";
const string pptxIdUri = "/ppt/presentation.xml";
const string fileFilter =
"All Microsoft Office 2007+ valid documents (*.xlsx;*.xlsm;*.pptx;*.pptm;*.docx;*.docm)|*.xlsx;*.xlsm;*.pptx;*.pptm;*.docx;*.docm" +
"|Microsoft Excel 2007+ documents (*.xlsx;*.xlsm)|*.xlsx;*.xlsm" +
"|Microsoft Powerpoint 2007+ documents (*.pptx;*.pptm)|*.pptx;*.pptm" +
"|Microsoft Word 2007+ documents (*.docx;*.docm)|*.docx;*.docm" +
"|All files | *.*";
bool?dialogResult;
var ofDialog = new OpenFileDialog()
{
InitialDirectory = _currentFileDirectory.FullName,
Multiselect = false,
CheckFileExists = true,
CheckPathExists = true,
ReadOnlyChecked = true,
Filter = fileFilter,
FilterIndex = 1
};
dialogResult = ofDialog.ShowDialog();
if (!dialogResult.GetValueOrDefault(false))
{
// If the user cancels out; exit method.
return;
}
// Ensure that everything is cleared out before proceeding
Dispose();
CodeDocument.FileName = null;
XmlSourceDocument.FileName = null;
CodeDocumentText = String.Empty;
XmlSourceDocumentText = String.Empty;
_fileName = String.Empty;
// See if the user left the Open as readonly flag on
var fShare = ofDialog.ReadOnlyChecked ? FileShare.ReadWrite : FileShare.Read;
// Get the selected file details
var fi = new FileInfo(ofDialog.FileName);
_currentFileDirectory = fi.Directory;
_fileName = fi.Name;
_stream = fi.Open(FileMode.Open, FileAccess.Read, fShare);
_pkg = Package.Open(_stream);
// Setup a quick look up for easier package validation
var quickPicks = new Dictionary <string, Func <Package, OpenXmlPackage> >(3)
{
{ docxIdUri, WordprocessingDocument.Open },
{ xlsxIdUri, SpreadsheetDocument.Open },
{ pptxIdUri, PresentationDocument.Open }
};
foreach (var qp in quickPicks)
{
if (_pkg.PartExists(new Uri(qp.Key, UriKind.Relative)))
{
_oPkg = qp.Value.Invoke(_pkg);
break;
}
}
// Make sure that a valid package was found before proceeding.
if (_oPkg == null)
{
throw new InvalidDataException("Selected file is not a known/valid OpenXml document");
}
// Wrap it up
var mainItem = new OpenXmlPackageTreeViewItem(_oPkg)
{
Header = _fileName
};
_treeData.Clear();
_treeData.Add(mainItem);
}
/// <summary>
/// Get Non-Main Part of current package
/// </summary>
/// <param name="package">current package</param>
/// <returns>Return non-main part of current package, null if not exist.</returns>
public static IEnumerable <OpenXmlPart> NonMainParts(this OpenXmlPackage package)
{
return(package.DescendantParts()
.Where(p => p.IsReflectable() && !p.IsMainPart()));
}
private static void ValidatePackageStructure(OpenXmlPackage document, ValidationContext context)
{
var documentName = document.GetType().Name;
var errors = new PackageValidator(document).Validate(context.FileFormat)
.Select(e =>
{
var errorInfo = new ValidationErrorInfo
{
ErrorType = ValidationErrorType.Package,
Id = "Pkg_" + e.MessageId,
};
string name;
switch (errorInfo.Id)
{
case "Pkg_PartIsNotAllowed":
name = e.Part is not null ? GetPartNameAndUri(e.Part) : documentName;
errorInfo.Description = SR.Format(ValidationResources.Pkg_PartIsNotAllowed, name, GetPartNameAndUri(e.SubPart));
break;
case "Pkg_RequiredPartDoNotExist":
errorInfo.Description = SR.Format(ValidationResources.Pkg_RequiredPartDoNotExist, e.PartClassName);
break;
case "Pkg_OnlyOnePartAllowed":
name = e.Part is not null ? GetPartNameAndUri(e.Part) : documentName;
errorInfo.Description = SR.Format(ValidationResources.Pkg_OnlyOnePartAllowed, name, e.PartClassName);
#if DEBUG
Debug.Assert(e.SubPart is not null);
errorInfo.RelatedPart = e.SubPart;
#endif
break;
case "Pkg_ExtendedPartIsOpenXmlPart":
errorInfo.Description = SR.Format(ValidationResources.Pkg_ExtendedPartIsOpenXmlPart, GetPartUri(e.SubPart));
break;
case "Pkg_DataPartReferenceIsNotAllowed":
name = e.Part is not null ? GetPartNameAndUri(e.Part) : documentName;
errorInfo.Description = SR.Format(ValidationResources.Pkg_PartIsNotAllowed, name, e.DataPartReferenceRelationship !.Uri);
break;
case "Pkg_InvalidContentTypePart": // won't get this error.
default:
Debug.Assert(false, "Invalid package validation event.");
break;
}
if (e.Part is not null)
{
errorInfo.Part = e.Part;
}
errorInfo.RelatedPart = e.SubPart;
return(errorInfo);
});
context.Errors.AddRange(errors);
}
public CustomXmlPart(OpenXmlPackage package, int partIndex)
: base(package, partIndex)
{
}
/// <summary>
/// Validates the specified document.
/// </summary>
/// <param name="openXmlPackage">The target WordprocessingDocument, SpreadsheetDocument or PresentationDocument.</param>
/// <returns>A set of validation erros.</returns>
/// <exception cref="ArgumentNullException">Thrown when the "openXmlPackage" parameter is null.</exception>
public IEnumerable<ValidationErrorInfo> Validate(OpenXmlPackage openXmlPackage)
{
if (openXmlPackage == null)
{
throw new ArgumentNullException("openXmlPackage");
}
if (openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.ProcessMode != MarkupCompatibilityProcessMode.NoProcess &&
openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.TargetFileFormatVersions != this.FileFormat)
{
string exceptionMessage = string.Format(System.Globalization.CultureInfo.CurrentUICulture,
ExceptionMessages.DocumentFileFormatVersionMismatch,
openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.TargetFileFormatVersions, this.FileFormat);
throw new InvalidOperationException(exceptionMessage);
}
// Do NOT use "yield return" in this method, as "yield return" are deferred executed.
// Otherwise, the null check is not performed when the method is called, but rather, when the returned enumerator is moved for the first time.
// That means that the exception isn't thrown until possibly far, far away from the actual site of the error, which is potentially confusing.
ValidationResult validationResult = null;
switch (DocumentTypeDetector.GetDocumentType(openXmlPackage))
{
case OpenXmlDocumentType.Spreadsheet:
validationResult = this.SpreadsheetDocumentValidator.Validate(openXmlPackage as SpreadsheetDocument);
break;
case OpenXmlDocumentType.Wordprocessing:
validationResult = this.WordprocessingDocumentValidator.Validate(openXmlPackage as WordprocessingDocument);
break;
case OpenXmlDocumentType.Presentation:
validationResult = this.PresentationDocumentValidator.Validate(openXmlPackage as PresentationDocument);
break;
default:
throw new System.IO.InvalidDataException(ExceptionMessages.UnknownPackage);
}
return this.YieldResult(validationResult);
}
public StronglyTypedBlock(OpenXmlPackage package)
{
_package = package ?? throw new ArgumentNullException(nameof(package));
_package.EndPowerToolsBlock();
}
private void SetPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Creator = "aanchals";
document.PackageProperties.Title = "Slide 1";
document.PackageProperties.Revision = "2";
document.PackageProperties.Created = System.Xml.XmlConvert.ToDateTime("2008-01-03T22:28:03Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.Modified = System.Xml.XmlConvert.ToDateTime("2012-10-03T08:41:17Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.LastModifiedBy = "Dan Ito";
}
/// <summary>
/// Converts an <see cref="OpenXmlPackage"/> into a <see cref="string"/> representation
/// of dotnet source code that can be compiled to build <paramref name="pkg"/>.
/// </summary>
/// <param name="pkg">
/// The <see cref="OpenXmlPackage"/> object to generate source code for.
/// </param>
/// <param name="provider">
/// The <see cref="CodeDomProvider"/> object to create the resulting source code.
/// </param>
/// <returns>
/// A <see cref="string"/> representation of the source code generated by <paramref name="provider"/>
/// that could create <paramref name="pkg"/> when compiled.
/// </returns>
public static string GenerateSourceCode(this OpenXmlPackage pkg, CodeDomProvider provider)
{
return pkg.GenerateSourceCode(new DefaultSerializeSettings(), provider);
}
/// <summary>
/// The set package properties.
/// </summary>
/// <param name="p">
/// The p.
/// </param>
private void SetPackageProperties(OpenXmlPackage p)
{
p.PackageProperties.Creator = this.Creator;
p.PackageProperties.Title = this.Title;
p.PackageProperties.Subject = this.Subject;
p.PackageProperties.Description = this.Description;
p.PackageProperties.Keywords = this.Keywords;
p.PackageProperties.Version = this.Version;
p.PackageProperties.Revision = this.Revision;
p.PackageProperties.Created = DateTime.Now;
p.PackageProperties.Modified = DateTime.Now;
p.PackageProperties.LastModifiedBy = this.Creator;
}
/// <summary>
/// Converts an <see cref="OpenXmlPackage"/> into a <see cref="string"/> representation
/// of dotnet source code that can be compiled to build <paramref name="pkg"/>.
/// </summary>
/// <param name="pkg">
/// The <see cref="OpenXmlPackage"/> object to generate source code for.
/// </param>
/// <param name="opts">
/// The <see cref="NamespaceAliasOptions"/> to apply to the resulting source code.
/// </param>
/// <param name="provider">
/// The <see cref="CodeDomProvider"/> object to create the resulting source code.
/// </param>
/// <returns>
/// A <see cref="string"/> representation of the source code generated by <paramref name="provider"/>
/// that could create <paramref name="pkg"/> when compiled.
/// </returns>
public static string GenerateSourceCode(this OpenXmlPackage pkg, NamespaceAliasOptions opts, CodeDomProvider provider)
{
return pkg.GenerateSourceCode(new DefaultSerializeSettings(opts), provider);
}
private void SetPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Creator = "rodrigo.iloro";
document.PackageProperties.LastModifiedBy = "rodrigo.iloro";
}
/// <summary>
/// Converts an <see cref="OpenXmlPackage"/> into a CodeDom object that can be used
/// to build code in a given .NET language to build the referenced <paramref name="pkg"/>.
/// </summary>
/// <param name="pkg">
/// The <see cref="OpenXmlPackage"/> object to generate source code for.
/// </param>
/// <returns>
/// A new <see cref="CodeCompileUnit"/> containing the instructions to build
/// the referenced <see cref="OpenXmlPackage"/>.
/// </returns>
public static CodeCompileUnit GenerateSourceCode(this OpenXmlPackage pkg)
{
return pkg.GenerateSourceCode(new DefaultSerializeSettings());
}
/// <summary>
/// Create an instance of OpenXmlPart according to the given relationship type.
/// </summary>
/// <param name="openXmlPackage">The container OpenXmlPackage.</param>
/// <param name="relationshipType">The relationship type of the target part.</param>
/// <param name="openXmlPart">The created instance of OpenXmlPart.</param>
/// <remarks>This partial method will be generated by code generaotr.</remarks>
static partial void CreatePartCore(OpenXmlPackage openXmlPackage, string relationshipType, ref OpenXmlPart openXmlPart)
{
if (openXmlPackage == null)
{
throw new ArgumentNullException("openXmlPackage");
}
if (relationshipType == null)
{
throw new ArgumentNullException("relationshipType");
}
if (openXmlPackage is WordprocessingDocument)
{
switch (relationshipType)
{
case MainDocumentPart.RelationshipTypeConstant:
openXmlPart = new MainDocumentPart();
return;
case CustomXmlPart.RelationshipTypeConstant:
openXmlPart = new CustomXmlPart();
return;
case CustomXmlPropertiesPart.RelationshipTypeConstant:
openXmlPart = new CustomXmlPropertiesPart();
return;
case GlossaryDocumentPart.RelationshipTypeConstant:
openXmlPart = new GlossaryDocumentPart();
return;
case WordprocessingCommentsPart.RelationshipTypeConstant:
openXmlPart = new WordprocessingCommentsPart();
return;
case AlternativeFormatImportPart.RelationshipTypeConstant:
openXmlPart = new AlternativeFormatImportPart();
return;
case ChartPart.RelationshipTypeConstant:
openXmlPart = new ChartPart();
return;
case ChartDrawingPart.RelationshipTypeConstant:
openXmlPart = new ChartDrawingPart();
return;
case ImagePart.RelationshipTypeConstant:
openXmlPart = new ImagePart();
return;
case EmbeddedPackagePart.RelationshipTypeConstant:
openXmlPart = new EmbeddedPackagePart();
return;
case ThemeOverridePart.RelationshipTypeConstant:
openXmlPart = new ThemeOverridePart();
return;
case ChartStylePart.RelationshipTypeConstant:
openXmlPart = new ChartStylePart();
return;
case ChartColorStylePart.RelationshipTypeConstant:
openXmlPart = new ChartColorStylePart();
return;
case DiagramColorsPart.RelationshipTypeConstant:
openXmlPart = new DiagramColorsPart();
return;
case DiagramDataPart.RelationshipTypeConstant:
openXmlPart = new DiagramDataPart();
return;
case SlidePart.RelationshipTypeConstant:
openXmlPart = new SlidePart();
return;
case DiagramPersistLayoutPart.RelationshipTypeConstant:
openXmlPart = new DiagramPersistLayoutPart();
return;
case DiagramLayoutDefinitionPart.RelationshipTypeConstant:
openXmlPart = new DiagramLayoutDefinitionPart();
return;
case DiagramStylePart.RelationshipTypeConstant:
openXmlPart = new DiagramStylePart();
return;
case EmbeddedObjectPart.RelationshipTypeConstant:
openXmlPart = new EmbeddedObjectPart();
return;
case VmlDrawingPart.RelationshipTypeConstant:
openXmlPart = new VmlDrawingPart();
return;
case LegacyDiagramTextPart.RelationshipTypeConstant:
openXmlPart = new LegacyDiagramTextPart();
return;
case EmbeddedControlPersistenceBinaryDataPart.RelationshipTypeConstant:
openXmlPart = new EmbeddedControlPersistenceBinaryDataPart();
return;
case NotesSlidePart.RelationshipTypeConstant:
openXmlPart = new NotesSlidePart();
return;
case NotesMasterPart.RelationshipTypeConstant:
openXmlPart = new NotesMasterPart();
return;
case ThemePart.RelationshipTypeConstant:
openXmlPart = new ThemePart();
return;
case UserDefinedTagsPart.RelationshipTypeConstant:
openXmlPart = new UserDefinedTagsPart();
return;
case SlideLayoutPart.RelationshipTypeConstant:
openXmlPart = new SlideLayoutPart();
return;
case SlideMasterPart.RelationshipTypeConstant:
openXmlPart = new SlideMasterPart();
return;
case EmbeddedControlPersistencePart.RelationshipTypeConstant:
openXmlPart = new EmbeddedControlPersistencePart();
return;
case SlideSyncDataPart.RelationshipTypeConstant:
openXmlPart = new SlideSyncDataPart();
return;
case WorksheetPart.RelationshipTypeConstant:
openXmlPart = new WorksheetPart();
return;
case DrawingsPart.RelationshipTypeConstant:
openXmlPart = new DrawingsPart();
return;
case WebExtensionPart.RelationshipTypeConstant:
openXmlPart = new WebExtensionPart();
return;
case PivotTablePart.RelationshipTypeConstant:
openXmlPart = new PivotTablePart();
return;
case PivotTableCacheDefinitionPart.RelationshipTypeConstant:
openXmlPart = new PivotTableCacheDefinitionPart();
return;
case PivotTableCacheRecordsPart.RelationshipTypeConstant:
openXmlPart = new PivotTableCacheRecordsPart();
return;
case SingleCellTablePart.RelationshipTypeConstant:
openXmlPart = new SingleCellTablePart();
return;
case TableDefinitionPart.RelationshipTypeConstant:
openXmlPart = new TableDefinitionPart();
return;
case QueryTablePart.RelationshipTypeConstant:
openXmlPart = new QueryTablePart();
return;
case ControlPropertiesPart.RelationshipTypeConstant:
openXmlPart = new ControlPropertiesPart();
return;
case CustomPropertyPart.RelationshipTypeConstant:
openXmlPart = new CustomPropertyPart();
return;
case WorksheetSortMapPart.RelationshipTypeConstant:
openXmlPart = new WorksheetSortMapPart();
return;
case SlicersPart.RelationshipTypeConstant:
openXmlPart = new SlicersPart();
return;
case TimeLinePart.RelationshipTypeConstant:
openXmlPart = new TimeLinePart();
return;
case DocumentSettingsPart.RelationshipTypeConstant:
openXmlPart = new DocumentSettingsPart();
return;
case MailMergeRecipientDataPart.RelationshipTypeConstant:
openXmlPart = new MailMergeRecipientDataPart();
return;
case EndnotesPart.RelationshipTypeConstant:
openXmlPart = new EndnotesPart();
return;
case FontTablePart.RelationshipTypeConstant:
openXmlPart = new FontTablePart();
return;
case FontPart.RelationshipTypeConstant:
openXmlPart = new FontPart();
return;
case FootnotesPart.RelationshipTypeConstant:
openXmlPart = new FootnotesPart();
return;
case NumberingDefinitionsPart.RelationshipTypeConstant:
openXmlPart = new NumberingDefinitionsPart();
return;
case StyleDefinitionsPart.RelationshipTypeConstant:
openXmlPart = new StyleDefinitionsPart();
return;
case StylesWithEffectsPart.RelationshipTypeConstant:
openXmlPart = new StylesWithEffectsPart();
return;
case WebSettingsPart.RelationshipTypeConstant:
openXmlPart = new WebSettingsPart();
return;
case FooterPart.RelationshipTypeConstant:
openXmlPart = new FooterPart();
return;
case HeaderPart.RelationshipTypeConstant:
openXmlPart = new HeaderPart();
return;
case WordprocessingPrinterSettingsPart.RelationshipTypeConstant:
openXmlPart = new WordprocessingPrinterSettingsPart();
return;
case CustomizationPart.RelationshipTypeConstant:
openXmlPart = new CustomizationPart();
return;
case WordAttachedToolbarsPart.RelationshipTypeConstant:
openXmlPart = new WordAttachedToolbarsPart();
return;
case VbaProjectPart.RelationshipTypeConstant:
openXmlPart = new VbaProjectPart();
return;
case VbaDataPart.RelationshipTypeConstant:
openXmlPart = new VbaDataPart();
return;
case WordprocessingCommentsExPart.RelationshipTypeConstant:
openXmlPart = new WordprocessingCommentsExPart();
return;
case WordprocessingPeoplePart.RelationshipTypeConstant:
openXmlPart = new WordprocessingPeoplePart();
return;
case ThumbnailPart.RelationshipTypeConstant:
openXmlPart = new ThumbnailPart();
return;
case CoreFilePropertiesPart.RelationshipTypeConstant:
openXmlPart = new CoreFilePropertiesPart();
return;
case ExtendedFilePropertiesPart.RelationshipTypeConstant:
openXmlPart = new ExtendedFilePropertiesPart();
return;
case CustomFilePropertiesPart.RelationshipTypeConstant:
openXmlPart = new CustomFilePropertiesPart();
return;
case DigitalSignatureOriginPart.RelationshipTypeConstant:
openXmlPart = new DigitalSignatureOriginPart();
return;
case XmlSignaturePart.RelationshipTypeConstant:
openXmlPart = new XmlSignaturePart();
return;
case QuickAccessToolbarCustomizationsPart.RelationshipTypeConstant:
openXmlPart = new QuickAccessToolbarCustomizationsPart();
return;
case RibbonExtensibilityPart.RelationshipTypeConstant:
openXmlPart = new RibbonExtensibilityPart();
return;
case RibbonAndBackstageCustomizationsPart.RelationshipTypeConstant:
openXmlPart = new RibbonAndBackstageCustomizationsPart();
return;
case WebExTaskpanesPart.RelationshipTypeConstant:
openXmlPart = new WebExTaskpanesPart();
return;
}
}
else if (openXmlPackage is SpreadsheetDocument)
{
switch (relationshipType)
{
case WorkbookPart.RelationshipTypeConstant:
openXmlPart = new WorkbookPart();
return;
case CustomXmlPart.RelationshipTypeConstant:
openXmlPart = new CustomXmlPart();
return;
case CustomXmlPropertiesPart.RelationshipTypeConstant:
openXmlPart = new CustomXmlPropertiesPart();
return;
case CalculationChainPart.RelationshipTypeConstant:
openXmlPart = new CalculationChainPart();
return;
case CellMetadataPart.RelationshipTypeConstant:
openXmlPart = new CellMetadataPart();
return;
case ConnectionsPart.RelationshipTypeConstant:
openXmlPart = new ConnectionsPart();
return;
case CustomXmlMappingsPart.RelationshipTypeConstant:
openXmlPart = new CustomXmlMappingsPart();
return;
case SharedStringTablePart.RelationshipTypeConstant:
openXmlPart = new SharedStringTablePart();
return;
case WorkbookRevisionHeaderPart.RelationshipTypeConstant:
openXmlPart = new WorkbookRevisionHeaderPart();
return;
case WorkbookRevisionLogPart.RelationshipTypeConstant:
openXmlPart = new WorkbookRevisionLogPart();
return;
case WorkbookUserDataPart.RelationshipTypeConstant:
openXmlPart = new WorkbookUserDataPart();
return;
case WorkbookStylesPart.RelationshipTypeConstant:
openXmlPart = new WorkbookStylesPart();
return;
case ThemePart.RelationshipTypeConstant:
openXmlPart = new ThemePart();
return;
case ImagePart.RelationshipTypeConstant:
openXmlPart = new ImagePart();
return;
case ThumbnailPart.RelationshipTypeConstant:
openXmlPart = new ThumbnailPart();
return;
case VolatileDependenciesPart.RelationshipTypeConstant:
openXmlPart = new VolatileDependenciesPart();
return;
case ChartsheetPart.RelationshipTypeConstant:
openXmlPart = new ChartsheetPart();
return;
case SpreadsheetPrinterSettingsPart.RelationshipTypeConstant:
openXmlPart = new SpreadsheetPrinterSettingsPart();
return;
case DrawingsPart.RelationshipTypeConstant:
openXmlPart = new DrawingsPart();
return;
case ChartPart.RelationshipTypeConstant:
openXmlPart = new ChartPart();
return;
case ChartDrawingPart.RelationshipTypeConstant:
openXmlPart = new ChartDrawingPart();
return;
case EmbeddedPackagePart.RelationshipTypeConstant:
openXmlPart = new EmbeddedPackagePart();
return;
case ThemeOverridePart.RelationshipTypeConstant:
openXmlPart = new ThemeOverridePart();
return;
case ChartStylePart.RelationshipTypeConstant:
openXmlPart = new ChartStylePart();
return;
case ChartColorStylePart.RelationshipTypeConstant:
openXmlPart = new ChartColorStylePart();
return;
case DiagramColorsPart.RelationshipTypeConstant:
openXmlPart = new DiagramColorsPart();
return;
case DiagramDataPart.RelationshipTypeConstant:
openXmlPart = new DiagramDataPart();
return;
case SlidePart.RelationshipTypeConstant:
openXmlPart = new SlidePart();
return;
case DiagramPersistLayoutPart.RelationshipTypeConstant:
openXmlPart = new DiagramPersistLayoutPart();
return;
case DiagramLayoutDefinitionPart.RelationshipTypeConstant:
openXmlPart = new DiagramLayoutDefinitionPart();
return;
case DiagramStylePart.RelationshipTypeConstant:
openXmlPart = new DiagramStylePart();
return;
case EmbeddedObjectPart.RelationshipTypeConstant:
openXmlPart = new EmbeddedObjectPart();
return;
case VmlDrawingPart.RelationshipTypeConstant:
openXmlPart = new VmlDrawingPart();
return;
case LegacyDiagramTextPart.RelationshipTypeConstant:
openXmlPart = new LegacyDiagramTextPart();
return;
case EmbeddedControlPersistenceBinaryDataPart.RelationshipTypeConstant:
openXmlPart = new EmbeddedControlPersistenceBinaryDataPart();
return;
case NotesSlidePart.RelationshipTypeConstant:
openXmlPart = new NotesSlidePart();
return;
case NotesMasterPart.RelationshipTypeConstant:
openXmlPart = new NotesMasterPart();
return;
case UserDefinedTagsPart.RelationshipTypeConstant:
openXmlPart = new UserDefinedTagsPart();
return;
case SlideLayoutPart.RelationshipTypeConstant:
openXmlPart = new SlideLayoutPart();
return;
case SlideMasterPart.RelationshipTypeConstant:
openXmlPart = new SlideMasterPart();
return;
case EmbeddedControlPersistencePart.RelationshipTypeConstant:
openXmlPart = new EmbeddedControlPersistencePart();
return;
case SlideSyncDataPart.RelationshipTypeConstant:
openXmlPart = new SlideSyncDataPart();
return;
case WorksheetPart.RelationshipTypeConstant:
openXmlPart = new WorksheetPart();
return;
case WorksheetCommentsPart.RelationshipTypeConstant:
openXmlPart = new WorksheetCommentsPart();
return;
case PivotTablePart.RelationshipTypeConstant:
openXmlPart = new PivotTablePart();
return;
case PivotTableCacheDefinitionPart.RelationshipTypeConstant:
openXmlPart = new PivotTableCacheDefinitionPart();
return;
case PivotTableCacheRecordsPart.RelationshipTypeConstant:
openXmlPart = new PivotTableCacheRecordsPart();
return;
case SingleCellTablePart.RelationshipTypeConstant:
openXmlPart = new SingleCellTablePart();
return;
case TableDefinitionPart.RelationshipTypeConstant:
openXmlPart = new TableDefinitionPart();
return;
case QueryTablePart.RelationshipTypeConstant:
openXmlPart = new QueryTablePart();
return;
case ControlPropertiesPart.RelationshipTypeConstant:
openXmlPart = new ControlPropertiesPart();
return;
case CustomPropertyPart.RelationshipTypeConstant:
openXmlPart = new CustomPropertyPart();
return;
case WorksheetSortMapPart.RelationshipTypeConstant:
openXmlPart = new WorksheetSortMapPart();
return;
case SlicersPart.RelationshipTypeConstant:
openXmlPart = new SlicersPart();
return;
case TimeLinePart.RelationshipTypeConstant:
openXmlPart = new TimeLinePart();
return;
case WebExtensionPart.RelationshipTypeConstant:
openXmlPart = new WebExtensionPart();
return;
case DialogsheetPart.RelationshipTypeConstant:
openXmlPart = new DialogsheetPart();
return;
case ExternalWorkbookPart.RelationshipTypeConstant:
openXmlPart = new ExternalWorkbookPart();
return;
case ExcelAttachedToolbarsPart.RelationshipTypeConstant:
openXmlPart = new ExcelAttachedToolbarsPart();
return;
case VbaProjectPart.RelationshipTypeConstant:
openXmlPart = new VbaProjectPart();
return;
case VbaDataPart.RelationshipTypeConstant:
openXmlPart = new VbaDataPart();
return;
case MacroSheetPart.RelationshipTypeConstant:
openXmlPart = new MacroSheetPart();
return;
case InternationalMacroSheetPart.RelationshipTypeConstant:
openXmlPart = new InternationalMacroSheetPart();
return;
case CustomDataPropertiesPart.RelationshipTypeConstant:
openXmlPart = new CustomDataPropertiesPart();
return;
case CustomDataPart.RelationshipTypeConstant:
openXmlPart = new CustomDataPart();
return;
case SlicerCachePart.RelationshipTypeConstant:
openXmlPart = new SlicerCachePart();
return;
case TimeLineCachePart.RelationshipTypeConstant:
openXmlPart = new TimeLineCachePart();
return;
case CoreFilePropertiesPart.RelationshipTypeConstant:
openXmlPart = new CoreFilePropertiesPart();
return;
case ExtendedFilePropertiesPart.RelationshipTypeConstant:
openXmlPart = new ExtendedFilePropertiesPart();
return;
case CustomFilePropertiesPart.RelationshipTypeConstant:
openXmlPart = new CustomFilePropertiesPart();
return;
case DigitalSignatureOriginPart.RelationshipTypeConstant:
openXmlPart = new DigitalSignatureOriginPart();
return;
case XmlSignaturePart.RelationshipTypeConstant:
openXmlPart = new XmlSignaturePart();
return;
case QuickAccessToolbarCustomizationsPart.RelationshipTypeConstant:
openXmlPart = new QuickAccessToolbarCustomizationsPart();
return;
case RibbonExtensibilityPart.RelationshipTypeConstant:
openXmlPart = new RibbonExtensibilityPart();
return;
case RibbonAndBackstageCustomizationsPart.RelationshipTypeConstant:
openXmlPart = new RibbonAndBackstageCustomizationsPart();
return;
case WebExTaskpanesPart.RelationshipTypeConstant:
openXmlPart = new WebExTaskpanesPart();
return;
}
}
else if (openXmlPackage is PresentationDocument)
{
switch (relationshipType)
{
case PresentationPart.RelationshipTypeConstant:
openXmlPart = new PresentationPart();
return;
case CustomXmlPart.RelationshipTypeConstant:
openXmlPart = new CustomXmlPart();
return;
case CustomXmlPropertiesPart.RelationshipTypeConstant:
openXmlPart = new CustomXmlPropertiesPart();
return;
case FontPart.RelationshipTypeConstant:
openXmlPart = new FontPart();
return;
case PresentationPropertiesPart.RelationshipTypeConstant:
openXmlPart = new PresentationPropertiesPart();
return;
case TableStylesPart.RelationshipTypeConstant:
openXmlPart = new TableStylesPart();
return;
case ThemePart.RelationshipTypeConstant:
openXmlPart = new ThemePart();
return;
case ImagePart.RelationshipTypeConstant:
openXmlPart = new ImagePart();
return;
case ViewPropertiesPart.RelationshipTypeConstant:
openXmlPart = new ViewPropertiesPart();
return;
case SlidePart.RelationshipTypeConstant:
openXmlPart = new SlidePart();
return;
case ChartPart.RelationshipTypeConstant:
openXmlPart = new ChartPart();
return;
case ChartDrawingPart.RelationshipTypeConstant:
openXmlPart = new ChartDrawingPart();
return;
case EmbeddedPackagePart.RelationshipTypeConstant:
openXmlPart = new EmbeddedPackagePart();
return;
case ThemeOverridePart.RelationshipTypeConstant:
openXmlPart = new ThemeOverridePart();
return;
case ChartStylePart.RelationshipTypeConstant:
openXmlPart = new ChartStylePart();
return;
case ChartColorStylePart.RelationshipTypeConstant:
openXmlPart = new ChartColorStylePart();
return;
case DiagramColorsPart.RelationshipTypeConstant:
openXmlPart = new DiagramColorsPart();
return;
case DiagramDataPart.RelationshipTypeConstant:
openXmlPart = new DiagramDataPart();
return;
case WorksheetPart.RelationshipTypeConstant:
openXmlPart = new WorksheetPart();
return;
case DrawingsPart.RelationshipTypeConstant:
openXmlPart = new DrawingsPart();
return;
case DiagramPersistLayoutPart.RelationshipTypeConstant:
openXmlPart = new DiagramPersistLayoutPart();
return;
case DiagramLayoutDefinitionPart.RelationshipTypeConstant:
openXmlPart = new DiagramLayoutDefinitionPart();
return;
case DiagramStylePart.RelationshipTypeConstant:
openXmlPart = new DiagramStylePart();
return;
case WebExtensionPart.RelationshipTypeConstant:
openXmlPart = new WebExtensionPart();
return;
case VmlDrawingPart.RelationshipTypeConstant:
openXmlPart = new VmlDrawingPart();
return;
case LegacyDiagramTextPart.RelationshipTypeConstant:
openXmlPart = new LegacyDiagramTextPart();
return;
case PivotTablePart.RelationshipTypeConstant:
openXmlPart = new PivotTablePart();
return;
case PivotTableCacheDefinitionPart.RelationshipTypeConstant:
openXmlPart = new PivotTableCacheDefinitionPart();
return;
case PivotTableCacheRecordsPart.RelationshipTypeConstant:
openXmlPart = new PivotTableCacheRecordsPart();
return;
case SingleCellTablePart.RelationshipTypeConstant:
openXmlPart = new SingleCellTablePart();
return;
case TableDefinitionPart.RelationshipTypeConstant:
openXmlPart = new TableDefinitionPart();
return;
case QueryTablePart.RelationshipTypeConstant:
openXmlPart = new QueryTablePart();
return;
case EmbeddedControlPersistencePart.RelationshipTypeConstant:
openXmlPart = new EmbeddedControlPersistencePart();
return;
case EmbeddedControlPersistenceBinaryDataPart.RelationshipTypeConstant:
openXmlPart = new EmbeddedControlPersistenceBinaryDataPart();
return;
case ControlPropertiesPart.RelationshipTypeConstant:
openXmlPart = new ControlPropertiesPart();
return;
case EmbeddedObjectPart.RelationshipTypeConstant:
openXmlPart = new EmbeddedObjectPart();
return;
case CustomPropertyPart.RelationshipTypeConstant:
openXmlPart = new CustomPropertyPart();
return;
case WorksheetSortMapPart.RelationshipTypeConstant:
openXmlPart = new WorksheetSortMapPart();
return;
case SlicersPart.RelationshipTypeConstant:
openXmlPart = new SlicersPart();
return;
case TimeLinePart.RelationshipTypeConstant:
openXmlPart = new TimeLinePart();
return;
case SlideCommentsPart.RelationshipTypeConstant:
openXmlPart = new SlideCommentsPart();
return;
case NotesSlidePart.RelationshipTypeConstant:
openXmlPart = new NotesSlidePart();
return;
case NotesMasterPart.RelationshipTypeConstant:
openXmlPart = new NotesMasterPart();
return;
case UserDefinedTagsPart.RelationshipTypeConstant:
openXmlPart = new UserDefinedTagsPart();
return;
case SlideLayoutPart.RelationshipTypeConstant:
openXmlPart = new SlideLayoutPart();
return;
case SlideMasterPart.RelationshipTypeConstant:
openXmlPart = new SlideMasterPart();
return;
case SlideSyncDataPart.RelationshipTypeConstant:
openXmlPart = new SlideSyncDataPart();
return;
case CommentAuthorsPart.RelationshipTypeConstant:
openXmlPart = new CommentAuthorsPart();
return;
case HandoutMasterPart.RelationshipTypeConstant:
openXmlPart = new HandoutMasterPart();
return;
case LegacyDiagramTextInfoPart.RelationshipTypeConstant:
openXmlPart = new LegacyDiagramTextInfoPart();
return;
case VbaProjectPart.RelationshipTypeConstant:
openXmlPart = new VbaProjectPart();
return;
case VbaDataPart.RelationshipTypeConstant:
openXmlPart = new VbaDataPart();
return;
case CoreFilePropertiesPart.RelationshipTypeConstant:
openXmlPart = new CoreFilePropertiesPart();
return;
case ExtendedFilePropertiesPart.RelationshipTypeConstant:
openXmlPart = new ExtendedFilePropertiesPart();
return;
case CustomFilePropertiesPart.RelationshipTypeConstant:
openXmlPart = new CustomFilePropertiesPart();
return;
case ThumbnailPart.RelationshipTypeConstant:
openXmlPart = new ThumbnailPart();
return;
case DigitalSignatureOriginPart.RelationshipTypeConstant:
openXmlPart = new DigitalSignatureOriginPart();
return;
case XmlSignaturePart.RelationshipTypeConstant:
openXmlPart = new XmlSignaturePart();
return;
case QuickAccessToolbarCustomizationsPart.RelationshipTypeConstant:
openXmlPart = new QuickAccessToolbarCustomizationsPart();
return;
case RibbonExtensibilityPart.RelationshipTypeConstant:
openXmlPart = new RibbonExtensibilityPart();
return;
case RibbonAndBackstageCustomizationsPart.RelationshipTypeConstant:
openXmlPart = new RibbonAndBackstageCustomizationsPart();
return;
case WebExTaskpanesPart.RelationshipTypeConstant:
openXmlPart = new WebExTaskpanesPart();
return;
}
}
else
{
System.Diagnostics.Debug.Assert(false);
}
return;
}
/// <summary>
/// Converts an <see cref="OpenXmlPackage"/> into a CodeDom object that can be used
/// to build code in a given .NET language to build the referenced <paramref name="pkg"/>.
/// </summary>
/// <param name="pkg">
/// The <see cref="OpenXmlPackage"/> object to generate source code for.
/// </param>
/// <param name="opts">
/// The <see cref="NamespaceAliasOptions"/> to apply to the resulting source code.
/// </param>
/// <returns>
/// A new <see cref="CodeCompileUnit"/> containing the instructions to build
/// the referenced <see cref="OpenXmlPackage"/>.
/// </returns>
public static CodeCompileUnit GenerateSourceCode(this OpenXmlPackage pkg, NamespaceAliasOptions opts)
{
return pkg.GenerateSourceCode(new DefaultSerializeSettings(opts));
}
private void SetPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Creator = "Dan Ito";
document.PackageProperties.Title = "PowerPoint プレゼンテーション";
document.PackageProperties.Revision = "15";
document.PackageProperties.Created = System.Xml.XmlConvert.ToDateTime("2012-01-27T09:12:05Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.Modified = System.Xml.XmlConvert.ToDateTime("2012-10-03T08:43:44Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.LastModifiedBy = "Dan Ito";
}
/// <summary>
/// Converts an <see cref="OpenXmlPackage"/> into a CodeDom object that can be used
/// to build code in a given .NET language to build the referenced <paramref name="pkg"/>.
/// </summary>
/// <param name="pkg">
/// The <see cref="OpenXmlPackage"/> object to generate source code for.
/// </param>
/// <param name="settings">
/// The <see cref="ISerializeSettings"/> to use during the code generation
/// process.
/// </param>
/// <returns>
/// A new <see cref="CodeCompileUnit"/> containing the instructions to build
/// the referenced <see cref="OpenXmlPackage"/>.
/// </returns>
public static CodeCompileUnit GenerateSourceCode(this OpenXmlPackage pkg, ISerializeSettings settings)
{
const string pkgVarName = "pkg";
const string paramName = "pathToFile";
var result = new CodeCompileUnit();
var pkgType = pkg.GetType();
var pkgTypeName = pkgType.Name;
var partTypeCounts = new Dictionary<string, int>();
var namespaces = new SortedSet<string>();
var mainNamespace = new CodeNamespace(settings.NamespaceName);
var bluePrints = new OpenXmlPartBluePrintCollection();
CodeConditionStatement conditionStatement;
CodeMemberMethod entryPoint;
CodeMemberMethod createParts;
CodeTypeDeclaration mainClass;
CodeTryCatchFinallyStatement tryAndCatch;
CodeFieldReferenceExpression docTypeVarRef = null;
Type docTypeEnum;
string docTypeEnumVal;
KeyValuePair<string, Type> rootVarType;
// Add all initial namespace names first
namespaces.Add("System");
// The OpenXmlDocument derived parts all contain a property called "DocumentType"
// but the property types differ depending on the derived part. Need to get both
// the enum name of selected value to use as a parameter for the Create statement.
switch (pkg)
{
case PresentationDocument p:
docTypeEnum = p.DocumentType.GetType();
docTypeEnumVal = p.DocumentType.ToString();
break;
case SpreadsheetDocument s:
docTypeEnum = s.DocumentType.GetType();
docTypeEnumVal = s.DocumentType.ToString();
break;
case WordprocessingDocument w:
docTypeEnum = w.DocumentType.GetType();
docTypeEnumVal = w.DocumentType.ToString();
break;
default:
throw new ArgumentException("object is not a recognized OpenXmlPackage type.", nameof(pkg));
}
// Create the entry method
entryPoint = new CodeMemberMethod()
{
Name = "CreatePackage",
ReturnType = new CodeTypeReference(),
Attributes = MemberAttributes.Public | MemberAttributes.Final
};
entryPoint.Parameters.Add(
new CodeParameterDeclarationExpression(typeof(string).Name, paramName));
// Create package declaration expression first
entryPoint.Statements.Add(new CodeVariableDeclarationStatement(pkgTypeName, pkgVarName,
new CodePrimitiveExpression(null)));
// Add the required DocumentType parameter here, if available
if (docTypeEnum != null)
{
namespaces.Add(docTypeEnum.Namespace);
var simpleFieldRef = new CodeVariableReferenceExpression(
docTypeEnum.GetObjectTypeName(settings.NamespaceAliasOptions.Order));
docTypeVarRef = new CodeFieldReferenceExpression(simpleFieldRef, docTypeEnumVal);
}
// initialize package var
var pkgCreateMethod = new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression(pkgTypeName),
"Create");
var pkgCreateInvoke = new CodeMethodInvokeExpression(pkgCreateMethod,
new CodeArgumentReferenceExpression(paramName),
docTypeVarRef);
var initializePkg = new CodeAssignStatement(
new CodeVariableReferenceExpression(pkgVarName),
pkgCreateInvoke);
// Call CreateParts method
var partsCreateMethod = new CodeMethodReferenceExpression(
new CodeThisReferenceExpression(),
"CreateParts");
var partsCreateInvoke = new CodeMethodInvokeExpression(
partsCreateMethod,
new CodeDirectionExpression(FieldDirection.Ref,
new CodeVariableReferenceExpression(pkgVarName)));
// Clean up pkg var
var pkgDisposeMethod = new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression(pkgVarName),
"Dispose");
var pkgDisposeInvoke = new CodeMethodInvokeExpression(
pkgDisposeMethod);
// Setup the try/catch statement to properly initialize the pkg var
tryAndCatch = new CodeTryCatchFinallyStatement();
// Try statements
tryAndCatch.TryStatements.Add(initializePkg);
tryAndCatch.TryStatements.AddBlankLine();
tryAndCatch.TryStatements.Add(partsCreateInvoke);
// If statement to ensure pkgVarName is not null before trying to dispose
conditionStatement = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression(pkgVarName),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)));
conditionStatement.TrueStatements.Add(pkgDisposeInvoke);
// Finally statements
tryAndCatch.FinallyStatements.Add(conditionStatement);
entryPoint.Statements.Add(tryAndCatch);
// Create the CreateParts method
createParts = new CodeMemberMethod()
{
Name = "CreateParts",
ReturnType = new CodeTypeReference(),
Attributes = MemberAttributes.Private | MemberAttributes.Final
};
createParts.Parameters.Add(new CodeParameterDeclarationExpression(pkgTypeName, pkgVarName)
{ Direction = FieldDirection.Ref });
// Add all of the child part references here
if (pkg.Parts != null)
{
var customNewPartTypes = new Type[] { typeof(PresentationPart), typeof(WorkbookPart), typeof(MainDocumentPart) };
OpenXmlPartBluePrint bpTemp;
CodeMethodReferenceExpression referenceExpression;
CodeMethodInvokeExpression invokeExpression;
CodeMethodReferenceExpression methodReference;
Type currentPartType;
string varName = null;
string initMethodName = null;
string mainPartTypeName;
foreach (var pair in pkg.Parts)
{
// Need special handling rules for WorkbookPart, MainDocumentPart, and PresentationPart
// objects. They cannot be created using the usual "AddNewPart" methods, unfortunately.
currentPartType = pair.OpenXmlPart.GetType();
if (customNewPartTypes.Contains(currentPartType))
{
namespaces.Add(currentPartType.Namespace);
mainPartTypeName = currentPartType.Name;
if (pair.OpenXmlPart is PresentationPart)
{
varName = "presentationPart";
initMethodName = "AddPresentationPart";
}
else if (pair.OpenXmlPart is WorkbookPart)
{
varName = "workbookPart";
initMethodName = "AddWorkbookPart";
}
else if (pair.OpenXmlPart is MainDocumentPart)
{
varName = "mainDocumentPart";
initMethodName = "AddMainDocumentPart";
}
rootVarType = new KeyValuePair<string, Type>(varName, currentPartType);
// Setup the blueprint
bpTemp = new OpenXmlPartBluePrint(pair.OpenXmlPart, varName);
// Setup the add new part statement for the current OpenXmlPart object
referenceExpression = new CodeMethodReferenceExpression(
new CodeArgumentReferenceExpression(pkgVarName), initMethodName);
invokeExpression = new CodeMethodInvokeExpression(referenceExpression);
createParts.Statements.Add(new CodeVariableDeclarationStatement(mainPartTypeName, varName, invokeExpression));
// Add the call to the method to populate the current OpenXmlPart object
methodReference = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), bpTemp.MethodName);
createParts.Statements.Add(new CodeMethodInvokeExpression(methodReference,
new CodeDirectionExpression(FieldDirection.Ref, new CodeVariableReferenceExpression(varName))));
// Add the current main part to the collection of blueprints to ensure that the appropriate 'Generate*'
// method is added to the collection of helper methods.
bluePrints.Add(bpTemp);
// Add a blank line for clarity
createParts.Statements.AddBlankLine();
// now create the child parts for the current one an continue the loop to avoid creating
// an additional invalid 'AddNewPart' method for the current main part.
foreach (var child in pair.OpenXmlPart.Parts)
{
createParts.Statements.AddRange(
OpenXmlPartExtensions.BuildEntryMethodCodeStatements(
child, settings, partTypeCounts, namespaces, bluePrints, rootVarType));
}
continue;
}
rootVarType = new KeyValuePair<string, Type>(pkgVarName, pkgType);
createParts.Statements.AddRange(
OpenXmlPartExtensions.BuildEntryMethodCodeStatements(
pair, settings, partTypeCounts, namespaces, bluePrints, rootVarType));
}
}
// Setup the main class next
mainClass = new CodeTypeDeclaration($"{pkgTypeName}BuilderClass")
{
IsClass = true,
Attributes = MemberAttributes.Public
};
// Setup the main class members
mainClass.Members.Add(entryPoint);
mainClass.Members.Add(createParts);
mainClass.Members.AddRange(OpenXmlPartExtensions.BuildHelperMethods
(bluePrints, settings, namespaces));
// Setup the imports
var codeNameSpaces = new List<CodeNamespaceImport>(namespaces.Count);
foreach (var ns in namespaces)
{
codeNameSpaces.Add(ns.GetCodeNamespaceImport(settings.NamespaceAliasOptions));
}
codeNameSpaces.Sort(new CodeNamespaceImportComparer());
mainNamespace.Imports.AddRange(codeNameSpaces.ToArray());
mainNamespace.Types.Add(mainClass);
// Finish up
result.Namespaces.Add(mainNamespace);
return result;
}
/// <summary>
/// Validates the specified content in the OpenXmlPart.
/// </summary>
/// <param name="openXmlPart">The target OpenXmlPart.</param>
/// <returns>A set of validation erros.</returns>
/// <exception cref="ArgumentNullException">Thrown when the "openXmlPart" parameter is null.</exception>
/// <exception cref="InvalidOperationException">Throw when the specified part is not a defined part in the specified FileFormat version.</exception>
public IEnumerable <ValidationErrorInfo> Validate(OpenXmlPart openXmlPart)
{
if (openXmlPart == null)
{
throw new ArgumentNullException("openXmlPart");
}
var openXmlPackage = openXmlPart.OpenXmlPackage;
if (openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.ProcessMode != MarkupCompatibilityProcessMode.NoProcess &&
openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.TargetFileFormatVersions != this.FileFormat)
{
string exceptionMessage = string.Format(System.Globalization.CultureInfo.CurrentUICulture,
ExceptionMessages.DocumentFileFormatVersionMismatch,
openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.TargetFileFormatVersions, this.FileFormat);
throw new InvalidOperationException(exceptionMessage);
}
if (!openXmlPart.IsInVersion(this.FileFormat))
{
if (openXmlPart is ExtendedPart)
{
throw new InvalidOperationException(ExceptionMessages.PartNotInVersion);
}
else
{
string strMessage;
// All Office 2007 and 2010 parts are allowed in Office 2013.
switch (this.FileFormat)
{
case FileFormatVersions.Office2007:
strMessage = "ExceptionMessages.PartIsNotInOffice2007";
break;
case FileFormatVersions.Office2010:
strMessage = "ExceptionMessages.PartIsNotInOffice2010";
break;
case FileFormatVersions.Office2013: // Falls through...
default:
strMessage = "ExceptionMessages.PartIsNotInOffice2013";
break;
}
throw new InvalidOperationException(strMessage);
}
}
// Do NOT use "yield return" in this method, as "yield return" are deferred executed.
// Otherwise, the null check is not performed when the method is called, but rather, when the returned enumerator is moved for the first time.
// That means that the exception isn't thrown until possibly far, far away from the actual site of the error, which is potentially confusing.
OpenXmlPackage package = openXmlPart.OpenXmlPackage;
Debug.Assert(package != null);
ValidationResult validationResult = null;
switch (DocumentTypeDetector.GetDocumentType(package))
{
case OpenXmlDocumentType.Spreadsheet:
validationResult = this.SpreadsheetDocumentValidator.Validate(openXmlPart);
break;
case OpenXmlDocumentType.Wordprocessing:
validationResult = this.WordprocessingDocumentValidator.Validate(openXmlPart);
break;
case OpenXmlDocumentType.Presentation:
validationResult = this.PresentationDocumentValidator.Validate(openXmlPart);
break;
default:
throw new System.IO.InvalidDataException(ExceptionMessages.UnknownPackage);
}
return(this.YieldResult(validationResult));
}
public void CreateWithNoAutoSaveTest()
{
this.MyTestInitialize(TestContext.GetCurrentMethod());
var testfiles = CopyTestFiles("bvt")
.Where(fi => fi.IsOpenXmlFile());
OpenXmlPackage createdPackage = null;
foreach (var testfile in testfiles)
{
string newlyCreatedName = null;
if (testfile.IsWordprocessingFile())
{
newlyCreatedName = Path.Combine(TestUtil.TestResultsDirectory, Guid.NewGuid().ToString() + ".docx");
}
else if (testfile.IsSpreadsheetFile())
{
newlyCreatedName = Path.Combine(TestUtil.TestResultsDirectory, Guid.NewGuid().ToString() + ".xlsx");
}
else if (testfile.IsPresentationFile())
{
newlyCreatedName = Path.Combine(TestUtil.TestResultsDirectory, Guid.NewGuid().ToString() + ".pptx");
}
Log.Comment("Opening source package in readOnly mode...");
var sourcePackage = testfile.OpenPackage(false);
Log.Comment("Creating new package with overload that no autoSave option");
if (testfile.IsWordprocessingFile())
{
createdPackage = WordprocessingDocument.Create(newlyCreatedName, WordprocessingDocumentType.Document);
}
else if (testfile.IsSpreadsheetFile())
{
createdPackage = SpreadsheetDocument.Create(newlyCreatedName, SpreadsheetDocumentType.Workbook);
}
else if (testfile.IsPresentationFile())
{
createdPackage = PresentationDocument.Create(newlyCreatedName, PresentationDocumentType.Presentation);
}
else
{
Log.Fail("Unexpected document type passed in.");
}
if (createdPackage != null)
{
Log.Comment("Feeding main part with DOM operations...");
duplicteMainPart(sourcePackage, createdPackage);
Log.Comment("Closing package...");
createdPackage.Close();
}
Log.Warning("Reopening...Expecting null for root element of main part as AutoSave default value is true thus DOM changes will be saved.");
if (testfile.IsWordprocessingFile())
{
createdPackage = WordprocessingDocument.Open(newlyCreatedName, false);
}
else if (testfile.IsSpreadsheetFile())
{
createdPackage = SpreadsheetDocument.Open(newlyCreatedName, false);
}
else if (testfile.IsPresentationFile())
{
createdPackage = PresentationDocument.Open(newlyCreatedName, false);
}
else
{
Log.Fail("Unexpected document type passed in.");
}
var mainpart = createdPackage.MainPart();
var dom = mainpart.RootElement;
if (dom != null)
{
Log.Pass("Root element of main part is not null just as expected.");
}
else
{
Log.Fail("Null root element of main part. Something must be wrong.");
}
createdPackage.Close();
FileInfo fz = new FileInfo(newlyCreatedName);
if (fz.Exists)
{
fz.Delete();
}
}
}
/// <summary>
/// Initializes a new instance of the OpenXmlPackagePartIterator class using the supplied OpenXmlPackage class.
/// </summary>
/// <param name="package">The OpenXmlPackage to use to enumerate parts</param>
public OpenXmlParts(OpenXmlPackage package)
{
_package = package;
}
private static string GetDocumentName(OpenXmlPackage document)
{
return(document.GetType().Name);
}
private void SetPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Creator = "ppelletier";
document.PackageProperties.Title = "Product to review";
document.PackageProperties.Subject = "";
document.PackageProperties.Keywords = "";
document.PackageProperties.Description = "";
document.PackageProperties.Revision = "4";
document.PackageProperties.Created = System.Xml.XmlConvert.ToDateTime("2010-01-19T15:22:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.Modified = System.Xml.XmlConvert.ToDateTime("2010-01-19T15:24:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.LastModifiedBy = "Julien Blin";
document.PackageProperties.LastPrinted = System.Xml.XmlConvert.ToDateTime("2006-09-26T13:33:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
}
private static void ApplyContent(ReportData pClient, OpenXmlPackage pPackage, BlockItem pBlock, TableDefinition pContent, Dictionary <string, string> pOptions)
{
try
{
string chartId = null;
var phElem = GetElements(pBlock.OxpBlock, pClient.ReportType)?.ToList();
if (phElem == null || phElem.Count == 0)
{
LogHelper.Instance.LogError("No placeholder content found.");
return;
}
#region Get the block Id in document
var allElementInPlaceHolder = GetElementsInPlaceHolder(pClient, phElem);
XElement graphicElement = phElem.Descendants(A.graphic).FirstOrDefault() ?? phElem.FirstOrDefault(_ => A.graphic.Equals(_.Name));
if (null != graphicElement)
{
XElement chartElem = graphicElement.Descendants(C.chart).FirstOrDefault();
if (null != chartElem)
{
chartId = chartElem.Attribute(R.id)?.Value;
}
else
{
LogHelper.Instance.LogFatal("Graphic object present but not a graph.");
}
}
else
{
LogHelper.Instance.LogFatal("No graphic / chart object inside the block.");
}
if (null == chartId)
{
pBlock.XBlock.ReplaceWith(allElementInPlaceHolder); return;
}
#endregion Get the block Id in document
var chartPart = GetChartPart(pPackage, pBlock, chartId);
if (null != chartPart)
{
string spreadsheetId = GetSpreadsheetId(chartPart);
if (!string.IsNullOrWhiteSpace(spreadsheetId))
{
#region Associated content management
var embedPackage = (EmbeddedPackagePart)chartPart.GetPartById(spreadsheetId);
if (null != embedPackage)
{
using (var ms = new MemoryStream())
{
#region Set content in memory to work with
using (Stream str = embedPackage.GetStream())
{
StreamHelper.CopyStream(str, ms);
str.Close();
}
#endregion Set content in memory to work with
using (SpreadsheetDocument spreadsheetDoc = SpreadsheetDocument.Open(ms, true))
{
#region Associated Data File content Management
var ws = (OXS.Sheet)spreadsheetDoc.WorkbookPart.Workbook.Sheets.FirstOrDefault();
if (ws != null)
{
string sheetId = ws.Id;
var wsp = (WorksheetPart)spreadsheetDoc.WorkbookPart.GetPartById(sheetId);
XDocument shPart = wsp.GetXDocument();
XElement shData = shPart.Descendants(S.sheetData).FirstOrDefault();
#region Use of the data content (Only data, no titles)
if (null != shData)
{
IEnumerable <XElement> allRows = shData.Descendants(S.row); // => if ToList() cause some graph to fail to generate
int ctRow = 0;
int nbRows = allRows.Count();
// Cleaning Cells ======================================================================
// We clean row not having Cell information
int idxRow = 1;
var nbCorrectSeries = allRows.Where(x => x.Descendants(S.c).Any(y => y.Attribute(NoNamespace.r) != null &&
y.Attribute(NoNamespace.r)?.Value != ""))
.Max(x => x.Descendants(S.c).Count());
for (int ctn = 0; ctn < nbRows; ctn += 1)
{
var oneRow = allRows.ElementAt(ctn);//[ctn];
// DCO - 9/21/2012 - I added the condition that the count of CELL must be indeed equal of numCorrectSeries OR to the number of column
// It happens for graphs with 3 cells defined per row, but only two used (so no Value for third cell), when NbColumns was == 2
var isRowValid = ((oneRow.Descendants(S.c).Count() == nbCorrectSeries || oneRow.Descendants(S.c).Count() >= pContent.NbColumns) &&
(oneRow.Descendants(S.c).Descendants(S.v).Count() == oneRow.Descendants(S.c).Count() ||
oneRow.Descendants(S.c).Descendants(S.v).Count() >= pContent.NbColumns));
// We remove rows that are not defined in content
if (isRowValid == false || ctRow >= pContent.NbRows)
{
oneRow.Remove();
ctn -= 1;
nbRows -= 1;
continue;
}
var _xAttribute = oneRow.Attribute(NoNamespace.r);
if (_xAttribute != null)
{
_xAttribute.Value = idxRow.ToString();
}
idxRow += 1;
}
// ====================================================================================
// Copying new row ========================================================================
// We copied new row if needed and extrapolate formula
// Take cell with no t SharedString
nbRows = allRows.Count();
if (pContent.NbRows > nbRows)
{
// We need to detect the best ROW to copy
// Usually the first row is the header so it contains two cells with SharedString
// Case 1: For others rows, it will be two cells with value.
// Case 2: For other rows, it can be one cell with SharedString and one cell with value (in case of App Nane + value)
var oneSerieRow =
// Case 1
allRows.FirstOrDefault(x => x.Attribute(NoNamespace.r) != null &&
x.Attribute(NoNamespace.r)?.Value != "" && x.Descendants(S.c).Any() &&
x.Descendants(S.c).Attributes(NoNamespace.t).Any() == false)
?? // Case 2: One or several SharedString, but at least one Value (by using < content.NbColumns)
allRows.FirstOrDefault(x => x.Attribute(NoNamespace.r) != null &&
x.Attribute(NoNamespace.r)?.Value != "" && x.Descendants(S.c).Any() &&
x.Descendants(S.c).Attributes(NoNamespace.t).Count() < pContent.NbColumns)
?? // Case 3: Any row but the first (avoiding Header)
allRows.FirstOrDefault(x => x.Attribute(NoNamespace.r) != null &&
x.Attribute(NoNamespace.r)?.Value != "" &&
x.Attribute(NoNamespace.r)?.Value != "1" && x.Descendants(S.c).Any());
if (oneSerieRow != null)
{
var previousRowValue = Convert.ToInt32(oneSerieRow.Attribute(NoNamespace.r)?.Value);
while (nbRows < pContent.NbRows)
{
var newRow = new XElement(oneSerieRow);
var _xAttribute = newRow.Attribute(NoNamespace.r);
if (_xAttribute != null)
{
_xAttribute.Value = (nbRows + 1).ToString(); // DCO Correction, ROW ID starts at 1
}
var serieCells = newRow.Descendants(S.c);
foreach (var oneCell in serieCells)
{
if (oneCell.Attribute(NoNamespace.r) == null)
{
continue;
}
var previousFormula = oneCell.Attribute(NoNamespace.r)?.Value;
// We extrapolate
int indexRow;
int indexCol;
WorksheetAccessorExt.GetRowColumnValue(previousFormula, out indexRow, out indexCol);
int newRowValue = nbRows + 1 + (indexRow - previousRowValue);
var _attribute = oneCell.Attribute(NoNamespace.r);
if (_attribute != null)
{
_attribute.Value = string.Concat(WorksheetAccessor.GetColumnId(indexCol), newRowValue.ToString());
}
if (oneCell.Attributes(NoNamespace.t).Any() != true)
{
continue;
}
var vElement = oneCell.Descendants(S.v).FirstOrDefault();
if (vElement != null)
{
vElement.Value = WorksheetAccessorExt.AddSharedStringValue(spreadsheetDoc, "").ToString();
}
// ---
}
shData.Add(newRow);
nbRows += 1;
}
}
else
{
LogHelper.Instance.LogWarn("Adding Rows: Could not find a row without a SharedString element.");
}
}
//-----
// Define Sheet Dimension ================================================================
int minStartRow = -1;
int minStartCol = -1;
int maxEndRow = -1;
int maxEndCol = -1;
var entireScope = allRows.SelectMany(x => x.Descendants(S.c).Attributes(NoNamespace.r).Select(y => y.Value));
foreach (var oneFormula in entireScope)
{
var startRow = -1;
var endRow = -1;
var startCol = -1;
var endCol = -1;
WorksheetAccessorExt.GetFormulaCoord(oneFormula, out startRow, out startCol,
out endRow, out endCol);
if (minStartRow == -1 || startRow < minStartRow)
{
minStartRow = startRow;
}
if (minStartCol == -1 || startCol < minStartCol)
{
minStartCol = startCol;
}
if (maxEndRow == -1 || endRow > maxEndRow)
{
maxEndRow = endRow;
}
if (maxEndCol == -1 || endCol > maxEndCol)
{
maxEndCol = endCol;
}
}
XElement sheetDimension = shPart.Descendants(S.s + "dimension").FirstOrDefault();
if (sheetDimension?.Attribute(NoNamespace._ref) != null)
{
sheetDimension.Attribute(NoNamespace._ref)?.SetValue(WorksheetAccessorExt.SetFormula("", minStartRow, minStartCol, maxEndRow, maxEndCol, false));
}
// ====================================================================================
int contentEltCount = pContent.Data?.Count() ?? 0;
// Apply values =======================================================================
for (int ctn = 0; ctn < nbRows; ctn++)
{
var oneRow = allRows.ElementAt(ctn);
// TODO: We may have to correct the "spans" in: <row r="1" spans="1:3"
List <XElement> allCells = oneRow.Descendants(S.c).ToList();
var ctCell = 0;
int nbCells = allCells.Count;
for (int ctc = 0; ctc < nbCells; ctc++)
{
var oneCell = allCells[ctc];
// We remove cell if they are not defined as content columns
if (ctCell >= pContent.NbColumns)
{
LogHelper.Instance.LogWarn("More cells that defined content ");
if (null != oneCell.Parent)
{
oneCell.Remove();
}
ctc -= 1;
nbCells -= 1;
continue;
}
// We inject text
var targetText = ((ctRow * pContent.NbColumns + ctCell) < contentEltCount ?
pContent.Data?.ElementAt(ctRow * pContent.NbColumns + ctCell) :
string.Empty);
if (null != targetText && !"<KEEP>".Equals(targetText)) // Keep for managing UniversalGraph
{
var isSharedString = oneCell.Attribute(NoNamespace.t);
if (null != isSharedString && "s".Equals(isSharedString.Value))
{
if ("".Equals(targetText))
{
LogHelper.Instance.LogWarn("Target Text empty for Shared String, this can create abnormal behavior.");
}
var idx = Convert.ToInt32(oneCell.Value);
WorksheetAccessorExt.SetSharedStringValue(spreadsheetDoc, idx, targetText);
}
else
{
XElement cell = oneCell.Descendants(S.v).FirstOrDefault();
if (null != cell)
{
cell.Value = targetText;
}
else
{
LogHelper.Instance.LogWarn("No correct cell value found");
}
}
}
ctCell += 1;
}
ctRow += 1;
}
}
else
{
LogHelper.Instance.LogWarn("Embedded spreadsheet is not formatted correctly");
}
// ====================================================================================
#endregion Get and use of the data content (Only data, no titles)
// We modify Table Definition (defining scope of Graph)
foreach (TableDefinitionPart t in wsp.TableDefinitionParts)
{
t.Table.Reference = String.Concat(WorksheetAccessor.GetColumnId(1), 1, ":",
WorksheetAccessor.GetColumnId(pContent.NbColumns), pContent.NbRows);
// We reduce the scope TableColumn if needed
var columnCount = t.Table.TableColumns.Count;
for (int ctCol = 0; ctCol < columnCount; ctCol += 1)
{
var tabColumn = t.Table.TableColumns.ElementAt(ctCol);
if (ctCol >= pContent.NbColumns)
{
tabColumn.Remove();
ctCol -= 1;
columnCount -= 1; // DCO - 10/23/2012 - Correction when reducing scope to a column (count is corrected afterwards).
continue;
}
// We align column name with the correct Shared String
if (!string.IsNullOrEmpty(pContent.Data?.ElementAt(ctCol)) && ctCol < pContent.NbColumns && "<KEEP>" != pContent.Data.ElementAt(ctCol))
{
tabColumn.SetAttribute(new OpenXmlAttribute("", "name", "", pContent.Data.ElementAt(ctCol)));
}
}
// The Count attribute is not updated correctly, so we do the work for them :)
if (pContent.NbColumns < t.Table.TableColumns.Count)
{
t.Table.TableColumns.SetAttribute(new OpenXmlAttribute("", "count", "", pContent.NbColumns.ToString()));
}
}
// We save the XML content
wsp.PutXDocument(shPart);
}
// We update cached data in Word document
UpdateCachedValues(pClient, chartPart, spreadsheetDoc, pContent);
#endregion Associated Data File content Management
}
// Write the modified memory stream back
// into the embedded package part.
using (Stream s = embedPackage.GetStream())
{
ms.WriteTo(s);
s.SetLength(ms.Length);
}
}
}
else
{
LogHelper.Instance.LogWarn("No embedded excel file found.");
}
#endregion Associated content management
}
else
{
LogHelper.Instance.LogWarn("No spreadsheet identifier found.");
}
#region Additionnal parameters
if (null == pContent.GraphOptions || !pContent.GraphOptions.HasConfiguration)
{
return;
}
Chart chart = chartPart.ChartSpace.Descendants <Chart>().FirstOrDefault();
PlotArea p_c = chart?.PlotArea;
var primaryVerticalAxis = p_c?.Descendants <ValueAxis>().FirstOrDefault(_ => "valAx".Equals(_.LocalName));
if (pContent.GraphOptions.AxisConfiguration.VerticalAxisMinimal.HasValue)
{
if (primaryVerticalAxis != null)
{
primaryVerticalAxis.Scaling.MinAxisValue.Val = DoubleValue.FromDouble(pContent.GraphOptions.AxisConfiguration.VerticalAxisMinimal.Value);
}
}
if (!pContent.GraphOptions.AxisConfiguration.VerticalAxisMaximal.HasValue)
{
return;
}
// ReSharper disable once PossibleInvalidOperationException
if (primaryVerticalAxis != null)
{
primaryVerticalAxis.Scaling.MaxAxisValue.Val = DoubleValue.FromDouble(pContent.GraphOptions.AxisConfiguration.VerticalAxisMaximal.Value);
}
#endregion Additionnal parameters
}
}
catch (Exception exception)
{
LogHelper.Instance.LogError("Unexpected exception thrown.", exception);
throw;
}
}
public PackageValidator(OpenXmlPackage package)
{
_package = package;
}
private static void SetPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Creator = "bs";
document.PackageProperties.Title = "";
document.PackageProperties.Subject = "";
document.PackageProperties.Keywords = "";
document.PackageProperties.Description = "";
document.PackageProperties.Revision = "1";
document.PackageProperties.Created = System.Xml.XmlConvert.ToDateTime("2014-02-25T16:28:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.Modified = System.Xml.XmlConvert.ToDateTime("2014-02-25T16:28:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.LastModifiedBy = "bs";
}
/// <summary>
/// Gets all parts contained in the <see cref="OpenXmlPackage" /> in a
/// breadth-first fashion, i.e., the direct and indirect relationship
/// targets of the package (where the <see cref="OpenXmlPartContainer.Parts" />
/// property only returns the direct relationship targets).
/// </summary>
public static IEnumerable <OpenXmlPart> GetAllParts(this OpenXmlPackage package)
{
return(new OpenXmlParts(package));
}
internal void Load(OpenXmlPackage openXmlPackage, PackagePart packagePart)
{
Debug.Assert(openXmlPackage.Package.GetPart(packagePart.Uri) == packagePart);
this._openXmlPackage = openXmlPackage;
this._metroPart = packagePart;
this._uri = packagePart.Uri;
if (this._metroPart.GetRelationships().Any())
{
// Media (Audio, Video) parts should not reference any other parts.
throw new OpenXmlPackageException(ExceptionMessages.MediaDataPartShouldNotReferenceOtherParts);
}
}
private void SetPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Creator = "SCHERRY, Philip E.";
document.PackageProperties.Revision = "2";
document.PackageProperties.Created = System.Xml.XmlConvert.ToDateTime("2016-05-10T21:30:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.Modified = System.Xml.XmlConvert.ToDateTime("2016-05-10T21:30:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.LastModifiedBy = "Rory Norman";
document.PackageProperties.LastPrinted = System.Xml.XmlConvert.ToDateTime("2015-07-23T17:36:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
}
// create a new part in this package
internal void CreateInternal(OpenXmlPackage openXmlPackage, string contentType, string extension)
{
this._openXmlPackage = openXmlPackage;
this._uri = NewPartUri(openXmlPackage, contentType, extension);
this._metroPart = this._openXmlPackage.CreateMetroPart(this._uri, contentType);
}
private void SetPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Creator = "TyC Sports";
document.PackageProperties.Created = System.Xml.XmlConvert.ToDateTime("1998-08-29T23:27:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.Modified = System.Xml.XmlConvert.ToDateTime("2013-11-21T19:46:45Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.LastModifiedBy = "Carlos Porcel";
document.PackageProperties.LastPrinted = System.Xml.XmlConvert.ToDateTime("2011-07-27T12:20:54Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
}
// create a new part in this package
internal void CreateInternal(OpenXmlPackage openXmlPackage, MediaDataPartType mediaDataPartType)
{
this._openXmlPackage = openXmlPackage;
string contentType = mediaDataPartType.GetContentType();
string targetFileExt = mediaDataPartType.GetTargetExtension();
OpenXmlPackage.PartExtensionProvider.MakeSurePartExtensionExist(contentType, targetFileExt);
this._uri = NewPartUri(openXmlPackage, contentType, null);
this._metroPart = this._openXmlPackage.CreateMetroPart(this._uri, contentType);
}
private void SetPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Creator = "asus1215";
document.PackageProperties.Revision = "2";
document.PackageProperties.Created = System.Xml.XmlConvert.ToDateTime("2013-01-14T19:41:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.Modified = System.Xml.XmlConvert.ToDateTime("2013-01-14T19:41:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.LastModifiedBy = "asus1215";
}
// create a new part in this package
internal void CreateInternal2(OpenXmlPackage openXmlPackage, string contentType, Uri partUri)
{
// openXmlPackage, parent can not be all null
if (openXmlPackage == null)
{
throw new ArgumentNullException(ExceptionMessages.PackageRelatedArgumentNullException);
}
// throw exception to catch error in our code
if (this._metroPart != null)
{
throw new InvalidOperationException();
}
// set the _openXmlPackage so ThrowIfObjectDisposed( ) do not throw.
this._openXmlPackage = openXmlPackage;
Uri parentUri = new Uri("/", UriKind.Relative);
this._uri = this._openXmlPackage.GetUniquePartUri(contentType, parentUri, partUri);
this._metroPart = this._openXmlPackage.CreateMetroPart(this._uri, contentType);
}
#pragma warning disable 0618 // CS0618: A class member was marked with the Obsolete attribute, such that a warning will be issued when the class member is referenced.
private void ValidatePackageStructure(OpenXmlPackage document)
{
OpenXmlPackageValidationSettings packageValidationSettings = new OpenXmlPackageValidationSettings();
packageValidationSettings.EventHandler += this.OnPackageValidationError;
document.Validate(packageValidationSettings, this.ValidationSettings.FileFormat);
return;
}
internal Uri NewPartUri(OpenXmlPackage openXmlPackage, string contentType, string extension)
{
string targetFileExt;
if (extension == null)
{
if (!this._openXmlPackage.PartExtensionProvider.TryGetValue(contentType, out targetFileExt))
{
targetFileExt = this.TargetFileExtension;
}
}
else
{
targetFileExt = extension;
}
return openXmlPackage.GetUniquePartUri(contentType, new Uri("/", UriKind.Relative), this.TargetPath, this.TargetName, targetFileExt);
}
// destroy itself (aka. dispose)
internal void Destroy()
{
this.OpenXmlPackage.Package.DeletePart(this.Uri);
this._openXmlPackage = null;
}
private void SetPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Creator = "Sprayette";
System.DateTime Fecha = Convert.ToDateTime(System.DateTime.Now);
//document.PackageProperties.Created = System.Xml.XmlConvert.ToDateTime(Fecha.ToString(), System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
//document.PackageProperties.Modified = System.Xml.XmlConvert.ToDateTime(Fecha.ToString(), System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.LastModifiedBy = "Sprayette";
}
private void SetPackageProperties(OpenXmlPackage document)
{
var created = Properties.Created == DateTime.MinValue ? DateTime.Now : Properties.Created;
var modified = Properties.Modified == DateTime.MinValue ? DateTime.Now : Properties.Modified;
document.PackageProperties.Created = created;
document.PackageProperties.Modified = modified;
document.PackageProperties.LastModifiedBy = Properties.LastModifiedBy;
document.PackageProperties.Creator = Properties.Author;
document.PackageProperties.Title = Properties.Title;
document.PackageProperties.Subject = Properties.Subject;
document.PackageProperties.Category = Properties.Category;
document.PackageProperties.Keywords = Properties.Keywords;
document.PackageProperties.Description = Properties.Comments;
document.PackageProperties.ContentStatus = Properties.Status;
}
/// <summary>
/// Asserts that two OpenXmlPackage instances have the same content.
/// </summary>
/// <param name="first">The first OpenXmlPackage</param>
/// <param name="second">The second OpenXmlPackage</param>
public static void Equal(OpenXmlPackage first, OpenXmlPackage second)
{
Validate(first, second);
}
private void SetPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Creator = "Cameron Hill";
document.PackageProperties.Title = "";
document.PackageProperties.Subject = "";
document.PackageProperties.Keywords = "";
document.PackageProperties.Description = "";
document.PackageProperties.Revision = "23";
document.PackageProperties.Created = System.Xml.XmlConvert.ToDateTime("2016-03-09T01:13:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.Modified = System.Xml.XmlConvert.ToDateTime("2016-03-09T02:19:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.LastModifiedBy = "Cameron Hill";
}
/// <summary>
/// Asserts that two OpenXmlPackage instances do not have the same content.
/// </summary>
/// <param name="first">The first OpenXmlPackage</param>
/// <param name="second">The second OpenXmlPackage</param>
public static void NotEqual(OpenXmlPackage first, OpenXmlPackage second)
{
Assert.Throws <Xunit.Sdk.EqualException>(() => Validate(first, second));
}
private void SetPackageProperties(OpenXmlPackage document)
{
document.PackageProperties.Creator = "Masaki Tamura (Pasona Tech)";
document.PackageProperties.Revision = "5";
document.PackageProperties.Created = System.Xml.XmlConvert.ToDateTime("2012-01-11T07:24:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.Modified = System.Xml.XmlConvert.ToDateTime("2012-01-12T04:45:00Z", System.Xml.XmlDateTimeSerializationMode.RoundtripKind);
document.PackageProperties.LastModifiedBy = "Masaki Tamura (Pasona Tech)";
}
protected abstract List <string> GetUrls(OpenXmlPackage package);
