Exemple #1
0
        /// <summary>
        /// No custom properties? Add the part, and the collection of properties
        /// </summary>
        private static CustomFilePropertiesPart InitializeCustomDocumentProperties(OpenXmlPackage document)
        {
            CustomFilePropertiesPart customProperties = null;

            if (document.GetType() == typeof(WordprocessingDocument))
            {
                var word = document as WordprocessingDocument;
                if (word != null)
                {
                    customProperties = word.AddCustomFilePropertiesPart();
                }
            }
            else if (document.GetType() == typeof(SpreadsheetDocument))
            {
                var excel = document as SpreadsheetDocument;
                if (excel != null)
                {
                    customProperties = excel.AddCustomFilePropertiesPart();
                }
            }
            else
            {
                throw new ArgumentException($"unkown type of {nameof(document)} [{document.GetType()}]");
            }

            if (customProperties == null)
            {
                throw new Exception("customDocumentProperties could not be initialized");
            }

            customProperties.Properties = new Properties();
            return(customProperties);
        }
Exemple #2
0
        private void BuildCustomProperties(MemoryStream documentData)
        {
            Logger.Info("Building custom properties section for newly-generated document.");
            using (WordprocessingDocument document = WordprocessingDocument.Open(documentData, true))
            {
                CustomFilePropertiesPart customPropertiesPart = document.CustomFilePropertiesPart;

                // Add custom properties part if there is none yet.
                if (customPropertiesPart == null)
                {
                    customPropertiesPart            = document.AddCustomFilePropertiesPart();
                    customPropertiesPart.Properties = new Properties();
                }

                // Remove all existing custom properties first.
                Properties customProps = customPropertiesPart.Properties;
                customProps.RemoveAllChildren <CustomDocumentProperty>();

                // Stick all of our generated custom properties in the new document.
                foreach (CustomDocumentProperty customProp in customProperties)
                {
                    customProps.AppendChild(customProp);
                }

                // Re-number the custom properties (advice given by MSDN).
                int pid = 2;
                foreach (CustomDocumentProperty customProp in customProps)
                {
                    customProp.PropertyId = pid++;
                }
            }
        }
Exemple #3
0
        private void GenerateCustomFilePropertiesPartContent(CustomFilePropertiesPart customFilePropertiesPart1)
        {
            var properties2 = new DocumentFormat.OpenXml.CustomProperties.Properties();

            properties2.AddNamespaceDeclaration("vt",
                                                "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes");
            var propertyId = 1;

            foreach (XlCustomProperty p in Properties)
            {
                propertyId++;
                var customDocumentProperty = new CustomDocumentProperty
                {
                    FormatId   = "{D5CDD505-2E9C-101B-9397-08002B2CF9AE}",
                    PropertyId = propertyId,
                    Name       = p.Name
                };
                var vTlpwstr1 = new VTLPWSTR {
                    Text = p.Value
                };
                customDocumentProperty.AppendChild(vTlpwstr1);
                properties2.AppendChild(customDocumentProperty);
            }

            customFilePropertiesPart1.Properties = properties2;
            customFilePropertiesPart1.Properties.Save();
        }
Exemple #4
0
        private static CustomFilePropertiesPart GetCustomDocumentProperties(OpenXmlPackage document)
        {
            CustomFilePropertiesPart customProps = null;

            if (document.GetType() == typeof(WordprocessingDocument))
            {
                var word = document as WordprocessingDocument;
                if (word != null)
                {
                    customProps = word.CustomFilePropertiesPart;
                }
            }
            else if (document.GetType() == typeof(SpreadsheetDocument))
            {
                var excel = document as SpreadsheetDocument;
                if (excel != null)
                {
                    customProps = excel.CustomFilePropertiesPart;
                }
            }

            if (customProps == null)
            {
                customProps = InitializeCustomDocumentProperties(document);
            }
            return(customProps);
        }
Exemple #5
0
        public static void GenerateCustomFilePropertiesPart1Content(CustomFilePropertiesPart customFilePropertiesPart1)
        {
            Op.Properties properties2 = new Op.Properties();
            properties2.AddNamespaceDeclaration("vt", "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes");

            Op.CustomDocumentProperty customDocumentProperty1 = new Op.CustomDocumentProperty()
            {
                FormatId = "{D5CDD505-2E9C-101B-9397-08002B2CF9AE}", PropertyId = 2, Name = "ContentTypeId"
            };
            Vt.VTLPWSTR vTLPWSTR1 = new Vt.VTLPWSTR();
            vTLPWSTR1.Text = "0x0101004B3CC135CC07AD41A19C6A3D7A557156";

            customDocumentProperty1.Append(vTLPWSTR1);

            Op.CustomDocumentProperty customDocumentProperty2 = new Op.CustomDocumentProperty()
            {
                FormatId = "{D5CDD505-2E9C-101B-9397-08002B2CF9AE}", PropertyId = 3, Name = "Order"
            };
            Vt.VTDouble vTDouble1 = new Vt.VTDouble();
            vTDouble1.Text = "3254000";

            customDocumentProperty2.Append(vTDouble1);

            properties2.Append(customDocumentProperty1);
            properties2.Append(customDocumentProperty2);

            customFilePropertiesPart1.Properties = properties2;
        }
 public FrmDeleteCustomProps(CustomFilePropertiesPart cfp)
 {
     InitializeComponent();
     PartModified = false;
     part = cfp;
     UpdateList();
 }
Exemple #7
0
 private void WriteCustomProperties(SpreadsheetDocument document)
 {
     if (Properties.Count != 0)
     {
         CustomFilePropertiesPart propertiesPart = document.CustomFilePropertiesPart ?? AddExtended(document);
         GenerateCustomFilePropertiesPartContent(propertiesPart);
     }
 }
 public List<string> CfpList(CustomFilePropertiesPart part)
 {
     List<string> val = new List<string>();
     foreach (CustomDocumentProperty cdp in part.RootElement)
     {
         val.Add(cdp.Name);
     }
     return val;
 }
 public DocxCustomPropertiesEditor ReadDocProperties()
 {
     if (_Document.CustomFilePropertiesPart == null)
     {
         _CustomProperties            = _Document.AddCustomFilePropertiesPart();
         _CustomProperties.Properties = new Properties();
     }
     else
     {
         _CustomProperties = _Document.CustomFilePropertiesPart;
     }
     return(this);
 }
Exemple #10
0
        private CustomFilePropertiesPart AddExtended(SpreadsheetDocument document)
        {
            CustomFilePropertiesPart propertiesPart = document.CustomFilePropertiesPart;

            if (propertiesPart == null)
            {
                propertiesPart = document.AddCustomFilePropertiesPart();
                if (propertiesPart != null && propertiesPart.Properties == null)
                {
                    propertiesPart.Properties = new DocumentFormat.OpenXml.CustomProperties.Properties();
                }
            }
            return(propertiesPart);
        }
Exemple #11
0
        private void SetFileProperties(CustomFilePropertiesPart customProp)
        {
            customProp.Properties = new Properties();
            int kvIndex = 2;

            foreach (KeyValuePair <string, string> kvPair in DocProperties)
            {
                CustomDocumentProperty newProp = new CustomDocumentProperty()
                {
                    Name = kvPair.Key, FormatId = "{D5CDD505-2E9C-101B-9397-08002B2CF9AE}", PropertyId = Int32Value.FromInt32(kvIndex), VTLPWSTR = new DocumentFormat.OpenXml.VariantTypes.VTLPWSTR(kvPair.Value)
                };
                customProp.Properties.Append(newProp);
                kvIndex++;
            }
        }
        public CustomFilePropertiesPart CheckCustomProperty(CustomFilePropertiesPart customFilePropertiesPart, int ParentId)
        {
            if (customFilePropertiesPart != null)
            {
                var props = customFilePropertiesPart.Properties;
                if (props != null)
                {
                    var prop = props.Where(p => ((CustomDocumentProperty)p).Name.Value == "ParentId").FirstOrDefault();
                    if (prop != null)
                    {
                        Int32.TryParse(((CustomDocumentProperty)prop).InnerText, out ParentId);
                    }
                }
            }

            return(customFilePropertiesPart);
        }
        public static void GenerateCustomFilePropertiesPart1Content(CustomFilePropertiesPart customFilePropertiesPart1)
        {
            var properties2 = new DocumentFormat.OpenXml.CustomProperties.Properties();

            properties2.AddNamespaceDeclaration("vt", "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes");

            var customDocumentProperty1 = new DocumentFormat.OpenXml.CustomProperties.CustomDocumentProperty()
            {
                FormatId = "{D5CDD505-2E9C-101B-9397-08002B2CF9AE}", PropertyId = 2, Name = "ContentTypeId"
            };
            var vTLPWSTR1 =
                new DocumentFormat.OpenXml.VariantTypes.VTLPWSTR {
                Text = "0x0101004B3CC135CC07AD41A19C6A3D7A557156"
            };

            customDocumentProperty1.Append(vTLPWSTR1);

            properties2.Append(customDocumentProperty1);

            customFilePropertiesPart1.Properties = properties2;
        }
 /// <summary>
 /// Saves the DOM into the CustomFilePropertiesPart.
 /// </summary>
 /// <param name="openXmlPart">Specifies the part to save to.</param>
 public void Save(CustomFilePropertiesPart openXmlPart)
 {
     base.SaveToPart(openXmlPart);
 }
 /// <summary>
 /// Loads the DOM from the CustomFilePropertiesPart
 /// </summary>
 /// <param name="openXmlPart">Specifies the part to be loaded.</param>
 public void Load(CustomFilePropertiesPart openXmlPart)
 {
     LoadFromPart(openXmlPart);
 }
 internal Properties(CustomFilePropertiesPart ownerPart) : base(ownerPart)
 {
 }
        private void CreateParts(PresentationDocument document, PresentationGenerationData data)
        {
            ExtendedFilePropertiesPart extendedFilePropertiesPart1 = document.AddNewPart <ExtendedFilePropertiesPart>("rId3");

            GenerateExtendedFilePropertiesPartHelper.GenerateExtendedFilePropertiesPart1Content(extendedFilePropertiesPart1);

            PresentationPart presentationPart1 = document.AddPresentationPart();

            GeneratePresentationPartHelper.GeneratePresentationPart1Content(presentationPart1);

            CommentAuthorsPart commentAuthorsPart1 = presentationPart1.AddNewPart <CommentAuthorsPart>("rId8");

            GenerateCommentAuthorsPartHelper.GenerateCommentAuthorsPart1Content(commentAuthorsPart1);

            CustomXmlPart customXmlPart1 = presentationPart1.AddNewPart <CustomXmlPart>("application/xml", "rId3");

            GenerateCustomXmlPartHelper.GenerateCustomXmlPart1Content(customXmlPart1);

            CustomXmlPropertiesPart customXmlPropertiesPart1 = customXmlPart1.AddNewPart <CustomXmlPropertiesPart>("rId1");

            GenerateCustomXmlPropertiesPartHelper.GenerateCustomXmlPropertiesPart1Content(customXmlPropertiesPart1);

            HandoutMasterPart handoutMasterPart1 = presentationPart1.AddNewPart <HandoutMasterPart>("rId7");

            GenerateHandoutMasterPartHelper.GenerateHandoutMasterPart1Content(handoutMasterPart1);

            ThemePart themePart1 = handoutMasterPart1.AddNewPart <ThemePart>("rId1");

            GenerateThemePartHelper.GenerateThemePart1Content(themePart1);

            TableStylesPart tableStylesPart1 = presentationPart1.AddNewPart <TableStylesPart>("rId12");

            GenerateTableStylesPartHelper.GenerateTableStylesPart1Content(tableStylesPart1);

            CustomXmlPart customXmlPart2 = presentationPart1.AddNewPart <CustomXmlPart>("application/xml", "rId2");

            GenerateCustomXmlPartHelper.GenerateCustomXmlPart2Content(customXmlPart2);

            CustomXmlPropertiesPart customXmlPropertiesPart2 = customXmlPart2.AddNewPart <CustomXmlPropertiesPart>("rId1");

            GenerateCustomXmlPropertiesPartHelper.GenerateCustomXmlPropertiesPart2Content(customXmlPropertiesPart2);

            CustomXmlPart customXmlPart3 = presentationPart1.AddNewPart <CustomXmlPart>("application/xml", "rId1");

            GenerateCustomXmlPartHelper.GenerateCustomXmlPart3Content(customXmlPart3);

            CustomXmlPropertiesPart customXmlPropertiesPart3 = customXmlPart3.AddNewPart <CustomXmlPropertiesPart>("rId1");

            GenerateCustomXmlPropertiesPartHelper.GenerateCustomXmlPropertiesPart3Content(customXmlPropertiesPart3);

            NotesMasterPart notesMasterPart1 = presentationPart1.AddNewPart <NotesMasterPart>("rId6");

            GenerateNotesMasterPartHelper.GenerateNotesMasterPart1Content(notesMasterPart1);

            ThemePart themePart2 = notesMasterPart1.AddNewPart <ThemePart>("rId1");

            GenerateThemePartHelper.GenerateThemePart2Content(themePart2);

            ThemePart themePart3 = presentationPart1.AddNewPart <ThemePart>("rId11");

            GenerateThemePartHelper.GenerateThemePart3Content(themePart3);

            SlidePart slidePart1 = presentationPart1.AddNewPart <SlidePart>("rId5");

            GenerateSlidePartHelper.GenerateSlidePart1Content(slidePart1, data);

            var pictureType = string.Empty;

            if (!string.IsNullOrEmpty(data.PictureType))
            {
                pictureType = data.PictureType;
            }
            else
            {
                pictureType = "image/png";
            }

            ImagePart imagePart1 = slidePart1.AddNewPart <ImagePart>(pictureType, "rId3");

            GenerateImagePartHelper.GenerateImagePart1Content(imagePart1, data.PictureContent);

            NotesSlidePart notesSlidePart1 = slidePart1.AddNewPart <NotesSlidePart>("rId2");

            GenerateNotesSlidePartHelper.GenerateNotesSlidePart1Content(notesSlidePart1);

            notesSlidePart1.AddPart(slidePart1, "rId2");

            notesSlidePart1.AddPart(notesMasterPart1, "rId1");

            SlideLayoutPart slideLayoutPart1 = slidePart1.AddNewPart <SlideLayoutPart>("rId1");

            GenerateSlideLayoutPartHelper.GenerateSlideLayoutPart1Content(slideLayoutPart1);

            SlideMasterPart slideMasterPart1 = slideLayoutPart1.AddNewPart <SlideMasterPart>("rId1");

            GenerateSlideMasterPartHelper.GenerateSlideMasterPart1Content(slideMasterPart1);

            SlideLayoutPart slideLayoutPart2 = slideMasterPart1.AddNewPart <SlideLayoutPart>("rId8");

            GenerateSlideLayoutPartHelper.GenerateSlideLayoutPart2Content(slideLayoutPart2);

            slideLayoutPart2.AddPart(slideMasterPart1, "rId1");

            ImagePart imagePart2 = slideMasterPart1.AddNewPart <ImagePart>("image/jpeg", "rId13");

            GenerateImagePartHelper.GenerateImagePart2Content(imagePart2);

            SlideLayoutPart slideLayoutPart3 = slideMasterPart1.AddNewPart <SlideLayoutPart>("rId3");

            GenerateSlideLayoutPartHelper.GenerateSlideLayoutPart3Content(slideLayoutPart3);

            slideLayoutPart3.AddPart(slideMasterPart1, "rId1");

            SlideLayoutPart slideLayoutPart4 = slideMasterPart1.AddNewPart <SlideLayoutPart>("rId7");

            GenerateSlideLayoutPartHelper.GenerateSlideLayoutPart4Content(slideLayoutPart4);

            slideLayoutPart4.AddPart(slideMasterPart1, "rId1");

            slideMasterPart1.AddPart(themePart3, "rId12");

            slideMasterPart1.AddPart(slideLayoutPart1, "rId2");

            SlideLayoutPart slideLayoutPart5 = slideMasterPart1.AddNewPart <SlideLayoutPart>("rId1");

            GenerateSlideLayoutPartHelper.GenerateSlideLayoutPart5Content(slideLayoutPart5);

            ImagePart imagePart3 = slideLayoutPart5.AddNewPart <ImagePart>("image/jpeg", "rId3");

            GenerateImagePartHelper.GenerateImagePart3Content(imagePart3);

            ImagePart imagePart4 = slideLayoutPart5.AddNewPart <ImagePart>("image/png", "rId2");

            GenerateImagePartHelper.GenerateImagePart4Content(imagePart4);

            slideLayoutPart5.AddPart(slideMasterPart1, "rId1");

            SlideLayoutPart slideLayoutPart6 = slideMasterPart1.AddNewPart <SlideLayoutPart>("rId6");

            GenerateSlideLayoutPartHelper.GenerateSlideLayoutPart6Content(slideLayoutPart6);

            slideLayoutPart6.AddPart(slideMasterPart1, "rId1");

            SlideLayoutPart slideLayoutPart7 = slideMasterPart1.AddNewPart <SlideLayoutPart>("rId11");

            GenerateSlideLayoutPartHelper.GenerateSlideLayoutPart7Content(slideLayoutPart7);

            slideLayoutPart7.AddPart(slideMasterPart1, "rId1");

            SlideLayoutPart slideLayoutPart8 = slideMasterPart1.AddNewPart <SlideLayoutPart>("rId5");

            GenerateSlideLayoutPartHelper.GenerateSlideLayoutPart8Content(slideLayoutPart8);

            slideLayoutPart8.AddPart(slideMasterPart1, "rId1");

            SlideLayoutPart slideLayoutPart9 = slideMasterPart1.AddNewPart <SlideLayoutPart>("rId10");

            GenerateSlideLayoutPartHelper.GenerateSlideLayoutPart9Content(slideLayoutPart9);

            slideLayoutPart9.AddPart(slideMasterPart1, "rId1");

            SlideLayoutPart slideLayoutPart10 = slideMasterPart1.AddNewPart <SlideLayoutPart>("rId4");

            GenerateSlideLayoutPartHelper.GenerateSlideLayoutPart10Content(slideLayoutPart10);

            slideLayoutPart10.AddPart(slideMasterPart1, "rId1");

            SlideLayoutPart slideLayoutPart11 = slideMasterPart1.AddNewPart <SlideLayoutPart>("rId9");

            GenerateSlideLayoutPartHelper.GenerateSlideLayoutPart11Content(slideLayoutPart11);

            slideLayoutPart11.AddPart(slideMasterPart1, "rId1");

            ViewPropertiesPart viewPropertiesPart1 = presentationPart1.AddNewPart <ViewPropertiesPart>("rId10");

            GenerateViewPropertiesPartHelper.GenerateViewPropertiesPart1Content(viewPropertiesPart1);

            presentationPart1.AddPart(slideMasterPart1, "rId4");

            PresentationPropertiesPart presentationPropertiesPart1 = presentationPart1.AddNewPart <PresentationPropertiesPart>("rId9");

            GeneratePresentationPropertiesPartHelper.GeneratePresentationPropertiesPart1Content(presentationPropertiesPart1);

            CustomFilePropertiesPart customFilePropertiesPart1 = document.AddNewPart <CustomFilePropertiesPart>("rId4");

            CustomFilePropertiesPartHelper.GenerateCustomFilePropertiesPart1Content(customFilePropertiesPart1);

            SetPackageProperties(document);
        }
Exemple #18
0
        public override void Write()
        {
            ExportFileName = PopulatedName(ExportFileName);
            if (!String.IsNullOrWhiteSpace(ExportFileName))
            {
                DocProperties["FileName"]   = ExportFileName;
                DocProperties["TableCount"] = _dataSet.Tables.Count.ToString();
                if (PopulatePropertiesOnly)
                {
                    if (_dataSet != null)
                    {
                        foreach (DataTable dTable in _dataSet.Tables)
                        {
                            if (dTable.Rows.Count > 0)
                            {
                                foreach (DataColumn dColumn in dTable.Columns)
                                {
                                    DocProperties[dColumn.ColumnName] = dTable.Rows[0][dColumn].ToString();
                                }
                            }
                        }
                    }
                }
                switch (DestinationType)
                {
                case OfficeFileType.WordDocument:
                    WordprocessingDocument doc;
                    if (File.Exists(TemplateFileName))
                    {
                        doc = WordprocessingDocument.CreateFromTemplate(TemplateFileName);
                        doc = (WordprocessingDocument)doc.SaveAs(ExportFileName);
                    }
                    else
                    {
                        doc = WordprocessingDocument.Create(ExportFileName, WordprocessingDocumentType.Document);
                    }
                    CustomFilePropertiesPart customProp = doc.CustomFilePropertiesPart;
                    if (customProp == null)
                    {
                        customProp = doc.AddCustomFilePropertiesPart();
                    }
                    SetFileProperties(customProp);

                    MainDocumentPart mainDoc = doc.MainDocumentPart;
                    if (mainDoc == null)
                    {
                        mainDoc = doc.AddMainDocumentPart();
                    }

                    DocumentSettingsPart settingsPart = mainDoc.GetPartsOfType <DocumentSettingsPart>().First();
                    UpdateFieldsOnOpen   updateFields = new UpdateFieldsOnOpen
                    {
                        Val = new OnOffValue(true)
                    };
                    settingsPart.Settings.PrependChild <UpdateFieldsOnOpen>(updateFields);
                    settingsPart.Settings.Save();

                    if (!PopulatePropertiesOnly)
                    {
                        if (mainDoc.Document == null)
                        {
                            mainDoc.Document = new word.Document();
                        }
                        word.Body body       = new word.Body();
                        bool      firstTable = true;
                        foreach (DataTable dt in _dataSet.Tables)
                        {
                            if (!firstTable)
                            {
                                body.Append(GetPageBreak());
                            }
                            else
                            {
                                firstTable = false;
                            }
                            body.Append(GetParagraph(dt.TableName));
                            body.Append(GetWordTable(dt));
                        }
                        mainDoc.Document.Append(body);
                    }
                    mainDoc.Document.Save();
                    doc.Dispose();
                    break;

                case OfficeFileType.ExcelWorkbook:
                    SpreadsheetDocument spreadSheet;
                    if (File.Exists(TemplateFileName))
                    {
                        spreadSheet = SpreadsheetDocument.CreateFromTemplate(TemplateFileName);
                        spreadSheet = (SpreadsheetDocument)spreadSheet.SaveAs(ExportFileName);
                    }
                    else
                    {
                        spreadSheet = SpreadsheetDocument.Create(ExportFileName, SpreadsheetDocumentType.Workbook);
                        spreadSheet.Save();
                    }
                    using (SpreadsheetDocument workbook = spreadSheet)
                    {
                        CustomFilePropertiesPart excelCustomProp = workbook.AddCustomFilePropertiesPart();
                        SetFileProperties(excelCustomProp);

                        if (workbook.WorkbookPart == null)
                        {
                            workbook.AddWorkbookPart();
                        }
                        if (workbook.WorkbookPart.Workbook == null)
                        {
                            workbook.WorkbookPart.Workbook = new excel.Workbook();
                        }
                        if (workbook.WorkbookPart.Workbook.Sheets == null)
                        {
                            workbook.WorkbookPart.Workbook.Sheets = new excel.Sheets();
                        }
                        excel.Sheets sheets = workbook.WorkbookPart.Workbook.Sheets;
                        foreach (DataTable table in _dataSet.Tables)
                        {
                            excel.SheetData sheetData = null;
                            WorksheetPart   sheetPart = null;
                            excel.Sheet     sheet     = null;
                            foreach (OpenXmlElement element in sheets.Elements())
                            {
                                if (element is Sheet)
                                {
                                    sheet = (Sheet)element;
                                    if (sheet.Name.Value.Equals(table.TableName, StringComparison.CurrentCultureIgnoreCase))
                                    {
                                        //Assign the sheetPart
                                        sheetPart = (WorksheetPart)workbook.WorkbookPart.GetPartById(sheet.Id.Value);
                                        sheetData = sheetPart.Worksheet.GetFirstChild <SheetData>();
                                        break;
                                    }
                                }
                                sheet = null;
                            }

                            if (sheet == null)
                            {
                                sheetPart           = workbook.WorkbookPart.AddNewPart <WorksheetPart>(); //Create a new WorksheetPart
                                sheetData           = new excel.SheetData();                              //create a new SheetData
                                sheetPart.Worksheet = new excel.Worksheet(sheetData);                     /// Create a new Worksheet with the sheetData and link it to the sheetPart...

                                string relationshipId = workbook.WorkbookPart.GetIdOfPart(sheetPart);     //get the ID of the sheetPart.
                                sheet = new excel.Sheet()
                                {
                                    Id = relationshipId, SheetId = 1, Name = table.TableName
                                };                        //create a new sheet
                                sheets.Append(sheet);     //append the sheet to the sheets.
                            }

                            List <String> columns = new List <string>();
                            foreach (System.Data.DataColumn column in table.Columns)
                            {
                                columns.Add(column.ColumnName);
                            }
                            if (PrintTableHeader)
                            {
                                excel.Row headerRow = new excel.Row();

                                foreach (string column in columns)
                                {
                                    excel.Cell cell = new excel.Cell
                                    {
                                        DataType  = excel.CellValues.String,
                                        CellValue = new excel.CellValue(GetColumnName(table.Columns[column]))
                                    };
                                    headerRow.AppendChild(cell);
                                }


                                sheetData.AppendChild(headerRow);
                            }

                            foreach (DataRow dsrow in table.Rows)
                            {
                                excel.Row newRow = new excel.Row();
                                foreach (String col in columns)
                                {
                                    excel.Cell cell = new excel.Cell
                                    {
                                        DataType  = excel.CellValues.String,
                                        CellValue = new excel.CellValue(dsrow[col].ToString())     //
                                    };
                                    newRow.AppendChild(cell);
                                }

                                sheetData.AppendChild(newRow);
                            }
                            sheetPart.Worksheet.Save();
                        }
                        workbook.WorkbookPart.Workbook.Save();
                        workbook.Save();
                        workbook.Close();
                    }

                    break;
                }
            }
        }