SharePoint 2010 provides some most useful Out of the box web parts. CQWP (Content By Query) web part is one of them. There are many articles around web explaining how to customize CQWP. However, apart from XSL customizations, many times we have support multilingual UI interface for the lables or the text being displayed on CQWP. There are different ways to achieve this, like having different language specific XSL templates. Having multiple templates is obiously great deployment and maintainance overhead. This article talks about extending out of the box SharePoint Content by query web part and enabling the localization in easy way. The localized lables will be picked from resx files as usual way. Hence adding new language is also extremely simple.

Extending and Localizing CQWP

For extending OOTB (Out of the box) CQWP you need to derive from ContentByQueryWebPart class localted under Microsoft.SharePoint.Publishing.WebControls namespace which is part of Microsoft.SharePoint.Publishing.dll assembly.

Once done, override ModifyXsltArgumentList. This function gets called before the xsl transformation is applied to the data returend by query to CQWP. Here, we will add one ExtensionObject named LocalizationHelper 

In this way, Localiztion of CQWP can be achieved by making use of Extenstion objects functionality of XSL templates.

Resource files are mainly used for localization of the custom solution.

While working with SharePoint 2010, many times the customizations need to be localized and hence, it means that developers have to play around the language specific resx files. Deployment of resx files through the SharePoint solution can be achieved using SharePoint mapped folder named "Resources". However the files those goes under this path can be accessed using SPUtility.GetLocalizedString function. Majority of the times, you may have customizations related to the user interface which are declarative. SharePoint 2010 is based on ASP.NET technology so for, any tags related to resources the resx files will be searched in App_GlobalResources folder located under intepub\wwroot\wss\<<application>> folder hierarchy.

This puts additional overhead of deployment to the developer who want to use the traditional ASP.NET way of localizing UI resources. As, we need to ensure that the resx files should be deployed under both 14 hive and App_GlobalResources folders.

There are multiple ways to deploy the resource files. Following are few of them

• Write an event handler to copy resx files
• Custom timer job
• PowerShell Script as a part of deployment
• Manual copy and so on....

But what about the solution uninstallations, upgrades and moreover if you have multi server environments, manual deplooyment of resx files is more tedious and erroneous.

SharePoint 2010 Projects supports feature called as "Elements". Using Elements we can deploy number of files at specific locations. Following solution makes use of Elements to deploy resx files to App_GlobalResources folder. Few advantages of this are as below

• No need to write custom code for deployment
• Resx files are packaged as a part of WSP
• No need to worry about upgrades and uninistallations its done automatically in SharePoint way
• Works perfectly on multi server enviornment
• No manual steps

 How to do it?

• Create new Empty SharePoint 2010 Project name it as ResxDeployment
• Choose a local site for debugging and, choose deployment type Deploy as farm solution

• In Solution Explorer, right click on ResxDeployment project and Add SharePoint Mapped Folder
• In Add SharePoint Mapped Folder dialog box, choose Resources and click OK

 
• In Solution Explorer, right click on ResxDeployment project and Add New Item
• Add few sample resx files to the Resources folder

• In Solution Explorer, right click on ResxDeployment project and Add New Item. Add Empty Element and name it as required for e.g. App_GlobalResources

• In Solution Explorer, click on Show All Files icon to view all files. Open SharePointProjectItem.spdata files located under App_GlobalResources node

• Add the relavent information to the xml file which includes Source, and Type of the file. The type should be set to AppGlobalResource and source should be a relative path of resx file. Following is the example

<?xml version="1.0" encoding="utf-8"?> 
<ProjectItem Type="Microsoft.VisualStudio.SharePoint.GenericElement" DefaultFile="Elements.xml" SupportedTrustLevels="All" SupportedDeploymentScopes="Web, Site, WebApplication, Farm, Package" xmlns="https://schemas.microsoft.com/VisualStudio/2010/SharePointTools/SharePointProjectItemModel"> 
 <Files> 
 <ProjectItemFile Source="Elements.xml" Target="App_GlobalResources\" Type="ElementManifest" /> 
 <ProjectItemFile Source="..\Resources\Contoso.resx" Type="AppGlobalResource"/> 
 <ProjectItemFile Source="..\Resources\Contoso.de-DE.resx" Type="AppGlobalResource"/> 
 <ProjectItemFile Source="..\Resources\Contoso.en-GB.resx" Type="AppGlobalResource"/> 
 <ProjectItemFile Source="..\Resources\Contoso.en-US.resx" Type="AppGlobalResource"/> 
 <ProjectItemFile Source="..\Resources\Contoso.es-ES.resx" Type="AppGlobalResource"/> 
 <ProjectItemFile Source="..\Resources\Contoso.it-IT.resx" Type="AppGlobalResource"/> 
 </Files> 
</ProjectItem> 

• In Solution Explorer, right click on ResxDeployment project and choose Deploy
• If everything goes well the solution will be deployed on given web application. Also, you can verify that the resx files are deployed under App_GlobalResources and 14\Resources folders

Points to be noted :

1. Resource files are deployed at two diffrent locations. You can directly add resx files to only elemets folder if needed.
2. There is no need to copy the files from Resources mapped folder to App_GlobalResources element folder in Visual studio. There is only one copy of resx file hence, no need to worry about multiple location changes
3. For every additional resx file, SharePointProjectItem.spdata file should be updated otherwise the file will not be copied to App_GlobalResources folder of web application
4. Please set the Scope of the Feature that includes this module as relavent. It is preferrable to set, Application Level Scoped

In this way, by using OOTB SharePoint features we can deploy resx files to App_GlobalResources folder.

Loading jQuery by putting it in a master page/page layouts additional header is one approach. But what if, multiple components are dependent on jQuery and its plugins? Also, they are individually registering their own script blocks?

In this case, we run in to lot of issues like

• jQuery getting registered multiple times
• Plugins are not loading properly
• JavaScript errors on page refresh
• and many more ...

To overcome this issue, we may prefer to use dynamic loading for these files. However, when dynamically loaded there should be some order of registration. Otherwise one may run in to multiple script related issues.

HTML Document supports different types of listeners and one of them is OnRedyStateChange function. Following script makes use of this function to ensure that the scripts are loaded in a right sequence one after another.

How to Use?

• Copy above code in one JS file
• Add the reference of this file in your HTML document
• Deploy required script files like, jQuery or related plugins. You can specify the path inside __dynamicJavaScriptsConfig array using src attribute
• Write ShouldLoad function to decide whether to load the given script. Specify this function to shouldLoad attribute of given script item
• Use _dynamicJavaScriptsOnLoadCompleteFunctionNames.push() function to register your own functions which should be called after successful loading of all scripts

I hope this helps!

Many time we come across the need of parsing XML document and creating entities. These entities are later passed between multiple methods, stored as configuration or used to perform some manipulation. Hand wrting code for parsing these entities from XML document is tedious. This article presents and easy way to parse XML documents and generating deserializers.

Hands on!

Lets create a sample XML document named Students.xml following is the sample content.

<xml version="1.0" encoding="utf-8" ?>
<Students>
  <Student>
    <RollNo>1</RollNo>
    <Name>Student 1</Name>
    <Address>Xyz Street</Address>
  </Student>
  <Student>
    <RollNo>2</RollNo>
    <Name>Student 2</Name>
    <Address>Xyz Street</Address>
  </Student>
  <Student>
    <RollNo>3</RollNo>
    <Name>Student 3</Name>
    <Address>Xyz Street</Address>
  </Student>
  <Student>
    <RollNo>4</RollNo>
    <Name>Student 4</Name>
    <Address>Xyz Street</Address>
  </Student>
  <Student>
    <RollNo>5</RollNo>
    <Name>Student 5</Name>
    <Address>Xyz Street</Address>
  </Student>
</Students>

Here, as we can see, there is one root node named <Students> and it contains <Student> nodes as children. Now, what if we need to create a list of students in our program and bind it to some grid? We have to write manual parsing code for achieving same. But, you can easily achieve this task using xsd.exe to generate de-serializer and get the student collection. Following are the steps

1. Start Visual Studio and open Student.xml 
2. Click on "XML" -> "Create Schema" on toolbar
   
   
   
   
3.  It will generate XML Schema. Following is the sample schema generated for Students.xml file
   
   <?xml version="1.0" encoding="utf-8"?>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="https://www.w3.org/2001/XMLSchema">
  <xs:element name="Students">
    <xs:complexType>
      <xs:sequence>
        <xs:element maxOccurs="unbounded" name="Student">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="RollNo" type="xs:unsignedByte" />
              <xs:element name="Name" type="xs:string" />
              <xs:element name="Address" type="xs:string" />
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>


4. Here we can observe the datatypes are automatically set as per the data available in Student.xml As per your need you can edit the schema and set the appropriate data types.
5. Save the Students.xml and Students.xsd files inside some folder say "C:\Sample\XML"
6. Now, we have to start "Visual Studio Command Prompt"
7. On VS Command Prompt, cd to "C:\Sample\XML" directory and type "xsd Students.xsd /c"
   
   
8. This will generate "Students.cs" file that we can use to de-serialize Student.xml file
9. Now create a "Console Application" named "XmlDeSerializer" we will use this to test the de-serialization
10. Add "Students.cs" file that we have created using xsd.exe file
    
    
11. Copy and paste following code in Program.cs file and run the program.
    

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Xml;
    using System.IO;
    using System.Xml.Serialization;
    
    namespace XmlDeSerializer
    {
        class Program
        {
            static void Main(string[] args)
            {
                using (FileStream xmlStream = new FileStream("C:\\Sample\\XML\\Students.xml", FileMode.Open))
                {
                    using (XmlReader xmlReader = XmlReader.Create(xmlStream))
                    {
                        XmlSerializer serializer = new XmlSerializer(typeof(Students));
                        Students deserializedStudents = serializer.Deserialize(xmlReader) as Students;
                        foreach (var student in deserializedStudents.Student)
                        {
                            Console.WriteLine("Roll No : {0}", student.RollNo);
                            Console.WriteLine("Name : {0}", student.Name);
                            Console.WriteLine("Address : {0}", student.Address);
                            Console.WriteLine("");
                        }
                    }
                }
            }
        }
    }
    
    

12. You will see following output

    

In this way we have successfully de-serialized Students.xml file and created entities. You May also serialize existing entites back in the xml format, we can use "Serialize" method of XmlSerializer.

I Hope this helps.

While working on SharePoint publishing portals, many times we require the automated publishing of contents. I am learning the "Poweshell". I thought of writing script that is having good options to choose from and, will automate the publishing of content over SharePoint sites. Following is the script that I have written. I hope it will help many people.

Features

• Non Recursive/Recursive for all root level webs and sub webs 
• Can Publish files with specific extension
• Can Publish folders
• Can Publish files from a specific sub web

this project is available on https://publishspcontent.codeplex.com/

How To?

Follow these simple steps to integrate jQuery with your SharePoint Site.

• Create a Blank Site ( I Prefered it. You can use any template you want)

• Download jQuery from https://docs.jquery.com/Downloading_jQuery
• Create folder of your choice inside ".<SharePoint Installation Path> \14\TEMPLATE\LAYOUTS"  say "CustomJScripts". Its not mandatory you may not choose to create it.
• Copy the jQuery script inside the folder we have recently created.

• Launch SharePoint designer and Open Sites main master page. By default SharePoint 2010 uses v4.master as sites default and custom master page.
• Right click on it and select "Edit in advanced mode"

• Add "ScriptLink" tag as shown below. "Do not put OnDemand="True" Tag. Otherwise jQuery will not be loaded by default.

• Save the master page.
• Check in an publish the master page. You will need to approve the page version also.
• Thats it. Now, you need to verify  jQuery is getting loaded when you are accessing your site.
• Open internet explorer and browse your site.
• Press F12 to bring up "Developer Tools" (You need to have IE8 for this functionality)
• Goto "Script" Tab and verify jQuery is getting loaded.

• To Perform a quick sanity test, go to script tab, in right side console window write something like, $("#MSO_ContentTable").css("background-color","cyan"); and press "Run Script"
• Verify the page background is changed to color "Cyan".

• Thats it! Now you can start using jQuery for client side scripting.

For adding your own custom scripts you can follow same steps i.e. adding script tag as described. Happy scripting :)