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;
}
}
