private static void ExtractFile(string rootFolder, ZipPackagePart contentFile) { try { string contentFilePath = contentFile.Uri.OriginalString.Replace('/', Path.DirectorySeparatorChar); if (contentFilePath.StartsWith(Path.DirectorySeparatorChar.ToString())) { contentFilePath = contentFilePath.TrimStart(Path.DirectorySeparatorChar); } contentFilePath = Path.Combine(rootFolder, contentFilePath); if (Directory.Exists(Path.GetDirectoryName(contentFilePath)) != true) { Directory.CreateDirectory(Path.GetDirectoryName(contentFilePath)); } FileStream newFileStream = System.IO.File.Create(contentFilePath); newFileStream.Close(); byte[] content = new byte[contentFile.GetStream().Length]; contentFile.GetStream().Read(content, 0, content.Length); System.IO.File.WriteAllBytes(contentFilePath, content); } catch (Exception ex) { Utilities.OnError(Utilities.GetCurrentMethod(), ex); } }
public static bool Decompress(FileInfo fi, string origName) { Package package = null; bool result = false; try { string fullName = fi.FullName; package = Package.Open(fullName, FileMode.Open, FileAccess.ReadWrite); using (IEnumerator <PackagePart> enumerator = package.GetParts().GetEnumerator()) { while (enumerator.MoveNext()) { ZipPackagePart contentFile = (ZipPackagePart)enumerator.Current; ZipHandler.CreateFile(origName, contentFile); result = true; } } package.Close(); } catch { return(false); } finally { if (package != null) { package.Close(); } } return(result); }
internal ExcelSlicerXmlSources(XmlNamespaceManager nsm, XmlNode topNode, ZipPackagePart part) : base(nsm, topNode) { _part = part; foreach (XmlNode node in GetNodes("d:extLst/d:ext")) { switch (node.Attributes["uri"].Value) { case _tableUId: //Table slicer foreach (XmlNode slicerNode in node.SelectNodes("x14:slicerList/x14:slicer", NameSpaceManager)) { _list.Add(new ExcelSlicerXmlSource(eSlicerSourceType.Table, part, slicerNode.Attributes["r:id"].Value)); } break; case _pivotTableUId: //Pivot table slicer foreach (XmlNode slicerNode in node.SelectNodes("x14:slicerList/x14:slicer", NameSpaceManager)) { _list.Add(new ExcelSlicerXmlSource(eSlicerSourceType.PivotTable, part, slicerNode.Attributes["r:id"].Value)); } break; default: break; } } }
public static string GetApplicationRibbonDiffXmlFromSolutionBody(byte[] fileBody) { string result = string.Empty; using (var memStream = new MemoryStream()) { memStream.Write(fileBody, 0, fileBody.Length); using (ZipPackage package = (ZipPackage)ZipPackage.Open(memStream, FileMode.Open, FileAccess.ReadWrite)) { ZipPackagePart part = (ZipPackagePart)package.GetPart(new Uri("/customizations.xml", UriKind.Relative)); if (part != null) { XDocument doc = null; using (Stream streamPart = part.GetStream(FileMode.Open, FileAccess.Read)) { doc = XDocument.Load(streamPart); } var ribbonDiffXml = doc.XPathSelectElement("ImportExportXml/RibbonDiffXml"); if (ribbonDiffXml != null) { result = ribbonDiffXml.ToString(); } } } } return(result); }
public Imaging(ZipPackagePart docRelPart, string inputDocxPath, string outputLatexPath) { _docRelPart = docRelPart; _inputDocxPath = inputDocxPath; _documentDirectory = Path.GetDirectoryName(inputDocxPath); _latexDirectory = Path.GetDirectoryName(outputLatexPath); }
private ZipPackageRelationship CreateThemeOverridePart(ZipPackage p, ZipPackagePart partToCopy) { var id = GetIxFromChartUri(_chart.UriChart.OriginalString); ThemeOverrideUri = GetNewUri(p, "/xl/theme/themeOverride{0}.xml", ref id); var rel = _chart.Part.CreateRelationship(ThemeOverrideUri, TargetMode.Internal, ExcelPackage.schemaThemeOverrideRelationships); ThemeOverridePart = p.CreatePart(ThemeOverrideUri, ExcelPackage.contentTypeThemeOverride); ThemeOverrideXml = new XmlDocument(); ThemeOverrideXml.Load(partToCopy.GetStream()); foreach (var themeRel in partToCopy.GetRelationships()) { var uri = OfficeOpenXml.Utils.UriHelper.ResolvePartUri(themeRel.SourceUri, themeRel.TargetUri); var toPart = _chart.Part.Package.CreatePart(uri, PictureStore.GetContentType(uri.OriginalString)); var imageRel = ThemeOverridePart.CreateRelationship(uri, TargetMode.Internal, themeRel.RelationshipType); SetRelIdInThemeDoc(ThemeOverrideXml, themeRel.Id, imageRel.Id); var stream = partToCopy.GetStream(); var b = stream.GetBuffer(); toPart.GetStream().Write(b, 0, b.Length); } ThemeOverrideXml.Save(ThemeOverridePart.GetStream(FileMode.CreateNew)); partToCopy.Package.Dispose(); return(rel); }
/// <summary> /// Method to create file at the temp folder /// </summary> /// <param name="rootFolder"></param> /// <param name="contentFileURI"></param> /// <returns></returns> protected static void ExtractFile(ZipPackagePart contentFile, string rootFolder) { // Initially create file under the folder specified string contentFilePath = string.Empty; contentFilePath = contentFile.Uri.OriginalString.Replace('/', Path.DirectorySeparatorChar); if (contentFilePath.StartsWith(Path.DirectorySeparatorChar.ToString())) { contentFilePath = contentFilePath.TrimStart(Path.DirectorySeparatorChar); } contentFilePath = Path.Combine(rootFolder, contentFilePath); //Check for the folder already exists. If not then create that folder if (!Directory.Exists(Path.GetDirectoryName(contentFilePath))) { Directory.CreateDirectory(Path.GetDirectoryName(contentFilePath)); } // Create the file with the Part content using (FileStream fileStream = new FileStream(contentFilePath, FileMode.Create)) { CopyStream(contentFile.GetStream(), fileStream); } // end:using(FileStream fileStream) - Close & dispose fileStream. }
private void GetSolutionFiles(string selectedPath, out XDocument docSolution, out XDocument docCustomizations) { docSolution = null; docCustomizations = null; using (FileStream fileStream = new FileStream(selectedPath, FileMode.Open, FileAccess.Read, FileShare.Read)) { using (ZipPackage package = (ZipPackage)ZipPackage.Open(fileStream, FileMode.Open, FileAccess.Read)) { { ZipPackagePart part = (ZipPackagePart)package.GetPart(new Uri("/solution.xml", UriKind.Relative)); if (part != null) { using (Stream streamPart = part.GetStream(FileMode.Open, FileAccess.Read)) { docSolution = XDocument.Load(streamPart); } } } { ZipPackagePart part = (ZipPackagePart)package.GetPart(new Uri("/customizations.xml", UriKind.Relative)); if (part != null) { using (Stream streamPart = part.GetStream(FileMode.Open, FileAccess.Read)) { docCustomizations = XDocument.Load(streamPart); } } } } } }
internal static XmlTextReader GetPartAsXmlReader(ZipPackage package, string uriString) { // HACK: just make it work... if (!uriString.StartsWith("/")) { uriString = "/" + uriString; } // Documents with relative uri exists. if (uriString.StartsWith("/..")) { uriString = uriString.Substring(3); } ZipPackagePart part = package.GetPart(new Uri(uriString, UriKind.Relative)) as ZipPackagePart; string xml = String.Empty; using (Stream stream = part.GetStream()) { using (StreamReader sr = new StreamReader(stream)) { xml = sr.ReadToEnd(); } } XmlTextReader reader = new XmlTextReader(new StringReader(xml)); return(reader); }
public PBIXUtils(string pbixSourceFileName, string pbixTargetFileName) { _originalFile = pbixSourceFileName; _modifiedFile = pbixTargetFileName; File.Copy(_originalFile, _modifiedFile, true); _pbixPackage = (ZipPackage)ZipPackage.Open(_modifiedFile, FileMode.Open); var enumerator = _pbixPackage.GetParts().GetEnumerator(); if (enumerator == null) { return; } while (enumerator.MoveNext() && (_mashup == null || _model == null)) { var currentPart = enumerator.Current as ZipPackagePart; if (currentPart == null) { continue; } if (currentPart.Uri.OriginalString.Contains("/DataMashup")) { _mashup = currentPart; } else if (currentPart.Uri.OriginalString.Contains("/DataModel")) { _model = currentPart; } } }
public string ResolveImage(string imageId, IStatusInformation statusInfo) { PackageRelationship rs = _docRelPart.GetRelationship(imageId); string imageUrl = rs.TargetUri.OriginalString; string orginalImagePath = Path.Combine(_latexDirectory, imageUrl); string newImagePath = Path.Combine(_latexDirectory, imageUrl); ZipPackagePart imagePackagePart = (ZipPackagePart)rs.Package.GetPart(new Uri("/word/" + imageUrl, UriKind.Relative)); using (Stream contentStream = imagePackagePart.GetStream()) { byte[] content = new byte[contentStream.Length]; contentStream.Read(content, 0, (int)contentStream.Length); using (FileStream fs = new FileStream(orginalImagePath, FileMode.Create)) { using (BinaryWriter bwImage = new BinaryWriter(fs)) { bwImage.Write(content, 0, (int)contentStream.Length); } } } ConvertImageToEPS(orginalImagePath, newImagePath, statusInfo); return(Path.ChangeExtension(imageUrl, "eps"));; }
internal ExcelChartEx(ExcelDrawings drawings, XmlNode node, Uri uriChart, ZipPackagePart part, XmlDocument chartXml, XmlNode chartNode, ExcelGroupShape parent = null) : base(drawings, node, chartXml, parent, "mc:AlternateContent/mc:Choice/xdr:graphicFrame") { UriChart = uriChart; Part = part; _chartNode = chartNode; ChartType = GetChartType(chartNode, drawings.NameSpaceManager); Init(); }
internal ExcelStockChart(ExcelDrawings drawings, XmlNode node, Uri uriChart, ZipPackagePart part, XmlDocument chartXml, XmlNode chartNode, ExcelGroupShape parent = null) : base(drawings, node, uriChart, part, chartXml, chartNode, parent) { if (chartNode.LocalName == "barChart") { var barChart = new ExcelBarChart(this, chartNode, parent); barChart.Direction = eDirection.Column; _plotArea = new ExcelChartPlotArea(NameSpaceManager, ChartXml.SelectSingleNode("c:chartSpace/c:chart/c:plotArea", NameSpaceManager), barChart, "c", this); _chartNode = chartNode.NextSibling; } }
internal ExcelChartStandard(ExcelDrawings drawings, XmlNode node, Uri uriChart, ZipPackagePart part, XmlDocument chartXml, XmlNode chartNode, ExcelGroupShape parent, string drawingPath = "xdr:graphicFrame", string nvPrPath = "xdr:nvGraphicFramePr/xdr:cNvPr") : base(drawings, node, chartXml, parent, drawingPath, nvPrPath) { UriChart = uriChart; Part = part; ChartXml = chartXml; _chartNode = chartNode; InitSeries(this, drawings.NameSpaceManager, _chartNode, PivotTableSource != null); InitChartLoad(drawings, chartNode); ChartType = GetChartType(chartNode.LocalName); }
internal ExcelControl(ExcelDrawings drawings, XmlNode drawingNode, ControlInternal control, ZipPackagePart ctrlPropPart, XmlDocument ctrlPropXml, ExcelGroupShape parent = null) : base(drawings, drawingNode, "xdr:sp", "xdr:nvSpPr/xdr:cNvPr", parent) { _control = control; _vml = (ExcelVmlDrawingControl)drawings.Worksheet.VmlDrawings[LegacySpId]; _vmlProp = XmlHelperFactory.Create(_vml.NameSpaceManager, _vml.GetNode("x:ClientData")); ControlPropertiesXml = ctrlPropXml; ControlPropertiesPart = ctrlPropPart; ControlPropertiesUri = ctrlPropPart.Uri; _ctrlProp = XmlHelperFactory.Create(NameSpaceManager, ctrlPropXml.DocumentElement); }
// -------------------------- CreatePackage -------------------------- /// <summary> /// Creates a package zip file containing specified /// content and resource files.</summary> private static void CreatePackage(string packagePath, bool withFiles, bool withDB, Player p) { // Create the Package if (withDB) { Server.s.Log("Saving DB..."); SaveDatabase("SQL.sql"); Server.s.Log("Saved DB to SQL.sql"); } Server.s.Log("Creating package..."); using (ZipPackage package = (ZipPackage)ZipPackage.Open(packagePath, FileMode.Create)) { if (withFiles) { Server.s.Log("Collecting Directory structure..."); string currDir = Directory.GetCurrentDirectory() + "\\"; List <Uri> partURIs = GetAllFiles(new DirectoryInfo("./"), new Uri(currDir)); Server.s.Log("Structure complete"); Server.s.Log("Saving data..."); foreach (Uri loc in partURIs) { if (!Uri.UnescapeDataString(loc.ToString()).Contains(packagePath)) { // Add the part to the Package ZipPackagePart packagePart = (ZipPackagePart)package.CreatePart(loc, ""); // Copy the data to the Document Part using (FileStream fileStream = new FileStream( "./" + Uri.UnescapeDataString(loc.ToString()), FileMode.Open, FileAccess.Read)) { CopyStream(fileStream, packagePart.GetStream()); } // end:using(fileStream) - Close and dispose fileStream. } } // end:foreach(Uri loc) } if (withDB) { // If we don't want to back up database, we don't do this part. Server.s.Log("Compressing Database..."); ZipPackagePart packagePart = (ZipPackagePart)package.CreatePart(new Uri("/SQL.sql", UriKind.Relative), "", CompressionOption.Normal); CopyStream(File.OpenRead("SQL.sql"), packagePart.GetStream()); Server.s.Log("Database compressed."); } // end:if(withFiles) Server.s.Log("Data saved!"); } // end:using (Package package) - Close and dispose package. Player.SendMessage(p, "Server backup (" + (withFiles ? "Everything" + (withDB ? "" : " but Database") : "Database") + "): Complete!"); Server.s.Log("Server backed up!"); }// end:CreatePackage()
public static byte[] ReplaceApplicationRibbonDiffXmlInSolutionBody(byte[] solutionBodyBinary, XElement newRibbonDiffXml) { using (var memStream = new MemoryStream()) { memStream.Write(solutionBodyBinary, 0, solutionBodyBinary.Length); using (ZipPackage package = (ZipPackage)ZipPackage.Open(memStream, FileMode.Open, FileAccess.ReadWrite)) { ZipPackagePart part = (ZipPackagePart)package.GetPart(new Uri("/customizations.xml", UriKind.Relative)); if (part != null) { XDocument doc = null; using (Stream streamPart = part.GetStream(FileMode.Open, FileAccess.Read)) { doc = XDocument.Load(streamPart); } var ribbonDiffXml = doc.XPathSelectElement("ImportExportXml/RibbonDiffXml"); if (ribbonDiffXml != null) { ribbonDiffXml.ReplaceWith(newRibbonDiffXml); } using (Stream streamPart = part.GetStream(FileMode.Create, FileAccess.Write)) { XmlWriterSettings settings = new XmlWriterSettings { OmitXmlDeclaration = true, Indent = true, Encoding = Encoding.UTF8 }; using (XmlWriter xmlWriter = XmlWriter.Create(streamPart, settings)) { doc.Save(xmlWriter); xmlWriter.Flush(); } } } } memStream.Position = 0; byte[] result = memStream.ToArray(); return(result); } }
/// <summary> /// Renders an XPS document page to the specified PDF page. /// </summary> /// <param name="page">The target PDF page. The page must belong to the PDF document of this converter.</param> /// <param name="xpsPageIndex">The zero-based XPS page number.</param> public void RenderPage(PdfPage page, int xpsPageIndex) { if (page == null) { throw new ArgumentNullException("page"); } if (!ReferenceEquals(page.Owner, pdfDocument)) { throw new InvalidOperationException(PSXSR.PageMustBelongToPdfDocument); } // Debug.Assert(xpsPageIndex==0, "xpsPageIndex must be 0 at this stage of implementation."); try { FixedPage fpage = xpsDocument.GetDocument().GetFixedPage(xpsPageIndex); // ZipPackage pack = ZipPackage.Open(xpsFilename) as ZipPackage; Uri uri = new Uri("/Documents/1/Pages/1.fpage", UriKind.Relative); ZipPackagePart part = xpsDocument.Package.GetPart(uri) as ZipPackagePart; if (part != null) { using (Stream stream = part.GetStream()) using (StreamReader sr = new StreamReader(stream)) { string xml = sr.ReadToEnd(); #if true && DEBUG if (!String.IsNullOrEmpty(xpsDocument.Path)) { string xmlPath = IOPath.Combine(IOPath.GetDirectoryName(xpsDocument.Path), IOPath.GetFileNameWithoutExtension(xpsDocument.Path)) + ".xml"; using (StreamWriter sw = new StreamWriter(xmlPath)) { sw.Write(xml); } } #endif //XpsElement el = PdfSharp.Xps.Parsing.XpsParser.Parse(xml); PdfRenderer renderer = new PdfRenderer(); renderer.RenderPage(page, fpage); } } } catch (Exception ex) { Debug.WriteLine(ex.ToString()); throw; } }
/// <summary> /// User selected to SAVE the selected open part /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void toolStripButton3_Click(object sender, EventArgs e) { // open the package using (ZipPackage LobjZip = (ZipPackage)ZipPackage.Open(MstrPath, FileMode.Open, FileAccess.ReadWrite)) { string LstrUri = label1.Text; ZipPackagePart LobjPart = (ZipPackagePart)LobjZip.GetPart(new Uri(LstrUri, UriKind.Relative)); Stream LobjStream = LobjPart.GetStream(FileMode.Open, FileAccess.ReadWrite); LobjStream.SetLength(0); LobjStream.Flush(); StreamWriter LobjSw = new StreamWriter(LobjStream); LobjSw.Write(lineNumberTextBox1.Text); LobjSw.Close(); } toolStripButton3.Enabled = false; }
/// <summary> /// Gets an XML reader for the specified part, or null, if the part not exists. /// </summary> static XmlTextReader GetPartAsXmlReader(ZipPackage package, Uri uri) { ZipPackagePart part = package.GetPart(uri) as ZipPackagePart; string xml = String.Empty; using (Stream stream = part.GetStream()) { using (StreamReader sr = new StreamReader(stream)) { xml = sr.ReadToEnd(); } } XmlTextReader reader = new XmlTextReader(new StringReader(xml)); return(reader); }
/// <summary> /// A helper method that decompresses the the Ribbon data returned /// </summary> /// <param name="data">The compressed ribbon data</param> /// <returns></returns> private byte[] unzipRibbon(byte[] data) { System.IO.Packaging.ZipPackage package = null; MemoryStream memStream = null; memStream = new MemoryStream(); memStream.Write(data, 0, data.Length); package = (ZipPackage)ZipPackage.Open(memStream, FileMode.Open); ZipPackagePart part = (ZipPackagePart)package.GetPart(new Uri("/RibbonXml.xml", UriKind.Relative)); using (Stream strm = part.GetStream()) { long len = strm.Length; byte[] buff = new byte[len]; strm.Read(buff, 0, (int)len); return(buff); } }
private void GetSection1M(byte[] dataMashupBytes) { //Only reading section1.M from packaging parts int packagingPartsLength = BitConverter.ToUInt16(dataMashupBytes.Skip(4).Take(4).ToArray(), 0); byte[] packagingPartsBytes = dataMashupBytes.Skip(8).Take(packagingPartsLength).ToArray(); using (MemoryStream packagingPartsStream = new MemoryStream(packagingPartsBytes)) { var packagingParts = new ZipPackage(packagingPartsStream); ZipPackagePart section1M = packagingParts.GetPart(new Uri("/Formulas/Section1.m", UriKind.Relative)); if (section1M == null) { return; } using (var reader = new StreamReader(section1M.GetStream())) PowerQueryFormulas = reader.ReadToEnd(); } }
public static string GetRibbonDiffXmlForEntityFromSolutionBody(string entityName, byte[] fileBody) { string result = string.Empty; using (var memStream = new MemoryStream()) { memStream.Write(fileBody, 0, fileBody.Length); using (ZipPackage package = (ZipPackage)ZipPackage.Open(memStream, FileMode.Open, FileAccess.ReadWrite)) { ZipPackagePart part = (ZipPackagePart)package.GetPart(new Uri("/customizations.xml", UriKind.Relative)); if (part != null) { XDocument doc = null; using (Stream streamPart = part.GetStream(FileMode.Open, FileAccess.Read)) { doc = XDocument.Load(streamPart); } var nodes = doc.XPathSelectElements("ImportExportXml/Entities/Entity"); foreach (var item in nodes) { var elementName = item.Element("Name"); if (elementName != null && string.Equals(elementName.Value, entityName, StringComparison.InvariantCultureIgnoreCase)) { var ribbonDiffXml = item.Element("RibbonDiffXml"); if (ribbonDiffXml != null) { result = ribbonDiffXml.ToString(); break; } } } } } } return(result); }
public void ReplaceKnownVariable(string variable, string newValue) { string packagePartsTempLocation = Path.GetTempFileName(); ZipPackage partsPackage = GetPackageParts(packagePartsTempLocation); var parts = partsPackage.GetParts(); var enumerator = parts.GetEnumerator(); ZipPackagePart mCodePart = null; while (enumerator.MoveNext()) { if (enumerator.Current.Uri.OriginalString.Contains("/Formulas/Section1.m")) { mCodePart = (ZipPackagePart)enumerator.Current; break; } } string theMCode; using (StreamReader mCodeReader = new StreamReader(mCodePart.GetStream())) { theMCode = mCodeReader.ReadToEnd(); } string pattern = "^shared\\s*" + variable + "\\s*=\\s*\"\\S*\""; Regex r = new Regex(pattern, RegexOptions.Multiline | RegexOptions.IgnoreCase); string updatedMCode = r.Replace(theMCode, string.Format(CultureInfo.InvariantCulture, "shared {0} = \"{1}\"", variable, newValue)); byte[] updateMCodeBytes = Encoding.UTF8.GetBytes(updatedMCode); mCodePart.GetStream().Write(updateMCodeBytes, 0, updateMCodeBytes.Length); mCodePart.GetStream().SetLength(updateMCodeBytes.Length); mCodePart.GetStream().Flush(); partsPackage.Close(); FileInfo fi = new FileInfo(packagePartsTempLocation); _packagePartsLength = Convert.ToUInt32(fi.Length); _packageParts = File.ReadAllBytes(packagePartsTempLocation); File.Delete(packagePartsTempLocation); }
internal void Save(ExcelPackage package, ZipPackagePart WorkbookPart, Uri personsUri) { if (Count == 0) { if (package.ZipPackage.PartExists(personsUri)) { package.ZipPackage.DeletePart(personsUri); } } else { if (!package.ZipPackage.PartExists(personsUri)) { var p = package.ZipPackage.CreatePart(personsUri, "application/vnd.ms-excel.person+xml"); WorkbookPart.CreateRelationship(personsUri, Packaging.TargetMode.Internal, ExcelPackage.schemaPersonsRelationShips); } package.SavePart(personsUri, PersonsXml); } }
public Numbering(ZipPackagePart numberingPart) { _numberingPart = numberingPart; // if exist then load it if (numberingPart != null) { Stream numberingStream = _numberingPart.GetStream(); NameTable nt = new NameTable(); _xmlnsMgr = new XmlNamespaceManager(nt); _xmlnsMgr.AddNamespace("w", "http://schemas.openxmlformats.org/wordprocessingml/2006/main"); _numberingDoc = new XmlDocument(nt); _numberingDoc.Load(numberingStream); } _listStyle = new List <ListInfo>(); _visitedFirstLevelNumberings = new Dictionary <uint, string>(); }
public static byte[] UnzipRibbon(byte[] data) { using (var memStream = new MemoryStream()) { memStream.Write(data, 0, data.Length); using (ZipPackage package = (ZipPackage)ZipPackage.Open(memStream, FileMode.Open)) { ZipPackagePart part = (ZipPackagePart)package.GetPart(new Uri("/RibbonXml.xml", UriKind.Relative)); using (Stream strm = part.GetStream()) { long len = strm.Length; byte[] buff = new byte[len]; strm.Read(buff, 0, (int)len); return(buff); } } } }
public static byte[] UnzipCrmTranslations(byte[] data, string filepath) { using (MemoryStream memStream = new MemoryStream()) { memStream.Write(data, 0, data.Length); using (ZipPackage package = (ZipPackage)ZipPackage.Open(memStream, FileMode.Open)) { ZipPackagePart part = (ZipPackagePart)package.GetPart(new Uri(filepath, UriKind.Relative)); using (Stream strm = part.GetStream()) { long len = strm.Length; byte[] buff = new byte[len]; strm.Read(buff, 0, (int)len); return(buff); } } } }
/// <summary> /// Method to create file at the temp folder /// </summary> /// <param name="rootFolder"></param> /// <param name="contentFileURI"></param> /// <returns></returns> private void createFile(ZipPackagePart contentFile) { // Initially create file under the folder specified string contentFilePath = string.Empty; contentFilePath = contentFile.Uri.OriginalString.Replace('/', System.IO.Path.DirectorySeparatorChar); if (contentFilePath.StartsWith( System.IO.Path.DirectorySeparatorChar.ToString())) { contentFilePath = contentFilePath.TrimStart( System.IO.Path.DirectorySeparatorChar); } else { //do nothing } contentFilePath = System.IO.Path.Combine(_certPath, contentFilePath); //Check for the folder already exists. If not then create that folder if (System.IO.Directory.Exists( System.IO.Path.GetDirectoryName(contentFilePath)) != true) { System.IO.Directory.CreateDirectory( System.IO.Path.GetDirectoryName(contentFilePath)); } else { //do nothing } System.IO.FileStream newFileStream = System.IO.File.Create(contentFilePath); newFileStream.Close(); byte[] content = new byte[contentFile.GetStream().Length]; contentFile.GetStream().Read(content, 0, content.Length); System.IO.File.WriteAllBytes(contentFilePath, content); }
internal ExcelXmlSource(ZipPackagePart relPart, string relId) { if (string.IsNullOrEmpty(relId)) { Uri = XmlHelper.GetNewUri(relPart.Package, "/xl/slicers/slicer{0}.xml"); Part = relPart.Package.CreatePart(Uri, "application/vnd.ms-excel.slicer+xml", CompressionLevel.Default); Rel = relPart.CreateRelationship(UriHelper.GetRelativeUri(relPart.Uri, Uri), TargetMode.Internal, ExcelPackage.schemaRelationshipsSlicer); var xml = new XmlDocument(); XmlHelper.LoadXmlSafe(xml, "<slicers xmlns:xr10=\"http://schemas.microsoft.com/office/spreadsheetml/2016/revision10\" xmlns:x=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" mc:Ignorable=\"x xr10\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/main\" />", Encoding.UTF8); XmlDocument = xml; } else { Rel = relPart.GetRelationship(relId); Uri = UriHelper.ResolvePartUri(relPart.Uri, Rel.TargetUri); Part = relPart.Package.GetPart(Uri); var xml = new XmlDocument(); XmlHelper.LoadXmlSafe(xml, Part.GetStream()); XmlDocument = xml; } }