Documentation – Showcases

Net: Aspose.PDF Editor

Sat, 05 Jun 2021 00:00:00 +0000

What is Html5 PDF Editor by Aspose.PDF for .NET?

HTML5 PDF Editor by Aspose.PDF for .NET is an open source web based PDF editor that allows users to create, edit and convert PDF files online and users can easily embed the editor in their own web applications for viewing and editing PDF files. HTML5 PDF Editor is developed using HTML5, jQuery Ajax, ASP.NET, Bootstrap and backend is powered by Aspose.PDF for .NET. The UI of the editor is kept very simple for easy understanding and enhancement of the features as per user requirements.

Features

Currently, it supports the following features:

Create new PDF files
Loading and Viewing PDF files
Loading PDF and Image files from Dropbox
Exporting PDF file to different file formats
Appending or Merging PDF files
Inserting New Pages
Deleting Pages
Moving Pages in PDF file
Inserting Text in PDF
Highlight Text in PDF
Rotate Inserted Text in PDF
Searching Text in PDF
Replace Text in PDF
Inserting Images
Resizing Signature and Images
Dragging and Positioning inserted items
Loading PDF files with form fields
Fill Form fields using the Editor
Save and Export PDF with form fields data
Highlighting required form fields
Add Attachments to PDF Files
Load Attachments from input PDF file
Download the Attachment files
Remove the Attachment files
Signing PDF using Free-Hand Drawing

System Requirements

As HTML5 PDF Editor is .NET Web application which is developed using ASP.NET, C#, HTML5, jQuery, Javascript. You will need the following system environment to setup HTML5 PDF Editor at your end.

Visual Studio 2010 (or above)
.NET Framework 3.5 (or above)
Aspose.PDF for .NET
jQuery 2.0.3
Bootstrap 3.2.0

You can use any of the following browsers to run the application at your end:

Mozilla Firefox (recommended)
Internet Explorer (version 9 or later)
Google Chrome
Apple Safari

Support

We, at Aspose, make sure to provide best possible support to our customers / users for their queries of any nature i.e. technical or sales. Please use the below links for any license and sales related or technical query.

PDF Editor Developer Guide

Create New PDF Files

Besides editing existing PDF documents, Html5 PDF Editor also supports creating new PDF files from scratch which you can do by using Create New File option from the menu bar. Using this feature, you may create a blank PDF in editor, add some text/images to it and save it in any desired format. In our next section, we will discuss the technical details behind this feature.

How it works?

HTML - “Create New File” menu item is clicked on the page

When you click “Create New File” menu item, onNewFileClicked method is called in Editor.js file.

jQuery - Send Ajax request to server for CreateNewFile method.

See Editor.js tab below for source code of onNewFileClicked method, it calls CreateNewFile method in CanvasSave.aspx.cs file.

ASP.NET web method handles server requests

See Canvas.aspx.cs tab below with source code of CreateNewFile method. It clears any existing data regarding previously loaded file using ResetData method.

New PDF file creation using Aspose.PDF for .NET

After clearing the data using ResetData method, CreateNewFile method creates a new PDF file using Document class of Aspose.PDF for .NET. As you can see in the below tab, the Document object is generating a file with one empty page. After the file is generated on the server, the file is converted to image using ImageConverter method to be loaded on canvas.

Loading the resultant file to canvas.

After file gets converted to image on server side, the control is returned back to onNewFileClicked method in Editor.js. onNewFileClicked method resets all the client side collections and load the generated image file to canvas using resetData method.

Exporting PDF to Different File Formats

HTML5 PDF Editor supports exporting PDF file to different file formats which you can do by using Export File option from the menu bar. Using this feature, you can export the PDF file to your desired format. In our next section, we will discuss the technical details behind this feature.

How it works?

HTML - “Export File” menu item is clicked on the page.

When you click “Export File” menu item, you can choose the export format from the list. After selecting the export format, “ExportFile” method is called in Editor.js file.

jQuery - Send Ajax server request for method btnFileExport_Click method

See Editor.js tab below for source code of “ExportFile” method. It send a request to server method btnFileExport_Click with file format parameter in CanvasSave.aspx.cs file.

ASP.NET web method handles server requests

See Canvas.aspx.cs tab below. Based on the file format parameter passed to btnFileExport_Click, the PDF file is converted using Save method of Aspose.PDF Document object.

Export file to Download on Client Browser

After the file is generated on the server, the control is returned back to ExportFile method in Editor.js from where the file is sent to the browser for user to download using ExportToBrowser method.

Appending or Merging PDF Files

Html5 PDF Editor supports appending or merging of PDF files which you can do by using Append File option from the menu bar. Using this feature, you can append the PDF file to your input file. In our next section, we will discuss the technical details behind this feature.

How it works?

HTML - “Append File” menu item is clicked on the page.

When you click “Append File” menu item, you can upload the file using file upload dialog. After the file gets uploaded, “fileSelected” method is called in Editor.js file.

jQuery - Send server request for ProcessRequest method

See Editor.js tab below for source code of “fileSelected” method. File gets posted to the server and method “ProcessRequest” is called in CanvasSave.aspx.cs file.

ASP.NET web method handles server requests

See Canvas.aspx.cs tab below. Based on the form parameter passed, the file to be appended is saved on the server and “AppendFile” method is called. AppendFile method, append the uploaded file using Aspose.PDF for .NET, convert the resultant file to image and return the control back to “fileSelected” method in Editor.js

Update the canvas content after appending the file

After the file is generated on the server, the control is returned back to “fileSeleceted” method in Editor.js which update the contents of the editor.

Upload Local PDF File

HTML5 PDF Editor supports uploading PDF file from local machine using Open From Computer option from the menu bar. Using this feature, you can open an existing PDF file and perform editing on your PDF file. In our next section, we will discuss the technical details behind this feature.

How it works?

HTML - “Open From Computer” menu item is clicked on the page.

When you click “Open From Computer” menu item, you can upload the input file using file upload dialog. After the file gets uploaded, “fileSelected” method is called in Editor.js file.

jQuery - Send server request for ProcessRequest method

See Editor.js tab below for source code of “fileSelected” method. File gets posted to the server and method “ProcessRequest” is called in CanvasSave.aspx.cs file.

ASP.NET web method handles server requests

See Canvas.aspx.cs tab below. Based on the form parameter passed, the file to be uploaded is saved on the server, resets the data using “ResetData” method and “ImageConverter” method is called. ImageConverter method, converts the uploaded file to images using Aspose.PDF for .NET and return the control back to “fileSelected” method in Editor.js

Update the canvas content after uploading the file

After the file is generated on the server, the control is returned back to “fileSeleceted” method in Editor.js which update the contents of the editor i.e. resets the canvas, load the newly uploaded file.

Adding Page in PDF File

Using Html5 PDF Editor, you can add new pages in PDF files using Add Page option from the menu bar. Using this feature, you may add a blank page to your PDF file. In our next section, we will discuss the technical details behind this feature.

How it works?

HTML - “Add Page” menu item is clicked on the page

When you click “Add Page” menu item, “AddPage” method is called in Editor.js file.

jQuery - Send Ajax request to server for AddPage_Click method.

See Editor.js tab below for source code of AddPage method, it calls AddPage_Click method in CanvasSave.aspx.cs file.

ASP.NET web method handles server requests

See Canvas.aspx.cs tab below with source code of AddPage_Click method. It adds a new empty page in PDF file using Aspose.PDF.Document class. After adding the page to PDF file, it converts the page to image to be displayed in the editor.The control is then returned back to Editor.js file which updates the page numbering in AddPage method.

Deleting Page from PDF File

Using Html5 PDF Editor, you can delete a page from PDF files using Delete Page option from the menu bar. In our next section, we will discuss the technical details behind this feature.

How it works?

HTML - “Delete Page” menu item is clicked on the page

When you click “Delete Page” menu item, DeletePage method is called in Editor.js file.

jQuery - Send Ajax request to server for DeletePage_Click method.

See Editor.js tab below for source code of DeletePage method, it calls DeletePage_Click method in CanvasSave.aspx.cs file.

ASP.NET web method handles server requests

See Canvas.aspx.cs tab below with source code of DeletePage_Click method. It deletes the selected page from PDF file using Delete method of Aspose.PDF.Document.Page collection.

Updating editing content

After deleting the page from PDF file, the control is then returned back to DeletePage method in Editor.js file which updates the page numbering, remove any collections associated with the deleted page using updateIndexesDelete method.

Move Pages in PDF File

Using Html5 PDF Editor, you can move pages in PDF files using Move Page option from the menu bar. Once you press the Move Page menu item, you are presented with an input dialog to specify the selected page’s new location. In our next section, we will discuss the technical details behind this feature.

How it works?

HTML - “Move Page” menu item is clicked on the page

When you click “Move Page” menu item, input dialog is shown to get the new location of the selected page. After providing the page number and pressing “Move” button, “Move” method is called in Editor.js file.

jQuery - Send Ajax request to server for MovePages method.

See Editor.js tab below for source code of Move method, which calls MovePage method and it passes the details like move from, move to, pages list to MovePages method in CanvasSave.aspx.cs file.

ASP.NET web method handles server requests

See Canvas.aspx.cs tab below with source code of MovePages method. It uses Aspose.PDF.Document.Pages collection to move the pages.

Updating editing content

After moving the page, the control is then returned back to MovePage method in Editor.js file which updates the page indexes and information related to different collections in the editor using MoveUpdate method.

Inserting Text in PDF File

Using Html5 PDF Editor, you can insert text in PDF files using Text Mode option from the menu bar. Once you select the Text Mode menu item and click on any location on the editor where you want to add the text, you are presented with an input dialog to input and format your desired text as shown below:

In our next section, we will discuss the technical details behind this feature.

How it works?

HTML - “Text Mode” menu item is selected on the page

When you select “Text Mode” menu item and click your desired location on the editor to insert text in PDF file, input dialog is shown to get the text you need to insert on the page. After providing the text and pressing “OK” button, “saveTextFromArea” method is called in Editor.js file.

Javascript - Get the input text from input dialog and show on the editor.

See Editor.js tab below for source code of saveTextFromArea method, which gets the text from the input dialog and show it on the editor. Also, it saves the data in shapes collection which is later used on server side to insert text in the PDF file. You can check the source code of saveFile method which is called when the file is saved.

ASP.NET web method handles server requests

As mentioned above, the text will actually get inserted into our source PDF file when we perform the save operation which uses GetTextStamp method to create the text stamp to insert in PDF file. See Canvas.aspx.cs tab below with source code of GetTextStamp method. It uses Aspose.PDF.TextStamp class to insert the text in the PDF file.

Highlight Text in PDF File

Using Html5 PDF Editor, you can highlight text in PDF files using Highlight Mode option from the menu bar. Once you select the Highlight Mode menu item, you can highlight any text and area using the rectangular highlighting tool. In our next section, we will discuss the technical details behind this feature.

How it works?

HTML - “Highlight Mode” menu item is selected on the page

When you select “Highlight Mode” menu item, you can draw a rectangular highlight around any text or item in your PDF file. The implementation of this process can be seen in “tools.rect” method in Editor.js file.

Javascript - Draw highlighting rectangle on the editor.

See Editor.js tab below for source code of tool.rect method, which allows the user to draw highlighting rectangle at any location on the editor. Also, it saves the data in shapes collection which is later used on server side to insert highlighting in source PDF file. You can check the source code of saveFile method which is called when the file is saved.

ASP.NET web method handles server requests

As mentioned above, the highlighting is actually inserted into our source PDF file when we perform the save operation which uses GetImageStamp method to insert the image stamp in source PDF file at the location specified on editor. See Canvas.aspx.cs tab below with source code of GetImageStamp method. It uses Aspose.PDF.ImageStamp class to insert the highlighting rectangle in the PDF file.

Searching Text in PDF File

Using Html5 PDF Editor, you can search text in PDF files using Search Text option from the menu bar. Once you click the Search Text menu item, you will be presented with a dialog box to input the text to be searched as shown below:

On providing the text and pressing search, all the instances of the word searched will get highlighted as shown below:

How it works?

HTML - “Search Text” menu item is clicked on the page

When you click “Search Text” menu item, you are presented with an input dialog to enter the text you want to search. After entering the text and pressing search button, “Move” method is called which checks whether the move page operation is performed or search operation is performed and then it calls performSearch method in Editor.js file.

jQuery - Send Ajax server request for method SearchData method

See Editor.js tab below for source code of performSearch method, which gets the input text and a request to server method SearchData in CanvasSave.aspx.cs file.

ASP.NET web method handles server requests

See Canvas.aspx.cs tab below. Using the input text passed from performSearch method, SearchData method uses Aspose.PDF.Text.TextFragmentAbsorber class to search for all the instances of the input text in our source PDF file and System.Drawing.Brush class to draw highlighting against the searched text. Once the data is searched, the resultant file is again converted to image and gets loaded in the editor.

Replacing Text in PDF File

Using Html5 PDF Editor, you can replace the existing text in PDF files using Replace Text option from the menu bar. Once you click the Replace Text menu item, you will be presented with a dialog box to input the text to be searched and replaced with.

How it works?

HTML - “Replace Text” menu item is clicked on the page

When you click “Replace Text” menu item, you are presented with an input dialog to enter the text to search and replace. After entering the text and pressing Replace button, “ReplaceText” method is called in Editor.js file.

jQuery - Send Ajax server request for method ReplaceText method

See Editor.js tab below for source code of ReplaceText method, which gets the input text from input text dialog and a request to server method ReplaceText in CanvasSave.aspx.cs file.

ASP.NET web method handles server requests

See Canvas.aspx.cs tab below. ReplaceText method uses Aspose.PDF.Text.TextFragmentAbsorber class to search for all the instances of the text to be replaced in our source PDF file and replaces all the instances with the replaced text. Once the text is replaced, the resultant file is again converted to image and gets loaded in the editor.

Loading PDF File with Form Fields

Using Html5 PDF Editor, you can load and work with a PDF file containing form fields. Once the file with form fields is loaded in the editor, all the form fields are loaded for editing. In our next section, we will discuss the technical details behind this feature.

How it works?

HTML - “Open From Computer” menu item is clicked on the page.

When you click “Open From Computer” menu item, you can upload the input file containing the form fields using file upload dialog. After the file gets uploaded, “fileSelected” method is called in Editor.js file.

jQuery - Send server request for ProcessRequest method

File gets posted to the server and method “ProcessRequest” is called in CanvasSave.aspx.cs file.

ASP.NET web method handles server requests

See Canvas.aspx.cs tab below. Based on the form parameter passed, the file to be uploaded is saved on the server, ImageConverter method, converts the uploaded file to images and “CheckFields” method is called which uses Aspose.PDF.InteractiveFeatures.Forms class to check for all the form fields and collect the information regarding the fields i.e. FieldType, Location etc. and return the field’s collection back to ImageConverter method. ImageConverter method returns the control back to “fileSelected” method in Editor.js

Loading form fields on canvas

Highlighting Required Form Fields

Using Html5 PDF Editor, you can highlight the required form fields in the editor. Once the file with form fields is loaded in the editor, all the required form fields are highlighted for the users to assist in editing. In our next section, we will discuss the technical details behind this feature.

How it works?

HTML - “Open From Computer” menu item is clicked on the page.

jQuery - Send server request for ProcessRequest method

File gets posted to the server and method “ProcessRequest” is called in CanvasSave.aspx.cs file.

ASP.NET web method handles server requests

See Canvas.aspx.cs tab below. Based on the form parameter passed, the file to be uploaded is saved on the server, ImageConverter method, converts the uploaded file to images and “CheckFields” method is called which uses Aspose.PDF.InteractiveFeatures.Forms class to check for all the form fields and collect the information regarding the fields i.e. FieldType, Location etc.. After getting the details of all the form fields, we get the information whether a form field is required form fields using Aspose.PDF.Facades.IsRequiredField method and return the field’s collection back to ImageConverter method. ImageConverter method returns the control back to “fileSelected” method in Editor.js

Loading form fields on canvas

See Editor.js tab below, manageFields method in Editor.js is used to generate all the fields on the canvas based on the information sent back from the server side. It draws HTML field controls using the type and location information from the server side to the canvas. If a certain field is required, it uses the div (named as wrapper) around the control and change the background color property of the div to show it as highlighted required field.

Net: Render WebForms DataGridView to PDF

Sat, 05 Jun 2021 00:00:00 +0000

How to export WebForm to PDF using Aspose.PDF/Aspose.HTML

Introduction

Generally, to convert WebForm to PDF document uses additional tools. This sample shows how to use Aspose.PDF library to render WebForm to PDF. The Aspose Export GridView To Pdf Control is also included in this sample to show how to render GridView control to PDF document.

How to render WebForm to PDF

The original idea for render WebForm to PDF is to create helper class, which inherited from System.Web.UI.Page, and overriding a Render method.

void Render(HtmlTextWriter writer)
{
    if (RenderToPDF)
    {
        // render web page for PDF document
    }
    else
    {
        // render web page in browser
        base.Render(writer);
    }
}

There are two Aspose tools can be used for render HTML to PDF:

Aspose.PDF for .NET
Aspose Export GridView control (based on Aspose.PDF)

Source Files

In this sample we have 2 demo reports.

Default.aspx demonstrate export to PDF using Aspose.PDF
Report2.aspx demonstrate export to PDF using Aspose Export GridView control (based on Aspose.PDF)

Additional files

Helpers\PdfPage.cs - contains a helper class, which shows how to use Aspose.PDF API.

The Aspose.Pdf.GridViewExport project contains extened GridView control for demonstration in Report2.aspx

Net: Render table from the data source

Sat, 05 Jun 2021 00:00:00 +0000

Aspose.PDF allows you to create the table with DataSource from DataSet, Data Table, arrays and IEnumerable objects using PdfLightTable class

The Table class is used to process tables. This class gives us the ability to create tables and place them in the document, using Rows and Cells. So, to create the table, you need to add the required number of rows and fill them with the appropriate number of cells.

The following example creates the table 4x10.

var table = new Table
    {
        // Set column auto widths of the table
        ColumnWidths = "25% 25% 25% 25%",
        // Set cell padding
        DefaultCellPadding = new MarginInfo(10, 5, 10, 5), // Left Bottom Right Top
        // Set the table border color as Green
        Border = new BorderInfo(BorderSide.All, .5f, Color.Green),
        // Set the border for table cells as Black
        DefaultCellBorder = new BorderInfo(BorderSide.All, .2f, Color.Green),
    };
    for (var rowCount = 0; rowCount < 10; rowCount++)
    {
        // Add row to table
        var row = table.Rows.Add();
        // Add table cells
        for (int i = 0; i < 4; i++)
        {
            row.Cells.Add($"Cell ({i+1}, {rowCount +1})");
        }
    }
    // Add table object to first page of input document
    document.Pages[1].Paragraphs.Add(table);

When initializing the Table object, the minimal skin settings were used:

ColumnWidths - width of columns (by default);
DefaultCellPadding - the default fields for the table cell;
Border - table frame attributes (style, thickness, color);
DefaultCellBorder - attributes of the cell frame (style, thickness, color).

Exporting data from an array of objects

The Table class provides methods for interacting with ADO.NET data sources - ImportDataTable and ImportDataView. The first method imports data from the DataTable, the second from the DataView. Premising that these objects are not very convenient for working in the MVC template, we will limit ourselves to a brief example. In this example (line 50), the ImportDataTable method is called and receives as parameters a DataTable instance and additional settings like the header flag and the initial position (rows/cols) for the data output.

// Create new a PDF document
var document = new Document
{
    PageInfo = new PageInfo { Margin = new MarginInfo(28, 28, 28, 42) }
};

var pdfPage = document.Pages.Add();

// Initializes a new instance of the TextFragment for report's title
var textFragment = new TextFragment(reportTitle1);
Table table = new Table
{
    // Set column widths of the table
    ColumnWidths = "25% 25% 25% 25%",
    // Set cell padding
    DefaultCellPadding = new MarginInfo(10, 5, 10, 5), // Left Bottom Right Top
    // Set the table border color as Green
    Border = new BorderInfo(BorderSide.All, .5f, Color.Green),
    // Set the border for table cells as Black
    DefaultCellBorder = new BorderInfo(BorderSide.All, .2f, Color.Green),
};

var configuration = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("config.json", false)
    .Build();

var connectionString = configuration.GetSection("connectionString").Value;

if (string.IsNullOrEmpty(connectionString))
    throw new ArgumentException("No connection string in config.json");

var resultTable = new DataTable();

using (var conn = new SqlConnection(connectionString))
{
    const string sql = "SELECT * FROM Tennats";
    using (var cmd = new SqlCommand(sql, conn))
    {
        using (var adapter = new SqlDataAdapter(cmd))
        {
            adapter.Fill(resultTable);
        }
    }
}

table.ImportDataTable(resultTable,true,1,1);

// Add table object to first page of input document
document.Pages[1].Paragraphs.Add(table);
using (var streamOut = new MemoryStream())
{
    document.Save(streamOut);
    return new FileContentResult(streamOut.ToArray(), "application/pdf")
    {
        FileDownloadName = "demotable2.pdf"
    };
}

Net: Render table with Entity Framework

Sat, 05 Jun 2021 00:00:00 +0000

There are a number of tasks when for some reason it is more convenient to export data from databases to a PDF document without using the recently popular HTML to PDF conversion scheme.

This article will show you how to generate a PDF document using the Aspose.PDF for .NET.

Basics of generation PDF with Aspose.PDF

One of the most important classes in Aspose.PDF is a Document class. This class is a PDF rendering engine. To present a PDF structure, the Aspose.PDF library uses the Document-Page model, where:

Document - contains the properties of the PDF document including page collection;
Page - contains the properties of a specific page and various collections of elements associated with this page.

Therefore, to create a PDF document with Aspose.PDF, you should follow these steps:

Create the Document object;
Add the page (the Page object) for the Document object;
Create objects that are placed on the page (e.g. text fragment, table, etc.)
Add created items to the corresponding collection on the page (in our case it will be a paragraph collection);
Save the document as PDF file.

// Step 1
var document = new Document
{
    PageInfo = new PageInfo { Margin = new MarginInfo(28, 28, 28, 42) }
};

// Step 2
var pdfPage = document.Pages.Add();

// Step 3
var textFragment = new TextFragment(reportTitle);
// ..........................................

var table = new Table
{
    // .................................
};

// Step 4
pdfPage.Paragraphs.Add(textFragment);
pdfPage.Paragraphs.Add(table);

// Step 5
using (var streamOut = new MemoryStream())
{
    document.Save(streamOut);
    return new FileContentResult(streamOut.ToArray(), "application/pdf")
    {
        FileDownloadName = "tenants.pdf"
    };
}

The most common problem is the output of data in a table format. The Table class is used to process tables. This class gives us the ability to create tables and place them in the document, using Rows and Cells. So, to create the table, you need to add the required number of rows and fill them with the appropriate number of cells.

The following example creates the table 4x10.

var table = new Table
    {
        // Set column auto widths of the table
        ColumnWidths = "25% 25% 25% 25%",
        // Set cell padding
        DefaultCellPadding = new MarginInfo(10, 5, 10, 5), // Left Bottom Right Top
        // Set the table border color as Green
        Border = new BorderInfo(BorderSide.All, .5f, Color.Green),
        // Set the border for table cells as Black
        DefaultCellBorder = new BorderInfo(BorderSide.All, .2f, Color.Green),
    };
    for (var rowCount = 0; rowCount < 10; rowCount++)
    {
        // Add row to table
        var row = table.Rows.Add();
        // Add table cells
        for (int i = 0; i < 4; i++)
        {
            row.Cells.Add($"Cell ({i+1}, {rowCount +1})");
        }
    }
    // Add table object to first page of input document
    document.Pages[1].Paragraphs.Add(table);

When initializing the Table object, the minimal skin settings were used:

ColumnWidths - width of columns (by default);
DefaultCellPadding - the default fields for the table cell;
Border - table frame attributes (style, thickness, color);
DefaultCellBorder - attributes of the cell frame (style, thickness, color).

As a result, we get the table 4x10 with equal-width columns.

Exporting Data from ADO.NET Objects

// Create new a PDF document
var document = new Document
{
    PageInfo = new PageInfo { Margin = new MarginInfo(28, 28, 28, 42) }
};

var pdfPage = document.Pages.Add();

// Initializes a new instance of the TextFragment for report's title
var textFragment = new TextFragment(reportTitle1);
Table table = new Table
{
    // Set column widths of the table
    ColumnWidths = "25% 25% 25% 25%",
    // Set cell padding
    DefaultCellPadding = new MarginInfo(10, 5, 10, 5), // Left Bottom Right Top
    // Set the table border color as Green
    Border = new BorderInfo(BorderSide.All, .5f, Color.Green),
    // Set the border for table cells as Black
    DefaultCellBorder = new BorderInfo(BorderSide.All, .2f, Color.Green),
};

var configuration = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("config.json", false)
    .Build();

var connectionString = configuration.GetSection("connectionString").Value;

if (string.IsNullOrEmpty(connectionString))
    throw new ArgumentException("No connection string in config.json");

var resultTable = new DataTable();

using (var conn = new SqlConnection(connectionString))
{
    const string sql = "SELECT * FROM Tennats";
    using (var cmd = new SqlCommand(sql, conn))
    {
        using (var adapter = new SqlDataAdapter(cmd))
        {
            adapter.Fill(resultTable);
        }
    }
}

table.ImportDataTable(resultTable,true,1,1);

// Add table object to first page of input document
document.Pages[1].Paragraphs.Add(table);
using (var streamOut = new MemoryStream())
{
    document.Save(streamOut);
    return new FileContentResult(streamOut.ToArray(), "application/pdf")
    {
        FileDownloadName = "demotable2.pdf"
    };
}

Exporting Data from the Entity Framework

More relevant for modern .NET is the import of data from ORM frameworks. In this case, it’s a good idea to extend the Table class with extension methods for importing data from a simple list or from the grouped data. Let’s give an example for one of the most popular ORMs - Entity Framework.

public static class PdfHelper
    {
        public static void ImportEntityList<TSource>(this Pdf.Table table, IList<TSource> data)
        {
            var headRow = table.Rows.Add();

            var props = typeof(TSource).GetProperties(BindingFlags.Public | BindingFlags.Instance);
            foreach (var prop in props)
            {
                headRow.Cells.Add(prop.GetCustomAttribute(typeof(DisplayAttribute)) is DisplayAttribute dd ? dd.Name : prop.Name);
            }

            foreach (var item in data)
            {
                // Add row to table
                var row = table.Rows.Add();
                // Add table cells
                foreach (var t in props)
                {
                    var dataItem = t.GetValue(item, null);
                    if (t.GetCustomAttribute(typeof(DataTypeAttribute)) is DataTypeAttribute dataType)
                        switch (dataType.DataType)
                        {

                            case DataType.Currency:
                                row.Cells.Add(string.Format("{0:C}", dataItem));
                                break;
                            case DataType.Date:
                                var dateTime = (DateTime)dataItem;
                                if (t.GetCustomAttribute(typeof(DisplayFormatAttribute)) is DisplayFormatAttribute df)
                                {
                                    row.Cells.Add(string.IsNullOrEmpty(df.DataFormatString)
                                        ? dateTime.ToShortDateString()
                                        : string.Format(df.DataFormatString, dateTime));
                                }
                                break;
                            default:
                                row.Cells.Add(dataItem.ToString());
                                break;
                        }
                    else
                    {
                        row.Cells.Add(dataItem.ToString());
                    }
                }
            }
        }
        public static void ImportGroupedData<TKey,TValue>(this Pdf.Table table, IEnumerable<Models.GroupViewModel<TKey, TValue>> groupedData)
        {
            var headRow = table.Rows.Add();           
            var props = typeof(TValue).GetProperties(BindingFlags.Public | BindingFlags.Instance);
            foreach (var prop in props)
            {
               headRow.Cells.Add(prop.GetCustomAttribute(typeof(DisplayAttribute)) is DisplayAttribute dd ? dd.Name : prop.Name);               
            }

            foreach (var group in groupedData)
            {
                // Add group row to table
                var row = table.Rows.Add();
                var cell = row.Cells.Add(group.Key.ToString());
                cell.ColSpan = props.Length;
                cell.BackgroundColor = Pdf.Color.DarkGray;
                cell.DefaultCellTextState.ForegroundColor = Pdf.Color.White;

                foreach (var item in group.Values)
                {
                    // Add data row to table
                    var dataRow = table.Rows.Add();
                    // Add cells
                    foreach (var t in props)
                    {
                        var dataItem = t.GetValue(item, null);

                        if (t.GetCustomAttribute(typeof(DataTypeAttribute)) is DataTypeAttribute dataType)
                            switch (dataType.DataType)
                            {
                                case DataType.Currency:
                                    dataRow.Cells.Add(string.Format("{0:C}", dataItem));
                                    break;
                                case DataType.Date:
                                    var dateTime = (DateTime)dataItem;
                                    if (t.GetCustomAttribute(typeof(DisplayFormatAttribute)) is DisplayFormatAttribute df)
                                    {
                                        dataRow.Cells.Add(string.IsNullOrEmpty(df.DataFormatString)
                                            ? dateTime.ToShortDateString()
                                            : string.Format(df.DataFormatString, dateTime));
                                    }
                                    break;
                                default:
                                    dataRow.Cells.Add(dataItem.ToString());
                                    break;
                            }
                        else
                        {
                            dataRow.Cells.Add(dataItem.ToString());
                        }
                    }
                }
            }
        }
    }

The Data Annotations attributes are often used to describe models and help us to create the table. Therefore, the following table generation algorithm was chosen for ImportEntityList:

lines 12-18: build a header row and add header cells according to the rule “If the DisplayAttribute is present, then take its value otherwise take the property name”
lines 50-53: build the data rows and add row cells according to the rule “If the attribute DataTypeAttribute is defined, then we check whether we need to make additional design settings for it, and otherwise just convert data to string and add to the cell;”

In this example, additional customizations were made for DataType.Currency (lines 32-34) and DataType.Date (lines 35-43), but you can add others if necessary. The algorithm of the ImportGroupedData method is almost the same as the previous one. An additional GroupViewModel class is used, to store the grouped data.

.using System.Collections.Generic;
    public class GroupViewModel<K,T>
    {
        public K Key;
        public IEnumerable<T> Values;
    }

Since we process groups, first we generate a line for the key value (lines 66-71), and after it - the lines of this group.