/// <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);