private string SavePicture(Image image)
{
ImageConverter ic = new ImageConverter();
byte[] img = (byte[])ic.ConvertTo(image, typeof(byte[]));
var ii = _drawings._package.AddImage(img);
if (_drawings._hashes.ContainsKey(ii.Hash))
{
var relID = _drawings._hashes[ii.Hash];
var rel = _drawings.Part.GetRelationship(relID);
UriPic = PackUriHelper.ResolvePartUri(rel.SourceUri, rel.TargetUri);
return(relID);
}
else
{
UriPic = ii.Uri;
}
//Set the Image and save it to the package.
RelPic = _drawings.Part.CreateRelationship(PackUriHelper.GetRelativeUri(_drawings.UriDrawing, UriPic), TargetMode.Internal, ExcelPackage.schemaRelationships + "/image");
//AddNewPicture(img, picRelation.Id);
_drawings._hashes.Add(ii.Hash, RelPic.Id);
ImageHash = ii.Hash;
return(RelPic.Id);
}
internal ExcelPicture(ExcelDrawings drawings, XmlNode node) :
base(drawings, node, "xdr:pic/xdr:nvPicPr/xdr:cNvPr/@name")
{
XmlNode picNode = node.SelectSingleNode("xdr:pic/xdr:blipFill/a:blip", drawings.NameSpaceManager);
if (picNode != null)
{
RelPic = drawings.Part.GetRelationship(picNode.Attributes["r:embed"].Value);
UriPic = PackUriHelper.ResolvePartUri(drawings.UriDrawing, RelPic.TargetUri);
Part = drawings.Part.Package.GetPart(UriPic);
FileInfo f = new FileInfo(UriPic.OriginalString);
ContentType = GetContentType(f.Extension);
_image = Image.FromStream(Part.GetStream());
ImageConverter ic = new ImageConverter();
var iby = (byte[])ic.ConvertTo(_image, typeof(byte[]));
var ii = _drawings._package.LoadImage(iby, UriPic, Part);
ImageHash = ii.Hash;
string relID = GetXmlNodeString("xdr:pic/xdr:nvPicPr/xdr:cNvPr/a:hlinkClick/@r:id");
if (!string.IsNullOrEmpty(relID))
{
HypRel = drawings.Part.GetRelationship(relID);
if (HypRel.TargetUri.IsAbsoluteUri)
{
_hyperlink = new ExcelHyperLink(HypRel.TargetUri.AbsoluteUri);
}
else
{
_hyperlink = new ExcelHyperLink(HypRel.TargetUri.OriginalString, UriKind.Relative);
}
((ExcelHyperLink)_hyperlink).ToolTip = GetXmlNodeString("xdr:pic/xdr:nvPicPr/xdr:cNvPr/a:hlinkClick/@tooltip");
}
}
}
public static bool VytvoritCustomUI(string souborDocx, string customUiXml, bool zalohovat)
{
bool uspech = false;
ZalohovatDokument(souborDocx, zalohovat);
string customUiRelationshipType = ZjistiVerziCustomUi(customUiXml);
if (customUiRelationshipType == null)
{
return(uspech);
}
string customUiXmlUri = "/customUI/customUI.xml";
string CustomUiId = "rCustomUiId";
if (customUiRelationshipType == RelCustomUiW14RelationshipType)
{
customUiXmlUri = "/customUI/customUI2010.xml";
CustomUiId = "rCustomUi2010Id";
}
using (Package wdPackage = Package.Open(souborDocx, FileMode.Open, FileAccess.ReadWrite))
{
PackageRelationship docPackageRelationship = wdPackage.GetRelationshipsByType(customUiRelationshipType).FirstOrDefault();
Uri documentUri = null;
if (docPackageRelationship == null)
{
documentUri = PackUriHelper.CreatePartUri(new Uri(customUiXmlUri, UriKind.Relative));
wdPackage.CreatePart(documentUri, "application/xml");
docPackageRelationship = wdPackage.CreateRelationship(documentUri, TargetMode.Internal, customUiRelationshipType, CustomUiId);
}
if (docPackageRelationship != null)
{
if (documentUri == null)
{
documentUri = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), docPackageRelationship.TargetUri);
}
PackagePart documentPart = wdPackage.GetPart(documentUri);
string customXml = "<customUI xmlns=\"http://schemas.microsoft.com/office/2006/01/customui\"><ribbon><tabs><tab id=\"tbKarta\" label=\"Karta\"></tab></tabs></ribbon></customUI>";
if (customUiXml != null)
{
using (StreamReader streamReader = new StreamReader(customUiXml))
{
customXml = streamReader.ReadToEnd();
}
}
using (StreamWriter streamWriter = new StreamWriter(documentPart.GetStream(FileMode.Create)))
{
streamWriter.Write(customXml);
uspech = true;
}
}
}
return(uspech);
}
public void ResolvePartUri3()
{
Uri src = new Uri("/1/2/3/4", UriKind.Relative);
Uri dest = new Uri("http://www.example.com", UriKind.Absolute);
PackUriHelper.ResolvePartUri(src, dest);
}
internal ExcelPivotCacheDefinition(XmlNamespaceManager ns, ExcelPivotTable pivotTable) :
base(ns, null)
{
foreach (var r in pivotTable.Part.GetRelationshipsByType(ExcelPackage.schemaRelationships + "/pivotCacheDefinition"))
{
Relationship = r;
}
CacheDefinitionUri = PackUriHelper.ResolvePartUri(Relationship.SourceUri, Relationship.TargetUri);
var pck = pivotTable.WorkSheet._package.Package;
Part = pck.GetPart(CacheDefinitionUri);
CacheDefinitionXml = new XmlDocument();
LoadXmlSafe(CacheDefinitionXml, Part.GetStream());
TopNode = CacheDefinitionXml.DocumentElement;
PivotTable = pivotTable;
if (CacheSource == eSourceType.Worksheet)
{
var worksheetName = GetXmlNodeString(_sourceWorksheetPath);
if (pivotTable.WorkSheet.Workbook.Worksheets.Any(t => t.Name == worksheetName))
{
_sourceRange = pivotTable.WorkSheet.Workbook.Worksheets[worksheetName].Cells[GetXmlNodeString(_sourceAddressPath)];
}
}
}
// Return true if an open XML document is enforcing read-only
private static bool IsOpenXMLReadOnlyEnforced(string filename)
{
// Read an OpenXML type document
using (Package package = Package.Open(path: filename, packageMode: FileMode.Open, packageAccess: FileAccess.Read))
{
if (null == package)
{
return(false);
}
try
{
// Document security is set in the extended properties
// https://docs.microsoft.com/en-us/previous-versions/office/developer/office-2010/cc845474(v%3doffice.14)
string extendedType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties";
PackageRelationshipCollection extendedProps = package.GetRelationshipsByType(extendedType);
if (null != extendedProps)
{
IEnumerator extendedPropsList = extendedProps.GetEnumerator();
if (extendedPropsList.MoveNext())
{
Uri extendedPropsUri = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), ((PackageRelationship)extendedPropsList.Current).TargetUri);
PackagePart props = package.GetPart(extendedPropsUri);
if (null != props)
{
// Read the internal docProps/app.xml XML file
XDocument xmlDoc = XDocument.Load(props.GetStream());
XElement securityEl = xmlDoc.Root.Element(XName.Get("DocSecurity", xmlDoc.Root.GetDefaultNamespace().NamespaceName));
if (null != securityEl)
{
if (!String.IsNullOrWhiteSpace(securityEl.Value))
{
// See https://docs.microsoft.com/en-us/previous-versions/office/developer/office-2010/cc840043%28v%3doffice.14%29
return((Int16.Parse(securityEl.Value) & 4) == 4);
}
}
package.Close();
// PowerPoint doesn't use DocSecurity (*sigh*) so need another check
XElement appEl = xmlDoc.Root.Element(XName.Get("Application", xmlDoc.Root.GetDefaultNamespace().NamespaceName));
if (null != appEl)
{
if (!String.IsNullOrWhiteSpace(appEl.Value) &&
appEl.Value.IndexOf("PowerPoint", StringComparison.InvariantCultureIgnoreCase) >= 0)
{
PresentationDocument presentationDocument = PresentationDocument.Open(path: filename, isEditable: false);
if (null != presentationDocument &&
presentationDocument.PresentationPart.Presentation.ModificationVerifier != null)
{
return(true);
}
}
}
}
}
}
}
catch (Exception) { }
return(false);
}
}
private static Type GetDocumentType(byte[] bytes)
{
using (MemoryStream stream = new MemoryStream(bytes))
using (Package package = Package.Open(stream, FileMode.Open))
{
PackageRelationship relationship = package.GetRelationshipsByType("http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument").FirstOrDefault();
if (relationship != null)
{
PackagePart part = package.GetPart(PackUriHelper.ResolvePartUri(relationship.SourceUri, relationship.TargetUri));
switch (part.ContentType)
{
case "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml":
return(typeof(WordprocessingDocument));
case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml":
return(typeof(SpreadsheetDocument));
case "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml":
case "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml":
return(typeof(PresentationDocument));
}
return(typeof(Package));
}
return(null);
}
}
/// <summary>
/// Add a new pivottable
/// </summary>
/// <param name="sheet">The worksheet</param>
/// <param name="address">the address of the pivottable</param>
/// <param name="sourceAddress">The address of the Source data</param>
/// <param name="name"></param>
/// <param name="tblId"></param>
internal ExcelPivotTable(ExcelWorksheet sheet, ExcelAddressBase address, ExcelRangeBase sourceAddress, string name, int tblId) :
base(sheet.NameSpaceManager)
{
WorkSheet = sheet;
Address = address;
var pck = sheet._package.Package;
PivotTableXml = new XmlDocument();
LoadXmlSafe(PivotTableXml, GetStartXml(name, tblId, address, sourceAddress));
TopNode = PivotTableXml.DocumentElement;
PivotTableUri = GetNewUri(pck, "/xl/pivotTables/pivotTable{0}.xml", tblId);
init();
Part = pck.CreatePart(PivotTableUri, ExcelPackage.schemaPivotTable);
PivotTableXml.Save(Part.GetStream());
//Worksheet-Pivottable relationship
Relationship = sheet.Part.CreateRelationship(PackUriHelper.ResolvePartUri(sheet.WorksheetUri, PivotTableUri), TargetMode.Internal, ExcelPackage.schemaRelationships + "/pivotTable");
_cacheDefinition = new ExcelPivotCacheDefinition(sheet.NameSpaceManager, this, sourceAddress, tblId);
_cacheDefinition.Relationship = Part.CreateRelationship(PackUriHelper.ResolvePartUri(PivotTableUri, _cacheDefinition.CacheDefinitionUri), TargetMode.Internal, ExcelPackage.schemaRelationships + "/pivotCacheDefinition");
sheet.Workbook.AddPivotTable(CacheID.ToString(), _cacheDefinition.CacheDefinitionUri);
LoadFields();
using (var r = sheet.Cells[address.Address])
{
r.Clear();
}
}
/// <summary>
/// Converts an OpenXml package in OPC format to an <see cref="XDocument"/>
/// in Flat OPC format.
/// </summary>
/// <param name="instruction">The processing instruction.</param>
/// <returns>The OpenXml package in Flat OPC format.</returns>
protected XDocument ToFlatOpcDocument(XProcessingInstruction instruction)
{
// Save the contents of all parts and relationships that are contained
// in the OpenXml package to make sure we convert a consistent state.
// This will also invoke ThrowIfObjectDisposed(), so we don't need
// to call it here.
Save();
// Identify all AlternativeFormatInputParts (AltChunk parts).
// This is necessary because AltChunk parts must be treated as binary
// parts regardless of the actual content type, which might even be
// XML-related such as application/xhtml+xml.
var altChunkPartUris = new HashSet <Uri>(
Package.GetParts()
.Where(part => part.ContentType != RelationshipContentType)
.SelectMany(part => part.GetRelationshipsByType(AltChunkRelationshipType))
.Select(pr => PackUriHelper.ResolvePartUri(pr.SourceUri, pr.TargetUri)));
// Create an XML document with a standalone declaration, processing
// instruction (if not null), and a package root element with a
// namespace declaration and one child element for each part.
return(new XDocument(
new XDeclaration("1.0", "UTF-8", "yes"),
instruction,
new XElement(
Pkg + "package",
new XAttribute(XNamespace.Xmlns + "pkg", Pkg.ToString()),
Package.GetParts().Select(part => GetContentsAsXml(part, altChunkPartUris)))));
}
void ExtractLayouts(Package package, PackageDefinition manifest, string workingDirectory)
{
var localContentDirectory = Path.Combine(workingDirectory, AzureCloudServiceConventions.PackageFolders.LocalContent);
fileSystem.EnsureDirectoryExists(localContentDirectory);
foreach (var layout in manifest.Layouts)
{
if (!layout.Name.StartsWith(AzureCloudServiceConventions.RoleLayoutPrefix))
{
continue;
}
var layoutDirectory = Path.Combine(localContentDirectory, layout.Name.Substring(AzureCloudServiceConventions.RoleLayoutPrefix.Length));
fileSystem.EnsureDirectoryExists(layoutDirectory);
foreach (var fileDefinition in layout.FileDefinitions)
{
var contentDefinition =
manifest.GetContentDefinition(fileDefinition.Description.DataContentReference);
var destinationFileName = Path.Combine(layoutDirectory, fileDefinition.FilePath.TrimStart('\\'));
ExtractPart(
package.GetPart(PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative),
contentDefinition.Description.DataStorePath)),
destinationFileName);
}
}
}
public static PackagePart GetDocumentPart(Package package)
{
PackageRelationship relationship = package.GetRelationshipsByType(OfficeDocumentRelType).FirstOrDefault();
Uri docUri = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), relationship.TargetUri);
return(package.GetPart(docUri));
}
public Dictionary <string, BitmapImage> GetImages()
{
if (Part == null)
{
throw new InvalidOperationException($"Part was already removed");
}
var imageCollection = new Dictionary <string, BitmapImage>();
foreach (var relationship in Part.GetRelationshipsByType(OfficeDocument.ImagePartRelType))
{
var customImageUri = PackUriHelper.ResolvePartUri(relationship.SourceUri, relationship.TargetUri);
if (!Part.Package.PartExists(customImageUri))
{
continue;
}
var imagePart = Part.Package.GetPart(customImageUri);
var imageStream = imagePart.GetStream(FileMode.Open, FileAccess.Read);
var image = new BitmapImage();
image.BeginInit();
image.StreamSource = imageStream;
image.CacheOption = BitmapCacheOption.OnLoad;
image.EndInit();
imageCollection.Add(relationship.Id, image);
imageStream.Close();
}
return(imageCollection);
}
private string?AddImageHelper(string fileName, string imageId, Func <string?, string?, bool>?alreadyExistingAction = null)
{
if (Part == null)
{
throw new InvalidOperationException($"Part was already removed");
}
if (fileName == null)
{
throw new ArgumentNullException(nameof(fileName));
}
Debug.Assert(File.Exists(fileName), fileName + " does not exist.");
if (!File.Exists(fileName))
{
return(null);
}
var extension = Path.GetExtension(fileName);
// Check for duplicates and correct ID if necessary
var originalId = imageId;
imageId = FindFirstAvailableImageId(Part, imageId);
if (imageId != originalId && !(alreadyExistingAction?.Invoke(originalId, imageId) ?? true))
{
return(null);
}
// Now do the same for the Uri (which does need to coincide with the ID)
var imageUri = FindFirstAvailableImageUri(Part, originalId, extension);
var imageRel = Part.CreateRelationship(imageUri, TargetMode.Internal, OfficeDocument.ImagePartRelType, imageId);
var imagePart = Part.Package.CreatePart(
PackUriHelper.ResolvePartUri(imageRel.SourceUri, imageRel.TargetUri),
MapImageContentType(Path.GetExtension(fileName)));
if (imagePart == null)
{
Debug.Print("Fail to create image part.");
return(null);
}
using var br = new BinaryReader(File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite));
using var bw = new BinaryWriter(imagePart.GetStream(FileMode.Create, FileAccess.Write));
var buffer = new byte[1024];
int byteCount;
while ((byteCount = br.Read(buffer, 0, buffer.Length)) > 0)
{
bw.Write(buffer, 0, byteCount);
}
bw.Flush();
return(imageRel.Id);
}
public void RemoveImage(string imageId)
{
if (Part == null)
{
throw new InvalidOperationException("Part was already removed");
}
if (imageId == null)
{
throw new ArgumentNullException(nameof(imageId));
}
if (imageId.Length == 0)
{
return;
}
if (!Part.RelationshipExists(imageId))
{
return;
}
var imageRel = Part.GetRelationship(imageId);
var imageUri = PackUriHelper.ResolvePartUri(imageRel.SourceUri, imageRel.TargetUri);
if (Part.Package.PartExists(imageUri))
{
Part.Package.DeletePart(imageUri);
}
Part.DeleteRelationship(imageId);
}
public static void PrekopirovatPanelNastroju(string strZdrojovySoubor, string strCilovySoubor)
{
using (Package wdPackage = Package.Open(strCilovySoubor, FileMode.Open, FileAccess.ReadWrite))
{
PackageRelationship docPackageRelationship = wdPackage.GetRelationshipsByType(RelDocumentRelationshipType).FirstOrDefault();
if (docPackageRelationship != null)
{
Uri documentUri = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), docPackageRelationship.TargetUri);
PackagePart documentPart = wdPackage.GetPart(documentUri);
// Find the styles part. There will only be one.
PackageRelationship styleRelation = documentPart.GetRelationshipsByType(RelCustomization).FirstOrDefault();
if (styleRelation != null)
{
Uri styleUri = PackUriHelper.ResolvePartUri(documentUri, styleRelation.TargetUri);
PackagePart stylePart = wdPackage.GetPart(styleUri);
using (StreamReader streamReader = new StreamReader(strZdrojovySoubor))
using (StreamWriter streamWriter = new StreamWriter(stylePart.GetStream(FileMode.Create)))
{
streamWriter.Write(streamReader.ReadToEnd());
}
}
}
}
}
/// <summary>
/// Method that makes two lists, parts to want Sign and indicate relationships to sign
/// </summary>
/// <param name="relationship">PackageRelationship</param>
/// <param name="partsToSign"> Package Parts that you want to sign</param>
/// <param name="relationshipsToSign">PacakgeRelationshipSelector objects which indicate relationships to sign</param>
private void AddSignableItems(
PackageRelationship relationship,
List <Uri> partsToSign,
List <PackageRelationshipSelector> relationshipsToSign)
{
PackageRelationshipSelector selector =
new PackageRelationshipSelector(
relationship.SourceUri,
PackageRelationshipSelectorType.Id,
relationship.Id);
relationshipsToSign.Add(selector);
if (relationship.TargetMode == TargetMode.Internal)
{
PackagePart part = relationship.Package.GetPart(
PackUriHelper.ResolvePartUri(
relationship.SourceUri, relationship.TargetUri));
if (partsToSign.Contains(part.Uri) == false)
{
partsToSign.Add(part.Uri);
foreach (PackageRelationship childRelationship in
part.GetRelationships())
{
AddSignableItems(childRelationship,
partsToSign, relationshipsToSign);
}
}
}
}
/// <summary>
/// Nahradí text dokumentu novým obsahem.
/// </summary>
/// <param name="souborDocx">Dokument DOCX, jehož obsah se má nahrazovat.</param>
/// <param name="dokumentXml">Text dokumentu ve formátu Xml.</param>
/// <param name="zalohovat">Zda se má dokument před provedením změn zálohovat.</param>
/// <returns></returns>
public static bool NahraditDokument(string souborDocx, string dokumentXml, bool zalohovat)
{
bool blnNahrazeno = false;
ZalohovatDokument(souborDocx, zalohovat);
using (Package wdPackage = Package.Open(souborDocx, FileMode.Open, FileAccess.ReadWrite))
{
PackageRelationship docPackageRelationship = wdPackage.GetRelationshipsByType(RelDocumentRelationshipType).FirstOrDefault();
if (docPackageRelationship != null)
{
Uri documentUri = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), docPackageRelationship.TargetUri);
PackagePart documentPart = wdPackage.GetPart(documentUri);
using (StreamReader streamReader = new StreamReader(dokumentXml))
using (StreamWriter streamWriter = new StreamWriter(documentPart.GetStream(FileMode.Create)))
{
streamWriter.Write(streamReader.ReadToEnd());
}
blnNahrazeno = true;
}
}
return(blnNahrazeno);
}
internal void GetExternalReferences()
{
XmlNodeList nl = WorkbookXml.SelectNodes("//d:externalReferences/d:externalReference", NameSpaceManager);
if (nl != null)
{
foreach (XmlElement elem in nl)
{
string rID = elem.GetAttribute("r:id");
PackageRelationship rel = Part.GetRelationship(rID);
var part = _package.Package.GetPart(PackUriHelper.ResolvePartUri(rel.SourceUri, rel.TargetUri));
XmlDocument xmlExtRef = new XmlDocument();
LoadXmlSafe(xmlExtRef, part.GetStream());
XmlElement book = xmlExtRef.SelectSingleNode("//d:externalBook", NameSpaceManager) as XmlElement;
if (book != null)
{
string rId_ExtRef = book.GetAttribute("r:id");
var rel_extRef = part.GetRelationship(rId_ExtRef);
if (rel_extRef != null)
{
_externalReferences.Add(rel_extRef.TargetUri.OriginalString);
}
}
}
}
}
public static bool NahraditDefiniciStylu(string strDocx, string strStylyXml)
{
bool blnNahrazeno = false;
using (Package wdPackage = Package.Open(strDocx, FileMode.Open, FileAccess.ReadWrite))
{
PackageRelationship docPackageRelationship = wdPackage.GetRelationshipsByType(RelDocumentRelationshipType).FirstOrDefault();
if (docPackageRelationship != null)
{
Uri documentUri = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), docPackageRelationship.TargetUri);
PackagePart documentPart = wdPackage.GetPart(documentUri);
// Find the styles part. There will only be one.
PackageRelationship styleRelation = documentPart.GetRelationshipsByType(RelStylesRelationshipType).FirstOrDefault();
if (styleRelation != null)
{
Uri styleUri = PackUriHelper.ResolvePartUri(documentUri, styleRelation.TargetUri);
PackagePart stylePart = wdPackage.GetPart(styleUri);
using (StreamReader streamReader = new StreamReader(strStylyXml))
using (StreamWriter streamWriter = new StreamWriter(stylePart.GetStream(FileMode.Create)))
{
streamWriter.Write(streamReader.ReadToEnd());
}
blnNahrazeno = true;
}
}
}
return(blnNahrazeno);
}
internal ExcelPivotCacheDefinition(XmlNamespaceManager ns, ExcelPivotTable pivotTable, ExcelRangeBase sourceAddress, int tblId) :
base(ns, null)
{
PivotTable = pivotTable;
var pck = pivotTable.WorkSheet._package.Package;
//CacheDefinition
CacheDefinitionXml = new XmlDocument();
LoadXmlSafe(CacheDefinitionXml, GetStartXml(sourceAddress));
CacheDefinitionUri = GetNewUri(pck, "/xl/pivotCache/pivotCacheDefinition{0}.xml", tblId);
Part = pck.CreatePart(CacheDefinitionUri, ExcelPackage.schemaPivotCacheDefinition);
TopNode = CacheDefinitionXml.DocumentElement;
//CacheRecord. Create an empty one.
CacheRecordUri = GetNewUri(pck, "/xl/pivotCache/pivotCacheRecords{0}.xml", tblId);
var cacheRecord = new XmlDocument();
cacheRecord.LoadXml("<pivotCacheRecords xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" count=\"0\" />");
var recPart = pck.CreatePart(CacheRecordUri, ExcelPackage.schemaPivotCacheRecords);
cacheRecord.Save(recPart.GetStream());
RecordRelationship = Part.CreateRelationship(PackUriHelper.ResolvePartUri(CacheDefinitionUri, CacheRecordUri), TargetMode.Internal, ExcelPackage.schemaRelationships + "/pivotCacheRecords");
RecordRelationshipID = RecordRelationship.Id;
CacheDefinitionXml.Save(Part.GetStream());
}
internal ExcelWorksheets(ExcelPackage pck, XmlNamespaceManager nsm, XmlNode topNode) :
base(nsm, topNode)
{
_pck = pck;
_namespaceManager = nsm;
_worksheets = new Dictionary <int, ExcelWorksheet>();
int positionID = 1;
foreach (XmlNode sheetNode in topNode.ChildNodes)
{
string name = sheetNode.Attributes["name"].Value;
//Get the relationship id
string relId = sheetNode.Attributes["r:id"].Value;
int sheetID = Convert.ToInt32(sheetNode.Attributes["sheetId"].Value);
//Hidden property
eWorkSheetHidden hidden = eWorkSheetHidden.Visible;
XmlNode attr = sheetNode.Attributes["state"];
if (attr != null)
{
hidden = TranslateHidden(attr.Value);
}
PackageRelationship sheetRelation = pck.Workbook.Part.GetRelationship(relId);
Uri uriWorksheet = PackUriHelper.ResolvePartUri(pck.Workbook.WorkbookUri, sheetRelation.TargetUri);
//add the worksheet
_worksheets.Add(positionID, new ExcelWorksheet(_namespaceManager, _pck, relId, uriWorksheet, name, sheetID, positionID, hidden));
positionID++;
}
}
public static CopyBuffer ExtractCopyBufferFromClipboardStream(Stream clipboardStream)
{
CopyBuffer result;
using (Package package = Package.Open(clipboardStream, FileMode.Open, FileAccess.Read))
{
result = new CopyBuffer();
foreach (PackageRelationship packageRelationship in package.GetRelationshipsByType("http://schemas.microsoft.com/cfxaml/2006/06/relationships/metadata/core-properties"))
{
Uri partUri = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), packageRelationship.TargetUri);
PackagePart part = package.GetPart(partUri);
Container.ParseCorePropertyPart(result, part);
}
foreach (PackageRelationship packageRelationship in package.GetRelationshipsByType("http://schemas.microsoft.com/cfxaml/2006/06/selected-item"))
{
Uri partUri = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), packageRelationship.TargetUri);
CopyItem itemToPaste = (CopyItem) new MemoryCopyItem(Container.GetBytes(package.GetPart(partUri)));
result.AddSelectedItem(itemToPaste);
}
foreach (PackageRelationship packageRelationship1 in package.GetRelationshipsByType("http://schemas.microsoft.com/cfxaml/2006/06/referenced-item"))
{
Uri partUri1 = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), packageRelationship1.TargetUri);
PackagePart part = package.GetPart(partUri1);
CopyItem copyItem = (CopyItem) new MemoryCopyItem(Container.GetBytes(part));
result.AddReferencedItem(copyItem);
foreach (PackageRelationship packageRelationship2 in part.GetRelationshipsByType("http://schemas.microsoft.com/cfxaml/2006/06/item-attributes"))
{
Uri partUri2 = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), packageRelationship2.TargetUri);
Container.ReadAttributes(package.GetPart(partUri2), copyItem);
}
}
}
return(result);
}
//Create Oid from a bytearray
//private string ReadHash(byte[] content)
//{
// StringBuilder builder = new StringBuilder();
// int offset = 0x6;
// if (0 < (content.Length))
// {
// byte num = content[offset];
// byte num2 = (byte)(num / 40);
// builder.Append(num2.ToString(null, null));
// builder.Append(".");
// num2 = (byte)(num % 40);
// builder.Append(num2.ToString(null, null));
// ulong num3 = 0L;
// for (int i = offset + 1; i < content.Length; i++)
// {
// num2 = content[i];
// num3 = (ulong)(ulong)(num3 << 7) + ((byte)(num2 & 0x7f));
// if ((num2 & 0x80) == 0)
// {
// builder.Append(".");
// builder.Append(num3.ToString(null, null));
// num3 = 0L;
// }
// //1.2.840.113549.2.5
// }
// }
// string oId = builder.ToString();
// return oId;
//}
internal void Save(ExcelVbaProject proj)
{
if (Certificate == null || Certificate.HasPrivateKey == false) //No signature. Remove any Signature part
{
if (Part != null)
{
foreach (var r in Part.GetRelationships())
{
Part.DeleteRelationship(r.Id);
}
Part.Package.DeletePart(Part.Uri);
}
return;
}
var ms = new MemoryStream();
var bw = new BinaryWriter(ms);
byte[] certStore = GetCertStore();
byte[] cert = SignProject(proj);
bw.Write((uint)cert.Length);
bw.Write((uint)44); //?? 36 ref inside cert ??
bw.Write((uint)certStore.Length); //cbSigningCertStore
bw.Write((uint)(cert.Length + 44)); //certStoreOffset
bw.Write((uint)0); //cbProjectName
bw.Write((uint)(cert.Length + certStore.Length + 44)); //projectNameOffset
bw.Write((uint)0); //fTimestamp
bw.Write((uint)0); //cbTimestampUrl
bw.Write((uint)(cert.Length + certStore.Length + 44 + 2)); //timestampUrlOffset
bw.Write(cert);
bw.Write(certStore);
bw.Write((ushort)0); //rgchProjectNameBuffer
bw.Write((ushort)0); //rgchTimestampBuffer
bw.Write((ushort)0);
bw.Flush();
var rel = proj.Part.GetRelationshipsByType(schemaRelVbaSignature).FirstOrDefault();
if (Part == null)
{
if (rel != null)
{
Uri = rel.TargetUri;
Part = proj._pck.GetPart(rel.TargetUri);
}
else
{
Uri = new Uri("/xl/vbaProjectSignature.bin", UriKind.Relative);
Part = proj._pck.CreatePart(Uri, ExcelPackage.schemaVBASignature);
}
}
if (rel == null)
{
proj.Part.CreateRelationship(PackUriHelper.ResolvePartUri(proj.Uri, Uri), TargetMode.Internal, schemaRelVbaSignature);
}
var b = ms.ToArray();
Part.GetStream(FileMode.Create).Write(b, 0, b.Length);
}
public void ResolvePartUri()
{
Uri src = new Uri("/1/2/3/4", UriKind.Relative);
Uri dest = new Uri("/MyFile", UriKind.Relative);
// Can't be empty url
Assert.AreEqual(new Uri(""), PackUriHelper.ResolvePartUri(src, dest), "#1");
}
}// end:main()
// ----------------------- ExtractPackageParts -----------------------
/// <summary>
/// Extracts content and resource parts from a given Package
/// zip file to a specified target directory.</summary>
/// <param name="packagePath">
/// The relative path and filename of the Package zip file.</param>
/// <param name="targetDirectory">
/// The relative path from the current directory to the targer folder.
/// </param>
private static void ExtractPackageParts(
string packagePath, string targetDirectory)
{
// Create a new Target directory. If the Target directory
// exists, first delete it and then create a new empty one.
DirectoryInfo directoryInfo = new DirectoryInfo(targetDirectory);
if (directoryInfo.Exists)
{
directoryInfo.Delete(true);
}
directoryInfo.Create();
//<SnippetPackageReadUsing>
// Open the Package.
// ('using' statement insures that 'package' is
// closed and disposed when it goes out of scope.)
using (Package package =
Package.Open(packagePath, FileMode.Open, FileAccess.Read))
{
PackagePart documentPart = null;
PackagePart resourcePart = null;
// Get the Package Relationships and look for
// the Document part based on the RelationshipType
Uri uriDocumentTarget = null;
foreach (PackageRelationship relationship in
package.GetRelationshipsByType(PackageRelationshipType))
{
// Resolve the Relationship Target Uri
// so the Document Part can be retrieved.
uriDocumentTarget = PackUriHelper.ResolvePartUri(
new Uri("/", UriKind.Relative), relationship.TargetUri);
// Open the Document Part, write the contents to a file.
documentPart = package.GetPart(uriDocumentTarget);
ExtractPart(documentPart, targetDirectory);
}
// Get the Document part's Relationships,
// and look for required resources.
Uri uriResourceTarget = null;
foreach (PackageRelationship relationship in
documentPart.GetRelationshipsByType(
ResourceRelationshipType))
{
// Resolve the Relationship Target Uri
// so the Resource Part can be retrieved.
uriResourceTarget = PackUriHelper.ResolvePartUri(
documentPart.Uri, relationship.TargetUri);
// Open the Resource Part and write the contents to a file.
resourcePart = package.GetPart(uriResourceTarget);
ExtractPart(resourcePart, targetDirectory);
}
} // end:using(Package package) - Close & dispose package.
//</SnippetPackageReadUsing>
} // end:ExtractPackageParts()
public Uri GetUniquePartUri(string contentType, Uri parentUri, Uri targetUri)
{
return(GetUniquePartUri(
contentType,
PackUriHelper.ResolvePartUri(parentUri, targetUri),
".",
Path.GetFileNameWithoutExtension(targetUri.OriginalString),
Path.GetExtension(targetUri.OriginalString)));
}
void IPersistable.Load(ExcelLoadContext context)
{
PackageRelationship drawingsRelation = context.Package.GetPart(this._WorkSheet.SheetUri).GetRelationship(this.RelationshipID);
this.DrawingUri = PackUriHelper.ResolvePartUri(drawingsRelation.SourceUri, drawingsRelation.TargetUri);
XElement drawingsElement = context.Package.GetXElementFromUri(this.DrawingUri);
context.Reader.ReadWrokSheetDrawings(this, drawingsElement, context);
}
void ExtractContents(Package package, PackageDefinition manifest, string contentNamePrefix, string workingDirectory)
{
foreach (var namedStreamsContent in manifest.Contents.Where(x => x.Name.StartsWith(contentNamePrefix)))
{
var destinationFileName = Path.Combine(workingDirectory, ConvertToWindowsPath(namedStreamsContent.Description.DataStorePath.ToString()).TrimStart('\\'));
ExtractPart(package.GetPart(PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), namedStreamsContent.Description.DataStorePath)),
destinationFileName);
}
}
/// <summary>
/// Extract a container Zip. NOTE: container must be created as Open Packaging Conventions (OPC) specification
/// </summary>
/// <param name="folderName">The folder to extract the package to</param>
/// <param name="compressedFileName">The package file</param>
/// <param name="overrideExisting">override existing files</param>
/// <param name="removeDescFile">Delete [Content_Types].xml when done</param>
/// <returns>ReturnResult</returns>
public ReturnResult UncompressFile(string folderName, string compressedFileName, bool overrideExisting, bool removeDescFile)
{
ReturnResult result = new ReturnResult();
try
{
if (!File.Exists(compressedFileName))
{
result.Success = false;
result.Message = "Compressed File not found";
return(result);
}
DirectoryInfo directoryInfo = new DirectoryInfo(folderName);
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
using (Package package = Package.Open(compressedFileName, FileMode.Open, FileAccess.Read))
{
PackagePart documentPart = null;
PackagePart resourcePart = null;
Uri uriDocumentTarget = null;
foreach (PackageRelationship relationship in package.GetRelationshipsByType(PackageRelationshipType))
{
uriDocumentTarget = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), relationship.TargetUri);
documentPart = package.GetPart(uriDocumentTarget);
ExtractPart(documentPart, folderName, overrideExisting);
}
if (documentPart != null)
{
Uri uriResourceTarget = null;
foreach (PackageRelationship relationship in documentPart.GetRelationshipsByType(ResourceRelationshipType))
{
uriResourceTarget = PackUriHelper.ResolvePartUri(documentPart.Uri, relationship.TargetUri);
resourcePart = package.GetPart(uriResourceTarget);
ExtractPart(resourcePart, folderName, overrideExisting);
}
}
}
if (removeDescFile && File.Exists(folderName + "\\[Content_Types].xml"))
{
File.Delete(folderName + "\\[Content_Types].xml");
}
}
catch (Exception e)
{
throw new Exception("Error unzipping file " + compressedFileName, e);
}
OnZipEnd(new ZipEndEventArgs());
result.Success = true;
result.Message = "OK";
return(result);
}
/// <summary>
/// Creates a new instance of the ExcelWorksheets class.
/// For internal use only!
/// </summary>
/// <param name="xlPackage"></param>
protected internal ExcelWorksheets(ExcelPackage xlPackage)
{
_xlPackage = xlPackage;
// Create a NamespaceManager to handle the default namespace,
// and create a prefix for the default namespace:
var nt = new NameTable();
_nsManager = new XmlNamespaceManager(nt);
_nsManager.AddNamespace("d", ExcelPackage.schemaMain);
_nsManager.AddNamespace("r", ExcelPackage.schemaRelationships);
// obtain container node for all worksheets
_worksheetsNode = _xlPackage.Workbook.WorkbookXml.SelectSingleNode("//d:sheets", _nsManager);
if (_worksheetsNode == null)
{
// create new node as it did not exist
_worksheetsNode = _xlPackage.Workbook.WorkbookXml.CreateElement("sheets", ExcelPackage.schemaMain);
_xlPackage.Workbook.WorkbookXml.DocumentElement.AppendChild(_worksheetsNode);
}
_worksheets = new Dictionary <int, ExcelWorksheet>();
var positionId = 1;
foreach (XmlNode sheetNode in _worksheetsNode.ChildNodes)
{
var name = sheetNode.Attributes["name"].Value;
// Get the relationship id attribute:
var relId = sheetNode.Attributes["r:id"].Value;
var sheetId = Convert.ToInt32(sheetNode.Attributes["sheetId"].Value);
//if (sheetID != count)
//{
// // renumber the sheets as they are in an odd order
// sheetID = count;
// sheetNode.Attributes["sheetId"].Value = sheetID.ToString();
//}
// get hidden attribute (if present)
var hidden = false;
XmlNode attr = sheetNode.Attributes["hidden"];
if (attr != null)
{
hidden = Convert.ToBoolean(attr.Value);
}
//string type = "";
//attr = sheetNode.Attributes["type"];
//if (attr != null)
// type = attr.Value;
var sheetRelation = _xlPackage.Workbook.Part.GetRelationship(relId);
var uriWorksheet = PackUriHelper.ResolvePartUri(_xlPackage.Workbook.WorkbookUri, sheetRelation.TargetUri);
// add worksheet to our collection
_worksheets.Add(positionId, new ExcelWorksheet(_xlPackage, relId, name, uriWorksheet, sheetId, hidden));
positionId++;
}
}