SharePoint

Print DataTable to PDF using Migradoc and PDFSHARP

2012-09-22T10:21:00.002-07:00

HOW TO PRINT A DATATABLE TO PDF FORM USING MIGRADOC AND PDFSHARP

I. INTRODUCTION
This post will detail out how to print a datatable in a PDF form using Migradoc and PDFSharp (http://www.pdfsharp.com/PDFsharp/). This functionality can be accomplished using a regular web application but since I was asked to do it in Sharepoint, the step by step implementation will be via a Sharepoint site collection. Special thanks to Mr. John Arrieta who is the original creator of this POC.

II. SCOPE
This post assumes that there is already an existing site collection created in Sharepoint 2010. The content of the datatable doesn’t come from an external data source and was just hard-coded for the purpose of presentation.

III. REQUIREMENTS
- Sharepoint 2010
- Visual Studio 2010
- Migradoc and PDF Assemblies (required DLLs)

IV. IMPLEMENTATION

1. Open Visual Studio and create an Empty Sharepoint Application. Input your Site Collection URL and click Finish. On my VM, the site collection URL is (http://valedevserver:3706)

2. Since we will be using third-party assemblies for the PDF printing, you have to download the required DLLs in (http://www.pdfsharp.com/PDFsharp/). In the Solution Explorer Toolbar, right-click on references and click on ‘Add Reference’. On the dialog box, add the assemblies needed.

3. We will create a class that will contain the methods to print our datatable. On the Solution Explorer Toolbar, right-click on ‘Add’ and then ‘New Item’. Create a new class. In my solution, I have named my class to be PDFform.cs.

4. Add the reference in the using section on the newly created class file. This class file handles the creation and formatting of the PDF.

using System.Data;
using MigraDoc.DocumentObjectModel.Tables;
using MigraDoc.DocumentObjectModel.Shapes;

5. Replace the contents of your class with the codes below.

class PDFform
{
  // The MigraDoc document that represents the invoice.
Document document;
DataTable dt;
string path;

    // The text frame of the MigraDoc document that contains the address.
TextFrame addressFrame;
/// The table of the MigraDoc document that contains the data
Table table;

// Initializes a new instance of the class and opens the specified datasource
public PDFform(DataTable dtIn, string pathIn)
{
dt = dtIn;
path = pathIn;
}
// Creates the document.
public Document CreateDocument()
{
  // Create a new MigraDoc document
this.document = new Document();
this.document.Info.Title = "";
this.document.Info.Subject = "";
this.document.Info.Author = "Aftab";
DefineStyles();
CreatePage();
FillContent();

return this.document;
}
// Defines the styles used to format the MigraDoc document.
void DefineStyles()
{
  // Get the predefined style Normal.
Style style = this.document.Styles["Normal"];
  // Because all styles are derived from Normal, the next line changes the
// font of the whole document. Or, more exactly, it changes the font of
// all styles and paragraphs that do not redefine the font.
style.Font.Name = "Verdana";
style = this.document.Styles[StyleNames.Header];
style.ParagraphFormat.AddTabStop("16cm", TabAlignment.Right);
style = this.document.Styles[StyleNames.Footer];
style.ParagraphFormat.AddTabStop("8cm", TabAlignment.Center);
// Create a new style called Table based on style Normal
style = this.document.Styles.AddStyle("Table", "Normal");
style.Font.Name = "Verdana";
style.Font.Name = "Times New Roman";
style.Font.Size = 9;
// Create a new style called Reference based on style Normal
style = this.document.Styles.AddStyle("Reference", "Normal");
style.ParagraphFormat.SpaceBefore = "5mm";
style.ParagraphFormat.SpaceAfter = "5mm";
style.ParagraphFormat.TabStops.AddTabStop("16cm", TabAlignment.Right);
}
// Creates the static parts of the invoice.
void CreatePage()
{
// Sets the PDF Page Orientation
this.document.DefaultPageSetup.Orientation = Orientation.Landscape;
// Each MigraDoc document needs at least one section.
Section section = this.document.AddSection();

// Put a logo in the header
Image image = section.AddImage(path);
image.Top = ShapePosition.Top;
image.Left = ShapePosition.Left;
image.WrapFormat.Style = WrapStyle.Through;
// Create footer
Paragraph paragraph = section.Footers.Primary.AddParagraph();
paragraph.AddText("This is the footer section");
paragraph.Format.Font.Size = 9;
paragraph.Format.Alignment = ParagraphAlignment.Center;
// Create the text frame for the address
this.addressFrame = section.AddTextFrame();
this.addressFrame.Height = "3.0cm";
this.addressFrame.Width = "7.0cm";
this.addressFrame.Left = ShapePosition.Left;
this.addressFrame.RelativeHorizontal = RelativeHorizontal.Margin;
this.addressFrame.Top = "5.0cm";
this.addressFrame.RelativeVertical = RelativeVertical.Page;
// Put sender in address frame
paragraph = this.addressFrame.AddParagraph("Karachi,Pakistan");
paragraph.Format.Font.Name = "Times New Roman";
paragraph.Format.Font.Size = 7;
paragraph.Format.SpaceAfter = 3;
// Add the print date field
paragraph = section.AddParagraph();
paragraph.Format.SpaceBefore = "6cm";
paragraph.Style = "Reference";
paragraph.AddFormattedText("Patients Detail", TextFormat.Bold);
paragraph.AddTab();
paragraph.AddText("Date, ");
paragraph.AddDateField("dd.MM.yyyy");
// Create the item table
this.table = section.AddTable();
this.table.Style = "Table";
this.table.Borders.Color = TableBorder;
this.table.Borders.Width = 0.25;
this.table.Borders.Left.Width = 0.5;
this.table.Borders.Right.Width = 0.5;
this.table.Rows.LeftIndent = 0;
// Before you can add a row, you must define the columns
Column column;
foreach (DataColumn col in dt.Columns)
{
column = this.table.AddColumn(Unit.FromCentimeter(3));
column.Format.Alignment = ParagraphAlignment.Center;
}
// Create the header of the table
Row row = table.AddRow();
row.HeadingFormat = true;
row.Format.Alignment = ParagraphAlignment.Center;
row.Format.Font.Bold = true;
row.Shading.Color = TableBlue;

for (int i = 0; i < dt.Columns.Count; i++)
{
row.Cells[i].AddParagraph(dt.Columns[i].ColumnName);
row.Cells[i].Format.Font.Bold = false;
row.Cells[i].Format.Alignment = ParagraphAlignment.Left;
row.Cells[i].VerticalAlignment = VerticalAlignment.Bottom;
}
this.table.SetEdge(0, 0, dt.Columns.Count, 1, Edge.Box, BorderStyle.Single, 0.75, Color.Empty);
}
// Creates the dynamic parts of the PDF
void FillContent()
{
  // Fill address in address text frame
Paragraph paragraph = this.addressFrame.AddParagraph();
paragraph.AddText("Dr. Anwar Ali");
paragraph.AddLineBreak();
paragraph.AddText("Health And Social Services ");
paragraph.AddLineBreak();
paragraph.AddText("Karachi");
Row newRow;
for (int i = 0; i < dt.Rows.Count; i++)
{
    // Format Cells and Display Records
newRow = this.table.AddRow();
newRow.TopPadding = 1.5;
for (int j = 0; j < dt.Columns.Count; j++)
{
newRow.Cells[j].Shading.Color = TableGray;
newRow.Cells[j].VerticalAlignment = VerticalAlignment.Center;
newRow.Cells[j].Format.Alignment = ParagraphAlignment.Left;
newRow.Cells[j].Format.FirstLineIndent = 1;
newRow.Cells[j].AddParagraph(dt.Rows[i][j].ToString());
this.table.SetEdge(0, this.table.Rows.Count - 2, dt.Columns.Count, 1, Edge.Box, BorderStyle.Single, 0.75);
}
}
}
// Some pre-defined colors
#if true
// RGB colors
readonly static Color TableBorder = new Color(81, 125, 192);
readonly static Color TableBlue = new Color(235, 240, 249);
readonly static Color TableGray = new Color(242, 242, 242);
#else
    // CMYK colors
readonly static Color tableBorder = Color.FromCmyk(100, 50, 0, 30);
readonly static Color tableBlue = Color.FromCmyk(0, 80, 50, 30);
readonly static Color tableGray = Color.FromCmyk(30, 0, 0, 0, 100);
#endif
}

5. For the next step, we will create a webpart that will serve as our User Interface for this function. Right-click on our Sharepoint solution and click on ‘New Item’ and then select ‘Visual Webpart’.

6. Create a Gridview on the User Control. This will contain our hard-coded datatable and a button that will trigger our PDF printing. Our user interface will look something like the one below.

6. On the source code of the created visual webpart, add javascript function that creates a new browser window to display the generated PDF. Set the OnClientClick event of the button to the javascript function.

<script type="text/javascript">
function PostToNewWindow() {
originalTarget = document.forms[0].target;
document.forms[0].target = '_blank';
window.setTimeout("document.forms[0].target=originalTarget;", 300);
return true;
}
</script>

<asp:Button ID="btnSaveViewPDF" runat="server" onclick="btnSaveViewPDF_Click"
Text="Save and View PDF" OnClientClick="return PostToNewWindow();" />

7. On the code-behind of the created visual webpart, add the following code on the PageLoad event and ButtonClick events. A script fix has been added on the PageLoad to handle viewing of PDF in a new browser window. ButtonClick event handles the creation of the PDF by calling the PDFform class created earlier and saves it in the 14th hive of Sharepoint, then renders the saved PDF document on a new browser window.

DataTable dt = new DataTable();

protected void Page_Load(object sender, EventArgs e)
{
  // Script Fix for Viewing PDF in a new browser window
ScriptManager.RegisterStartupScript(this.Page, this.GetType(),
"UpdatePanelFixup", "_spOriginalFormAction = document.forms[0].action; _spSuppressFormOnSubmitWrapper=true;", true);

// Sample Data
dt.Columns.Add("Column 1", typeof(string));
dt.Columns.Add("Column 2", typeof(string));
dt.Columns.Add("Column 3", typeof(string));
dt.Rows.Add("Data 1", "Data 2", "Data 3");
dt.Rows.Add("Data 1", "Data 2", "Data 3");
dt.Rows.Add("Data 1", "Data 2", "Data 3");

GridView1.DataSource = dt;
GridView1.DataBind();
}
protected void btnSaveViewPDF_Click(object sender, EventArgs e)
{
  // Create instance of PDFform class
PDFform pdfForm = new PDFform(dt, "ImageLogo");
  // Create a MigraDoc document
MigraDoc.DocumentObjectModel.Document document = pdfForm.CreateDocument();
document.UseCmykColor = true;
  // Create a renderer for PDF that uses Unicode font encoding
PdfDocumentRenderer pdfRenderer = new PdfDocumentRenderer(true);
  // Set the MigraDoc document
pdfRenderer.Document = document;
  // Create the PDF document
pdfRenderer.RenderDocument();
  // Save the PDF document...
string filename = "PDFReport1.pdf";
  //14 Hive Path
string spSetupPath = SPUtility.GetGenericSetupPath(string.Empty);
pdfRenderer.Save(spSetupPath + filename); ;
  // ...and start a viewer.
Response.Clear();
Response.ClearContent();
Response.ClearHeaders();
  //Set the appropriate ContentType.
Response.ContentType = "Application/pdf";
  //Get the physical path to the file.
Response.WriteFile(spSetupPath + filename);
Response.Flush();
Response.End();
}

8. On this step, the solution is now ready to be deployed in Sharepoint. Right-click on our Sharepoint solution and click on Deploy.

9. To consume our Visual webpart, Edit a page and insert a webpart. On the Categories section, Click on the Customs group. Add the custom webpart (VisualWebPart1) on the Sharepoint page.

10. Clicking the button will open a new browser window containing the generated PDF. Created PDF is located at the 14 hive.

[ERROR FIX:] The term ‘Add-SPSolution ’ is not recognized as the name of a cmdlet, function, script file, or operable program

2012-09-22T10:18:00.002-07:00

I. PROBLEM

For my today’s task, my onshore counterpart has given me a backup file (.bak) to restore on a new site collection. So I have decided to do a restore script in Powershell to accomplish this job. I was about to run my script in Powershell, when I came across this error. .

“The term ‘Add-SPSolution ’ is not recognized as the name of a cmdlet, function, script file, or operable program. Check the spelling of the name, or if a path was included, verify that the path is correct and try again.”

I thought that Powershell can automatically interpret Microsoft. Sharepoint.Powershell commands, but I was wrong.

II. SOLUTION

On top of your powershell script, add a code to reference Microsoft.Sharepoint.Powershell so it will be made available to Powershell ISE.
Add the line below at the start of your powershell script.

Add-PSSnapin Microsoft.Sharepoint.Powershell –EA 0

But for a long-term solution, so you do not have to constantly adding the above line every time you write a script, you may refer to the site below.

http://blogs.msdn.com/b/kaevans/archive/2011/11/14/add-microsoft-sharepoint-powershell-snap-in-to-all-powershell-windows.aspx

Customizing SharePoint Web Parts with Custom Properties

2012-05-14T01:46:00.000-07:00

Developers have the flexibility to create custom Web Parts to achieve sophisticated custom functionality in SharePoint Portal server. Typically this will be used to create common customized functionality for a specific organization or project. There are several properties available by default from SharePoint Portal server to customize the Web Part. Alternatively, developers can create their own custom properties to achieve extra customization on Web Part appearance and behavior.

Properties

The Web Part base class provides a set of default properties which allow users to change appearance and behavior. These properties are found in the default Web Part property pages and contain basic customization properties, such as height, width, frame set state and much more (as illustrated below).

Figure 1: Properties available by default in the "default" property pane.

TIP: To access the property pane, select the Edit mode of the Web Part. Then click the down arrow located at top right hand corner of the Web Part. Select "Modify Shared web part" (or personnel depend on witch mode the Web Part is running).

The properties are categorized according to their behavior and functionality, which provides a logical structure when you need to find the right item. According to Figure 1, all the properties that affect appearance are listed below the "Appearance" category and all the advanced options under the "Advanced" category.

While the default properties are a good starting point, it won't take long until you come across development requirements which the default properties cannot satisfy. This is where you implement Custom Properties to achieve the additional functionality or behavior required.

Custom Properties

A Custom Property is a property that a developer creates when they need to introduce additional functionality or behavior to the Web Part that is not provided by the base class.

The Visual Studio .Net environment supports the development of Web Parts for SharePoint Portal Server. The Web Part Template provided on MSDN (http://msdn.microsoft.com/library/default.asp?url=/library/en-us/odc_sp2003_ta/html/sharepoint_webparttemplates.asp) provides an excellent starting point with the structure of a custom Web Part property (example below).

///<summary>/// Default property available form the template///</summary>
[Browsable(true),
Category("Miscellaneous"),
DefaultValue(defaultText),
WebPartStorage(Storage.Personal),
FriendlyName("Text"),
Description("Text Property")]
publicstring Text
{
get
{
return text;
}
set
{
text = value;
}
}

Figure 2: Default custom property available from MSDN template.

Before we start developing any custom properties, let's have a look at how custom property works. The custom properties can be customized and saved in SharePoint as XML. The System.Xml.Serialization namespace is used to serialize the Custom Properties to XML. The above namespace will be available from System.Xml.dll assembly. There is a XML namespace attribute defined at the root level of the assembly as displayed below,

///<summary>/// Customize a web part/// </summary>
[DefaultProperty("Text"),ToolboxData("<{0}:CustomizedWebPart runat=server></{0}:CustomizedWebPart>"),
XmlRoot(Namespace="CustomizedWebPart")]

publicclass Customer : Microsoft.SharePoint.WebPartPages.WebPart

{

Figure 3: XML namespace in root level

The namespace attribute can be defined, either at the root level or at the property level. If a root level XML namespace is available, the developer doesn't need to assign XML namespaces at property level. But if the developer assigns a XML namespace at the property level, this will override the XML namespace assigned at the root level.

If you are using the template provided by MSDN, the System.Xml.dll will be automatically added to your reference in Web Part project as display below,

Figure 4: System.Xml.dll in Web Part project reference list

There are two parts to create a Custom Property:

1. Create property accessors

Each Custom Property of the Web Part requires the appropriate get and set accessors methods.

publicstring Text
{
get
{
return text;
}
set
{
text = value;
}
}

Figure 5: Get and Set accessors methods for a Web Part property in C#

2. Set Web Part Property attributes

Most attributes are members of the System.ComponentModel namespace. This namespace provides the classes that are used to implement the run time and design time behavior for Microsoft .NET components and controls. At the same time, there are properties like WebPartStorage attribute, which are specifically designed for Web Part properties. The attributes that you specify for the custom property will determine the behavior of the Web Part in the property pane and determine the storage for the custom property. Following is a list of attributes available and how they affect the behavior of the property.

Browsable
Determines whether or not the property is visible in the property pane or not. Setting this attribute to true will include the property.
Category
The property pane is divided into sections. This attribute determines the name of the section in the property pane where the custom property will be displayed. This allows the developer to categories their custom properties according to their logical functionality. If the developer does not specify this attribute or select "Default" as the category, the custom properties will display in Miscellaneous section of the property pane. At the same time, if you select one of the default categories, such as Appearance, Layout or Advanced, the category attribute setting will be ignored and the property will displayed in Miscellaneous section.
Default Value
This is the default value of the property. It will minimize the storage requirement by storing the property value only if it is different from the default value.
Description
Additional information regarding the property for the end-user. The description appears as the tool tip when the mouse hovers over the property.
FriendlyNameAttribute
This is the caption of the property when it is displayed in the property pages. If this attribute is omitted, the actual name of the property is used instead.
ReadOnly
The custom property will be read only if this is set to true.
WebPartStorage
There are three settings for this attribute.
- Storage.Shared: Display in property pane when the user is in shared view of the page.
- Storage.Personal: Displays when the user is in shared OR personal view of the page.
- Storage.None: Does not persist the setting of the property and will not display in the property pane.

Properties will display in different formats according to the property type. (as displayed below)

Property Type	Display as
Bool	Check box
DateTime	Text box
Enum Drop	down box
int / string	Text box

Download code here: 040218.zip

By Gayan Peiris

Developing custom field type for SharePoint 2010

2012-05-14T01:34:00.001-07:00

The ECM features of SharePoint 2010 are excellent. The best thing is the extendibility of the platform using SharePoint designer and Visual Studio. By default SharePoint includes field types such as Single line text, multi-line text etc. The following is the snapshot of the fields available in SharePoint 2010

The out of the box field controls are useful for most situations, but still you may need additional field types when building business applications. Fortunately you can build custom field controls using Visual Studio 2010 and deploy to SharePoint. Custom field control can provide a unique editing and display experience. Custom field controls can be used to include custom client-side validation and a unique editing experience.

In this article I am going to demonstrate how you can build custom field control for SharePoint 2010. For the purpose of this article, I am going to build a custom field control that inherits the single line of text. When displaying the control, it will show the entered text in <h1> tags. Also the field will convert the text to upper case while displaying. The custom field will throw error if it contains more than 10 characters. The examples looks simple, my intention is to show you how easily you can build custom controls. In real time you can add your business logic to build your own field controls.

Open Visual Studio, from the file menu select new project. In the new project dialog, select empty SharePoint project as the template. I have named the project as “MyCustomFieldProject”

In the SharePoint customization wizard, make sure you select “deploy as farm solution”. Also you can enter the local site URL where you can deploy the custom field.

Click the Finish button. Visual Studio will create an empty project. In Visual Studio solution explorer, the project looks as follows.

Now you need to add a class to the solution that represents the custom field. Now right click the project and select Add -> Class

I have named the class as “MyHeaderField”

The class just created have the following code.

Now you need to set the class as public. You need to include the using statement to include Microsoft.SharePoint to get access to the Sharepoint built in types. As I mentioned initially MyHeaderField needs to inherit the SharePoint Text field which is “SPFieldText”. Now you need to override the 2 default construtors. After making the mentioned changes, the code file looks as follows.

Now I am going to override 2 methods as follows.

GetValidatedString – This will be used to validate the data before saving to database.
GetFieldValueAsHtml – this is how the value will be displayed in the page.

The implementation of the methods are as follows.

Each field type you define should have a corresponding entry in the form of XML file in the XML folder under 14\Template folder. The XML file will have the following naming convention

It should start with fldtypes_
After _ you can define the field name. It is a good practice to specify the class name as the field name, though it is not a must
In the XML file, you need to define the fields such as TypeName, parent type name, type display name, corresponding class and assembly.

Now in the Visual Studio project, you need to add a XML file and while deploying it should be deployed to the folder 14\Template\XML. To do this, you can add a mapped folder to your project. Right click the project in solution explorer, select Add -> SharePoint mapped folder

In the Add mapped folder dialog, expand Template and select XML

Now you can see the XML folder under your project. Any files created here will be deployed to the 14\Template\XML folder in the SharePoint farm where the solution is deployed. Now you need to add the XML file for your field.

Right click the project, select Add -> New Item. Now in the template selection, select Data as the category and then select XML as the file type. I have named fldtypes_MyHeaderField.xml

I have updated the content of the XML file as follows. Be noted that $SharePoint.Project.AssemblyFullName$ will be replaced automatically by the correct assembly name wile deploying. All the other fields are self-explanatory.

Now we are done with all the requirements. From the solution explorer, right click the project and click deploy.

Once deployed, you can add new columns to SharePoint lists and libraries with the type “MyHeaderField”. Add the new column to SharePoint types will show the new type you added.

I have added a new column named “MyHeader” to my publishing page content type. Now when I try to add text to the column, it will validate it. See a simple validation

SharePoint 2010 is extensible as you can build and deploy custom fields that address your custom business requirements.

Original post by: K. G. Sreeju Nair