Updating an expired Client Secret of SharePoint Add-in

Updated with Azure-AD / AZ Cli here https://cann0nf0dder.wordpress.com/2019/11/25/updating-an-expired-client-secret-of-a-sharepoint-add-in-using-azure-ad-az-cli/ 

Been working with SharePoint Add-in tokens for a while now, but this week has been the first time I’m still working with an add-in longer than a year in one environment. My application start throwing the error message:

“Error:Token request failed., InnerMessage:System.Net.WebException: The remote server returned an error: (401) Unauthorized.”

I knew that they did expire after a year, but never really thought about (until now) how to go about renewing them. Luckily Microsoft documentation nowadays is a lot better than it used to be. I found this walk through https://msdn.microsoft.com/en-us/library/office/dn726681.aspx. In case Microsoft takes the link down, or changes the URL, I will explain the steps below. I have also changed the code slightly for the Report on Client ID expiry dates, as the Microsoft one didn’t return the results I expected.

Report on Client ID expiry dates.

• Open Windows Powershell and run the following cmdlet:

Connect-MsolService

• A login prompt will appear, here enter the tenant-administrator credentials for the Office 365 tenancy where the add-in was registered with AppRegNew.aspx

• You can generate a report that list each add-in in the tenant with the date that the secret expires with the following PowerShelll code.

  $applist = Get-MsolServicePrincipal -all  |Where-Object -FilterScript { ($_.DisplayName -notlike "*Microsoft*") -and ($_.DisplayName -notlike "autohost*") -and  ($_.ServicePrincipalNames -notlike "*localhost*") }
  $output = "";
  foreach ($appentry in $applist)
  {
      $principalId = $appentry.AppPrincipalId
      $principalName = $appentry.DisplayName
  
      $results =  Get-MsolServicePrincipalCredential -AppPrincipalId $principalId -ReturnKeyValues $false | Where-Object { ($_.Type -ne "Other") -and ($_.Type -ne "Asymmetric") }
      if($results.count -gt 0)
      {
           $output += "PrincipalId:`t$principalId`n"
           $output += "PrincipalName:`t$principalName`n"
           $output += "Keys`n" foreach($result in $results) { 
           $output += "Type:`t" + $result.Type + "`n" 
           $output += "Value:`t" + $result.Value + "`n" 
           $output += "KeyId:`t" + $result.KeyId + "`n" 
           $output += "StartDate:`t" + $result.StartDate + "`n" 
           $output += "EndDate:`t" + $result.EndDate + "`n" 
           $output += "Usage:`t" + $result.Usage+ "`n" $output += "`n"        
       } 
        $output += "-----------------------------------------------`n" } 
  } 
        $output | Out-File "c:\temp\appsec.txt" 
  

  • The above code first filters out Microsoft’s own applications, add-ins still under development (and a now-deprecated type of add-in that was called autohosted).
  • Filters out non-SharePoint add-ins and add-in like workflow.
• Open the file at c:\temp\appsec.text to see the report.

An example of the report below:

Note: The PrincipalID is your Client ID

Generate a new secret for another year.

To generate a new secret, you just need to run the following PowerShell script:

$clientId = <#Replace with your ClientID of the add-in>
$bytes = New-Object Byte[] 32
$rand = [System.Security.Cryptography.RandomNumberGenerator]::Create()
$rand.GetBytes($bytes)
$rand.Dispose()
$newClientSecret = [System.Convert]::ToBase64String($bytes)
New-MsolServicePrincipalCredential -AppPrincipalId $clientId -Type Symmetric -Usage Sign -Value $newClientSecret
New-MsolServicePrincipalCredential -AppPrincipalId $clientId -Type Symmetric -Usage Verify -Value $newClientSecret
New-MsolServicePrincipalCredential -AppPrincipalId $clientId -Type Password -Usage Verify -Value $newClientSecret
$newClientSecret

The output of the above PowerShell file will give you a new Client Secret, take note of this:

Generate a new secret for 3 years.

It is possible to create a secret that will last 3 years, the PowerShell script is very similar to the above script, but now it has a start and end date.

$clientId = <#Replace with your ClientID of the add-in>
$bytes = New-Object Byte[] 32
$rand = [System.Security.Cryptography.RandomNumberGenerator]::Create()
$rand.GetBytes($bytes)
$rand.Dispose()
$newClientSecret = [System.Convert]::ToBase64String($bytes)
$dtStart = [System.DateTime]::Now
$dtEnd = $dtStart.AddYears(3)
New-MsolServicePrincipalCredential -AppPrincipalId $clientId -Type Symmetric -Usage Sign -Value $newClientSecret -StartDate $dtStart -EndDate $dtEnd
New-MsolServicePrincipalCredential -AppPrincipalId $clientId -Type Symmetric -Usage Verify -Value $newClientSecret -StartDate $dtStart -EndDate $dtEnd
New-MsolServicePrincipalCredential -AppPrincipalId $clientId -Type Password -Usage Verify -Value $newClientSecret -StartDate $dtStart -EndDate $dtEnd
$newClientSecret

Updating the remote web application using the new secret

• If you are redeploying from Visual Studio you will need to update the client Secret in your Web.Config
• If you are just updating directly in Azure, you can just go to the configurations and update the new secret there.

If you are using the default TokenHelper.cs file in your project, and it’s not the prerelease version then you can add a second app setting called SecondaryClientSecret. Here you would put in your old secret, and in the ClientSecret put in the new one. This is so if your token is going to expire soon, the application will still work as it will try one first then the other.

Time to propagate Client Secret to SharePoint

According the Microsoft link you should wait at least 24 hours to propagate the ClientSecret. However, I found as soon as I changed the secret I could use it straight away. After changing your Client Secret if you run the ‘Report on Client ID expiry dates’ powershell again, those dates didn’t update for me until the following day.

I ran the report the following day, and as you can see below, Demo App 1 which was shown in the screen shot above now has 3 new keys with new dates.

Deleting expired client secrets

As expired client secrets do not seem to get removed, it is recommended to delete them. The code below will grab any keys that are expired for a ClientID and delete them.

$clientId = <#Replace with your ClientID of the add-in>;
$keys = Get-MsolServicePrincipalCredential -AppPrincipalId $clientId -ReturnKeyValues $false
$dtNow = [System.DateTime]::Now
foreach($key in $keys)
{
 if($key.EndDate -lt  $dtNow)
 {
   write-host $key.KeyId "Expired"
   Remove-MsolServicePrincipalCredential -KeyIds @($key.KeyId) -AppPrincipalId $clientId
 }
}

Using ITextSharp to create basic PDF page from item property

1. Setting up Word Automation Services for SharePoint 2013
   
2. Setting up PowerPoint Automation Services for SharePoint 2013
3. Converting a Library’s Word Documents to PDF
4. Converting a Library’s PowerPoint documents to PDF
   
5. Using ITextSharp to Merge PDF’s into one
6. Using ITextSharp to create basic PDF page from item property
   

This is the final post in this series, I’ve shown you how to set up Word and PowerPoint Automation, how to convert Word and PowerPoint to PDF, and in the last blog post I showed you how to merge all your pdf’s into one. This post is to demonstrate how to create a PDF page using ITextSharp. ITextSharp is a port of the iText open source java library for PDF generation written entirely in C# for the .NET platform. http://itextpdf.com. Please see my previous blog on how to add the itextsharp dll to the Visual Studio project.

In this demonstration, I will read in the first item of a list, and then copy all the visible columns by creating a table like structure which will be saved in my document library as a PDF file. The purpose of this post is to introduce to you what you can do with ITextSharp, there is plenty I don’t know about ITextSharp, and I’ve only learnt enough to solve my proof of concept I was doing for a client. If you are interested in ITextSharp, I’d recommend you look up books by Bruno Lowagie.

First, I have created a contact list, and added a single person to this list.

Continuing with my previous Visual Studio solution, I have added a new visual web part. It simply has a text box for the user to enter the list which it will take the first item from and convert to PDF in the Shared document library, and a button that will fire off the event to convert the item.

Below is the code and comments explaining what is happening at different stages of the code.

//Will require these using statements
using iTextSharp.text;
using itextSharp.text.pdf;

protected void btnlistItemToPDF_Click(object sender, EventArgs e)
{
  //Get Current Web context and get Document and user chosen list.
  var web = SPContext.Current.Web;
  SPList doclibrary = web.Lists.TryGetList("Documents");
  SPList list = web.Lists.TryGetList(txtList.text);
 
  //Check if lists are not null, then call code to convert.
  if(doclibrary == null || list == null)
  {
     ListItemToConvertoToPDF(list, doclibrary);
  }
}

private void ListItemToConvertoToPDF(SPList list, SPList doclibrary)
{
   if (list.ItemCount == 0)
        throw new Exception("Unfortunately there are not any items in your list to convert");
 
   Byte[] result = null;
   String returnString = "";

   //Perform Query to return 1 item.
   SPQuery query = new SPQuery();
   query.RowLimit = 1;
   query.ViewFields = list.DefaultView.ViewFields.SchemaXml;

   try
   {
      var collection = list.GetItems(query);
      SPListItem item = collection[0];

      //Get Title name, using default Guid for Title, to create a filename.
      var filename = item[new Guid("fa564e0f-0c70-4ab9-b863-0177e6ddd247")] + ".pdf";

      //Creating the Document in memory first.
      using(MemoryStream ms = new MemoryStream())
      {
       //Using the ItextSharp Document
         using(Document document = new Document())
         {
           //Using the ItextSharp PdfWriter to create an instance of the document using the memory stream.
           PdfWriter.GetInstance(document, ms).SetFullCompression();

           //Open the document otherwise you won't be able to add to it.
           document.Open();

           //Create a PDF table with Two Columns
           PdfPTable table = new PdfPTable(2);

           //Create the first Cell, make it span across 2 columns.
           PdfPCell cell = new PdfPCell(new Phrase("Contact Details"));
           cell.Colspan = 2;
           cell.HorizontalAlignment = 1; //0=Left, 1=Centre, 2=Right

           //Add the cell to the table.
           table.AddCell(cell);

           //Loop through all the fields in the collection.
           foreach (SPField f in collection.Fields)
           {
               //Obtain the value of the given field.
               var value = item[f.Id];
               //We are only showing if there is a value and the field/column isn't hidden.
               if (value != null && !f.Hidden)
               {
                  //Create a cell and just put the title of the column in it.
                  table.AddCell(f.Title);
                  //Depending on the type of file, depends how we want to add it to the pdf.
                  switch (f.TypeAsString)
                  {
                         //URL to display within the PDF as a URL.
                         case "URL":
                           //Get the field value as a SPFieldURLValue
                           SPFieldUrlValue urlV = new SPFieldUrlValue(value.ToString());
                           //create a new Cell.
                           cell = new PdfPCell();
                           //Use Chunk to add the text
                           var chunk = new Chunk(urlV.Description);
                           //A chunk can have an Anchor tag added to it.
                           chunk.SetAnchor(urlV.Url);
                           //add chunk to the cell.
                           cell.AddElement(chunk);
                           //add the cell to the table. Because this is the second cell added to the table, it is aware that it's the right cell.
                           table.AddCell(cell);
                           break;

                         //Date Time to display a valid date time format.
                         case "DateTime":
                           //Parse the date time to full date and time.
                           var dateV = DateTime.Parse(value.ToString()).ToString("R");
                           //add the cell to the table.
                           table.AddCell(dateV);
                           break;
 
                        //Default captures all other type of field types, numbers, text, etc.
                        default:
                           table.AddCell(value.ToString());
                           break;
                        }
                     }
                  }
                  //Add the table to the document and close the document.
                 document.Add(table);
                 document.Close();
              }
             //Convert the final memory stream into a byte array.
             result = ms.ToArray();
          }
 
          //Write file to document library
          SPFolder rootFolder = doclibrary.RootFolder;
          SPFile newFile = rootFolder.Files.Add(filename, result, true);
      }
      catch (Exception Ex)
      {
           Throw new Exception("Error trying to convert item to pdf. Message: " + Ex.Message);
      }
 }

Once the code is deployed, web part added to the page and ran, I get a pdf file named after the contact’s surname.

If I open the file, I have a table like structure within my PDF displaying all the columns I expected. I’m not going to win any awards for style, however check out the resource link at the bottom of this post to learn ways of jazzing up your tables.

Link to Sample code : OneDrive

 

Resources: http://www.mikesdotnetting.com/article/86/itextsharp-introducing-tables

Using ITextSharp to Merge PDF’s into one

1. Setting up Word Automation Services for SharePoint 2013
   
2. Setting up PowerPoint Automation Services for SharePoint 2013
3. Converting a Library’s Word Documents to PDF
4. Converting a Library’s PowerPoint documents to PDF
   
5. Using ITextSharp to Merge PDF’s into one
   
6. Using ITextSharp to create basic PDF page from item property

In the last couple of posts I’ve shown you how to convert Word and PowerPoint documents into PDF. In this post I’m going to show you how to use ITextSharp to merge your PDF’s together. iTextSharp is a port of the iText open source java library for PDF generation written entirely in C# for the .NET platform. http://itextpdf.com

Following on from my last Farm Solution, I have extended the solution by adding another button that when clicked, it looks up the document library and grabs all pdf files. Looping through each file, copies each pdf to a memory stream, once it have completely looped through each file, it then saves the file back to the SharePoint library. The advantage of using ITextSharp dll, is that you could create a provider hosted SharePoint App, and therefore create this merge functionality in Office 365. Unfortunately, I’m not showing you how to do this in this demo.

The Shared Document library for my site, I already have pdf’s files from my previous demos.

First thing we need to do is add the itextsharp to the Visual Studio project. With NuGet this is really simple. Right click your project and select Manage NuGet Packages…

This will open the Manage NuGet Packages dialog. Type in the Search Online Box for ITextSharp, the top result should be ITextSharp. Just click the Install button, and accept the License Acceptance.

This will add the itextsharp reference to your project. All that remains is to ensure that this dll is deployed to the GAC. Double Click on the Package.Package file in your project.

Select the Advanced tab. Then click the Add to add Existing assemblies. You will find the dll sitting in a package folder at the same location you find the .sln file for your solution. Navigate down through the folder to Packages\iTextSharp.5.5.4\lib\itextsharp.dll. Select the Deployment Target as GlobalAssemblyCache and the location is itextsharp.dll

Click OK.

Below is the code and comments explaining what is happening at different stages of the code.

//Will require these using statements
using iTextSharp.text;
using iTextSharp.text.pdf;

protected void btnPDFMerge_Click(object sender, EventArgs e)
{
  //Get current web context
   var web = SPContext.Current.Web;
   var list = web.Lists.TryGetList(libraryName.Text)
   if (list != null)
   {
       MergePdfs(list);
   }
 
 private void MergePdfs(SPList library)
{
  byte[] result = null;
  SPFolder merged = null;
  //Using helper method (explained further down, look for folder called Merged)
  if (!DoesFolderExist(library.RootFolder, "Merged"))
  {
     //Folder not found so create it.
     merged = library.RootFolder.SubFolders.Add("Merged");
     library.Update();
  }
  else
  {
    //Using helper method (explained further down, Get folder called Merged)
    merged = GetFolder(library.RootFolder, "Merged");
  }
    //CAML Query to return all pdf file types.
   SPQuery query = new SPQuery();

   //Include all subfolders so include Recursive Scope
   //TODO: Ignore Merged folder.
    query.ViewXml = @"<View Scope='Recursive'>
         <Query>
            <Where>
                <Contains>
                    <FieldRef Name='File_x0020_Type'/>
                    <Value Type='text'>pdf</Value>
                </Contains>
            </Where>
        </Query>
      </View>";

   //Get Documents
   SPListItemCollection listItems = library.GetItems(query);
   //Check that there are any documents to merge
   if (listItems.Count > 0)
   {
      //Perform the conversion in memory first
      using (MemoryStream ms = new MemoryStream())
      {
         //Using the ItextSharp Document
         using (Document document = new Document())
         {
           //Using the ITextSharp PdfCopy to create a PDF document in the memory stream
           using (PdfCopy copy = new PdfCopy(document, ms))
           {
             //Open the document before any changes can be made.
             document.Open();

             //Loop through each file
             foreach (SPListItem li in listItems)
             {
               // Convert the BinaryStream of the file to a ITexSharp PdfReader
               PdfReader reader = new PdfReader(li.File.OpenBinaryStream());
               int n = reader.NumberOfPages;
               //Loop through each page in the current PDF file
              for (int page = 0; page < n; )
              {
                 //Import the page to the PDF document in the memory stream.
                 copy.AddPage(copy.GetImportedPage(reader, ++page));
              }
             }
          }
       }

      //Convert the final memory stream into a byte array.
      result = ms.ToArray();
   }
    //Create a new file in the Merged folder called combined.pdf from the byte array.
    SPFile newFile = merged.Files.Add("combined.pdf", result, true);
  }
 }
}

I used a helper method to check if folder exists and another method to return the found folder. I have pinched this method and converted to work on an on-premise code from the OfficeDevPnP code. (I can’t take credit for this).

//Pass in folder and folder we are looking for.
private bool DoesFolderExist(SPFolder parentFolder, string folderName)
{
  //Check that foldername
  if(string.IsNullOrEmpty(folderName))
 {
    throw new ArgumentException("folderName");
 }
   
 //Get collection of the sub folders
 var folderCollection = parentFolder.SubFolders;
 //Call the worker code
 var exists = FolderExistsImplementation(folderCollection, folderName);

  return exists;
}

private bool FolderExistsImplementation(SPFolderCollection folderCollection, string folderName)
{
    //Validate inputs
    if(folderCollection == null)
    {
       throw new ArgumentNullException("folderCollection");
    }

    if(string.IsNullOrEmpty(folderName))
    {
       throw new ArgumentException("folderName");
    }

    //Loop each folder for the folderName
    foreach(SPFolder f in folderCollection)
    {
       if(f.Name.Equals(folderName, StringComparison.InvariantCultureIgnoreCase))
       {
         //If found return true
         return true;
       }
    }

   //not found return false
   return false;
 }
 
 //This code is almost identical to Does folder exist, except instead of return true/false it returns the folder or null.
//In fact these I could just use this method for both and check for null instead of true/false
private SPFolder GetFolder(SPFolder parentFolder, string folderName)
{
   if (string.IsNullOrEmpty(folderName))
   {
       throw new ArgumentException("folderName");
   }

   var folderCollection = parentFolder.SubFolders;
   var folder = GetFolderImplementation(folderCollection, folderName);
   return folder;
}

private SPFolder GetFolderImplementation(SPFolderCollection folderCollection, string folderName)
{
   if (folderCollection == null)
   {
      throw new ArgumentNullException("folderCollection");
   }
   if (string.IsNullOrEmpty(folderName))
   {
     throw new ArgumentException("folderName");
   }

   foreach (SPFolder f in folderCollection)
   {
      if (f.Name.Equals(folderName, StringComparison.InvariantCultureIgnoreCase))
      {
          return f;
      }
   }

  return null;
}

As you can see from my screen shot, I now have a document called combined.pdf sitting in my Merged folder inside my Shared Document library.

Link to Sample code : OneDrive

Converting a Library’s PowerPoint Documents to PDF using PowerPoint Automation Services for SharePoint 2013

1. Setting up Word Automation Services for SharePoint 2013
2. Setting up PowerPoint Automation Services for SharePoint 2013
3. Converting a Library’s Word Documents to PDF
4. Converting a Library’s PowerPoint documents to PDF
5. Using ITextSharp to Merge PDF’s into one
6. Using ITextSharp to create basic PDF page from item property

In my last post, I showed you how to convert a Word document to PDF. In this post I’m going to walk through the code that you can use to convert your PowerPoint document to PDF.

Following on from my last Farm Solution, I have extended the solution by adding another button that when clicked, it looks up the document library and grabs all the PowerPoint documents. Looping through each PowerPoint document it finds, it converts them to PDF and then saves them back to the same library. As before, there is no current way of performing this in Office 365.

The Shared Document library for my site, I have added two PowerPoint documents to my library.

Test 3 is a simple PowerPoint slide that has some text.

And the second PowerPoint document is a “Create an Office Mix” Template created in PowerPoint. As with my word demo, this is just so you can see pictures and layouts converted correctly.

Below is the code and comments explaining what is happening at different stages of the code.

//Will require this using statement
using Microsoft.Office.Server.PowerPoint.Conversion;

protected void btnPowerPointConverttoPDF_Click(object sender, EventArgs e)
{
   //Get current site context
   var site = SPContext.Current.Site;
   var list = web.Lists.TryGetList(libraryName.Text)
   if (list != null)
   {
       PowerPointDocsToConvertToPdf(list);
   }
}

 private void PowerPointDocsToConvertToPdf(SPList library)
 {
    //Perform a SPQuery that returns only PowerPoint Documents.
    SPQuery query = new SPQuery();
    query.Folder = library.RootFolder;

    //Include all subfolders so include Recursive Scope.
    query.ViewXml = @"<View Scope='Recursive'>
       <Query>
            <Where>
                <Or>
                   <Contains>
                     <FieldRef Name='File_x0020_Type'/>
                     <Value Type='Text'>ppt</Value>
                   </Contains>
                   <Contains>
                     <FieldRef Name='File_x0020_Type'/>
                     <Value Type='Text'>pptx</Value>
                   </Contains>
                </Or>
           </Where>
        </Query>
   </View>";

//Get Documents
SPListItemCollection listItems = library.GetItems(query);
//Check that there are any documents to convert.
if (listItems.Count > 0)
{
       foreach (SPListItem li in listItems)
       {
             try
             {
             //Perform the conversion in memory first
             using (MemoryStream destinationStream = new MemoryStream())
             {
                  //Create the conversion request, configure settings.
                 Microsoft.Office.Server.PowerPoint.Conversion.FixedFormatSettings settings = new Microsoft.Office.Server.PowerPoint.Conversion.FixedFormatSettings();
                 settings.BitmapUnembeddableFonts = true;
                 settings.FrameSlides = true;
                 settings.IncludeDocumentProperties = true;
                 settings.IncludeDocumentStructureTags = true;
                 settings.IncludeHiddenSlides = true;
                 settings.OptimizeForMinimumSize = true;
                 settings.UsePdfA = true;
                 settings.UseVerticalOrder = true;

                 //Perform conversion, opening stream, passing in settings and destination stream.
                 PdfRequest request = new PdfRequest(li.File.OpenBinaryStream(), ".pptx", settings, destinationStream);

                 //Send the request synchronusly, passing in null value for the callback parameter and caputring the response in result object.
                 IAsyncResult result = request.BeginConvert(SPServiceContext.GetContext(library.ParentWeb.Site), null, null);

                //Use the EndConvertMethod;
                request.EndConvert(result);

                //Add the converted file to the document library
                var fileName = Path.GetFileNameWithoutExtension(li.File.Name) + ".pdf";
                SPFile newFile = library.RootFolder.Files.Add(fileName, destinationStream, true);
            }
          }
          catch(Exception ex)
          {
            throw new Exception("Error processing PowerPoint to PDF " + ex.message);
          }
     }
  }
}

After typing in the Document Library name and clicking the button, the PowerPoint documents have been converted to PDF.

Link to Sample code : OneDrive

 

Converting a Library’s Word Documents to PDF using Word Automation Services for SharePoint 2013

1. Setting up Word Automation Services for SharePoint 2013
2. Setting up PowerPoint Automation Services for SharePoint 2013
3. Converting a Library’s Word Documents to PDF
4. Converting a Library’s PowerPoint documents to PDF
5. Using ITextSharp to Merge PDF’s into one
6. Using ITextSharp to create basic PDF page from item property

In my previous posts, I showed you how to set up your environment so that you could perform Word or PowerPoint conversion to PDF. In this post I’m going to walk through the code that you can use to convert your word document to PDF.

Back in SharePoint 2010, when you converted a Word Document to PDF you created a Conversion Job, this was to accommodate bulk file operation scenarios. The job was placed in a queue within the Word Automation Services and ran by a SharePoint Timer Job. Due to it being ran on a SharePoint Timer Job, there wasn’t a simple way of determine when a conversion had completed. Developers who wanted to perform a conversion synchronously, and get a response if the file conversion was successful or not just couldn’t. Part of the SharePoint 2013 version of Word Automation Services, you can now call the Word Automation Services on demand. Meaning you can now perform synchronous file conversions. If you wish to perform Asynchronous Word to PDF conversion, there is a MSDN walkthrough article how you might achieve this. https://msdn.microsoft.com/en-us/library/office/ff181518(v=office.14).aspx

I have put together a simple Farm Solution that although it is performing a bulk conversion of Word Documents to PDF, it does it synchronously. There is currently no possible way of doing this process within Office 365, well not without using an on premise farm to perform the actual conversion for you.

I have built a simple visual web part (maybe in a real world scenario this might be a button on the ribbon of the library, or you perform a event receiver on the list that converts any word document to pdf), that has textbox for a user to enter the document library they wish to convert Word Documents to PDF, and a button. The button click calls then looks up the document library, grab all word documents then loops through each word document converting to PDF and then save it back to the same library.

The Shared Document library for my site, I have added two word documents to my library.

One is a simple test document that says “hello you”.

And a second document that is actually an “Event Flyer” Template created in Microsoft Word, and edited slightly. This is just so that you can see pictures and layouts conversion too.

Below is the code and comments explaining what is happening at different stages of the code.

//Will require this using statement
using Microsoft.Office.Word.Server.Conversions;

//This is the name of your Word Automation Service within Central Admin. If you have followed my setup yours will be called WAS too.
public static string WORD_AUTOMATION_SERVICE = "WAS";

//Click handler
protected void btnWordConvertToPDF_Click(object sender, EventArgs e)
{
  //Get current site context         
  var web = SPContext.Current.Web;
  var list = web.Lists.TryGetList(libraryName);

 if(list != null)
 {
    WordDocsToConvertToPdf(list);
 }
} 

private void WordDocsToConvertToPdf(SPList library)
{
   //Perform a SPQuery that returns only Word Documents.
   SPQuery query = new SPQuery();
   query.Folder = library.RootFolder;
   //Include all subfolders so include Recursive Scope.
    query.ViewXml = @"<View Scope='Recursive'>
                                <Query>
                                   <Where>
                                        <Or>
                                            <Contains>
                                                <FieldRef Name='File_x0020_Type'/>
                                                <Value Type='Text'>doc</Value>
                                            </Contains>
                                            <Contains>
                                                <FieldRef Name='File_x0020_Type'/>
                                                <Value Type='Text'>docx</Value>
                                            </Contains>
                                        </Or>
                                    </Where>
                                </Query>
                            </View>"; 

  //Get Documents
  SPListItemCollection listItems = library.GetItems(query);

  //Check that there are any documents to convert.
            if (listItems.Count > 0)
            {
                foreach (SPListItem li in listItems)
                {
                    //Perform the conversion in memory first, therefore we require a MemoryStream.
                    using (MemoryStream destinationStream = new MemoryStream())
                    {
                        //Call the syncConverter class, passing in the name of the Word Automation Service for your Farm.
                        SyncConverter sc = new SyncConverter(WORD_AUTOMATION_SERVICE);
                        //Pass in your User Token or credentials under which this conversion job is executed.
                        sc.UserToken = SPContext.Current.Site.UserToken;
                        sc.Settings.UpdateFields = true;

                        //Save format
                        sc.Settings.OutputFormat = SaveFormat.PDF; 

                        //Convert to PDF by opening the file stream, and then converting to the destination memory stream.
                        ConversionItemInfo info = sc.Convert(li.File.OpenBinaryStream(), destinationStream);

                        var filename = Path.GetFileNameWithoutExtension(li.File.Name) + ".pdf";
                        if (info.Succeeded)
                        {
                            //File conversion successful, then add the memory stream to the SharePoint list.
                            SPFile newfile = library.RootFolder.Files.Add(filename, destinationStream, true);
                        }
                        else if (info.Failed)
                        {
                            throw new Exception(info.ErrorMessage);
                        }
                     }
                }
            }
        }

After typing in the Document library name and clicking the button, the word document have been converted to PDF.

 

When building this demo, I did discover that if you have your Active Directory on the same box as your SharePoint then Word Automation Service will throw an error message as you try to convert documents, saying that:

“The file could not be converted; it may be corrupt or otherwise invalid (the conversion process failed). Please try opening the file in Microsoft Word, resaving it, and then resubmitting the file for conversion. If this does not resolve the issue, contact your system administrator.”

So firstly, I’m sorry to any developers out there that have used my earlier blogs to build themselves a Single SharePoint 2013 server farm. And secondly thank you to Karsten Pohnke who blog post confirmed why I was getting the error message. http://www.ilikesharepoint.de/2014/07/sharepoint-word-automation-service-does-not-work-file-may-be-corrupted/

Link to Sample code : OneDrive

Setting up PowerPoint Automation Services for SharePoint 2013

1. Setting up Word Automation Services for SharePoint 2013
2. Setting up PowerPoint Automation Services for SharePoint 2013
3. Converting a Library’s Word Documents to PDF
4. Converting a Library’s PowerPoint documents to PDF
5. Using ITextSharp to Merge PDF’s into one
6. Using ITextSharp to create basic PDF page from item property

Microsoft PowerPoint Automation Services is a new feature of Microsoft SharePoint Server 2013. Using PowerPoint Automation Services, you can convert PowerPoint (.pptx and .ppt) file to supported document formats (.pptx, .pdf, .xps, .jpg and .png).This blog post will walk you through the steps of setting up your SharePoint 2013 on premise farm to use PowerPoint Automation Services. Unlike with Word Automation Services, this cannot be configured from inside Central Admin.

To create this service PowerShell must be used. This feature is not available with SharePoint Online.Before you start, ensure in your AD you have created a service account. Mine is called PowerPointAutomation.

1. Open up a PowerShell command window or PowerShell ISE.
2. First we need to create the Managed Account in SharePoint. This can either be done by directly in SharePoint Central Admin by registering a new Managed Account https://<CentralAdminUrl>/_admin/ManagedAccounts.aspx
   
   Or we can do it with PowerShell

   add-pssnapin Microsoft.SharePoint.Powershell
   
   $cred = Get-Credential
   New-SPManagedAccount -Credential $cred
   

   When run, this will display a Credential box, put in here your Service account and password

   

   Your Managed Account will now be registered with SharePoint.

3. Now we can run the following script to create the PowerPoint Automation Service and Proxy. (Remember to change your service account)

   add-pssnapin Microsoft.SharePoint.Powershell
   
   #Create a new Service Application Pool Account
   New-SPServiceApplicationPool -Name "PowerPointAutomationAppPool" -Account cc\PowerPointAutomation
   #Get the Service Application pool
   $pool = Get-SPServiceApplicationPool | where {$_.Name -like "PowerPointAuto*"}
   #Create the PowerPoint Conversion Service
   $ppt = New-SPPowerPointConversionServiceApplication "PowerPoint Conversion Service" -ApplicationPool $pool
   #Create the Proxy for Service
   New-SPPowerPointConversionServiceApplicationProxy "PowerPoint Conversion Service Proxy" -ServiceApplication $ppt –AddToDefaultGroup
   

   Once complete your powershell window should look similar to mine below.

   

   Also if you navigate in Central Administration back to your Service Applications, you will now see the PowerPoint Conversion Service Application and Proxy within the list.
   

4. For the PowerPoint Conversion Service to work, you will need create a new folder called PowerPointConversion on the server running the PowerPoint Conversion Service in the following location. C:\ProgramData\Microsoft\SharePoint. This folder directory is a hidden folder and you will need to show Hidden items in the ribbon of explorer to see it.
   
   
   
5. Once you have created this folder, view the security on this folder (Right click folder, click Properties, view the Security Tab) and give WSS_WPG Modify permissions. This will allow the Web Application pool service account to create folders and files within the newly created PowerPointConversion folder, which is required to convert a PowerPoint document.
6. Lastly in Central Administration, under system Settings click on Manage Services on Server, and ensure that you have started PowerPoint Conversion Service.

In Part 4 of these blog posts I will demo how to code against the PowerPoint Automation Services to convert PowerPoint Documents to PDF.

Setting up Word Automation Service for SharePoint 2013

1. Setting up Word Automation Services for SharePoint 2013
2. Setting up PowerPoint Automation Services for SharePoint 2013
3. Converting a Library’s Word Documents to PDF
4. Converting a Library’s PowerPoint documents to PDF
5. Using ITextSharp to Merge PDF’s into one
6. Using ITextSharp to create basic PDF page from item property

Word Automation Services for SharePoint 2013 is a SharePoint Service Application and it gives developers a way to perform server-side conversion of documents that are supported by Microsoft Word. This service was available in SharePoint 2010, however the newer version now allows on demand file conversions and converting streams to files. (Steams with Word Automation Service can only be used with on demand conversions, not Timer job-based requests.

This blog post will walk you through the steps of setting up your SharePoint 2013 on premise farm to use Word Automation Services. This feature is not available with SharePoint Online.

Before you start, ensure in your AD you have created a service account. Mine is called WordAutomation.

1. Open Central Administration
2. Under Application Management > Service Applications select Manage service applications
   
   
3. In the ribbon bar area, click New > Word Automation Services
   
   
4. On the Create New Word Automation Services Application dialog. Fill in:
   a. Name: WAS
   b. Create New Application pool: WASAppPool
   c. Security Account for Application Pool – Configurable: [Domain]\WordAutomation
       (Note: You might have to Register your new Managed account first, before it shows up in your Configurable Drop down list)
   d. Add to Default Proxy List: Tick
   
5. Click Next
   
6. On the next screen enter:
   a. Database Server: [SQL Server]
   b. Database Name: WASDatabase
   
7. Click Finish
   
8. Once created your Word Automation Services and Proxy will be displayed in the Service Applications list.

When you click WAS link you will be taken through to the configuration of the Word Automation Services. You will not need to change any of this to start using the Word Automation Services, however it is useful looking over these settings in case you need to change them in the future.

 

• Lastly, in Central Administration, under System Settings, click on Services on Server, and ensure that you have Started the Word Automation Services.
  

 

In Part 3 of these blog posts I will demo how to code against the Word Automation Services to convert Word Documents to PDF.

Merging JavaScript using JQuery extend

In a previous blog, I showed how to use a configuration page that attaches a Site Column to a Managed Metadata TermSet. This was done using JavaScript. With SharePoint Online and sandbox solutions, if you are unable to configure SharePoint using declarative XML, the only option you have left (apart from manually point and clicking after deployment) is using JavaScript.

In all the Sandbox solutions I have created there is always a core.wsp file that has a bunch of configuration. Recently I created an additional wsp that on first load I needed to run the same configuration scripts, however the configuration data needed to be different. For example, different quick launch navigation, different branding, different logo at the top left of the screen. This was a perfect scenario for using the JQuery extend to merge the JavaScript files together.

The demo today won’t actually show you any configuration code, however it will show you two solutions. The first solution, will display JavaScript on a page. This JavaScript is a copy of the main JavaScript configuration. After uploading the second solution the second JavaScript configuration will be merged with the first and displayed on the page. This is all done using the following code

if (CF.SharePoint.CoreSiteConfiguration.Data != null) {
    jQuery.extend(CF.SharePoint.CoreSiteConfiguration.Data, CF.SharePoint.SiteConfiguration.Data);
};

Before I start walking through the solution, I want to thank Pumbaa80 on StackOverflow who provided me with the syntaxHighlight(json) function which allowed me to display JavaScript within a webpage prettified.

 

Solution 1 MergingJavascript.wsp

All the files from the first solution can be seen above. I’m just using JQuery library. The configuration data is in a file called CF.SharePoint.CoreSiteConfiguration.js and looks like below:

var CF = CF || {};
CF.SharePoint = CF.SharePoint || {};
CF.SharePoint.CoreSiteConfiguration = CF.SharePoint.CoreSiteConfiguration || {};
 
CF.SharePoint.CoreSiteConfiguration.Data = {
    Branding: {
        ColorPaletteUrl: "/_catalogs/theme/15/CF.spcolor",
        FontSchemeUrl: null,
        MasterPageUrl: "/_catalogs/masterpage/CF/CF.master",
        CustomMasterPageUrl: "/_catalogs/masterpage/CF/CF.master",
        BackgroundImageUrl: null
    },
    TaxonomyFields: [
        { Id: '{F5F171D8-47C7-4698-8B28-78A86A95A2E8}', Name: 'CF_TaxCountries' },
        { Id: '{C03CC67A-4E66-4723-9D0F-3D7CB117DA0C}', Name: 'CF_TaxNavigation' },
    ],

    ContentTypeBindings: [
        { ContentTypeId: "0x0101003C7036AFEEB24CFC95926C7E222CE2BC", ContentTypeName: "CF Document", ListTitle: "Documents", ListUrl: "Shared Documents" }
    ],

    DefaultContentTypes: [
        { ContentTypeId: "0x0101003C7036AFEEB24CFC95926C7E222CE2BC", ContentTypeName: "CF Document", ListTitle: "Documents", ListUrl: "Shared Documents" }
    ],

    RequiredSharePointJSFiles: [
        "sp.js",
        "sp.ui.dialog.js",
        "sp.taxonomy.js",
        "sp.publishing.js"
    ]
};

I’ve declared a namespace at the top of the JavaScript file, then it’s just a bunch of objects declared within CF.SharePoint.CoreSiteConfiguration.Data.

I upload jQuery and my configuration.js file to a folder called Assets at the site collection. You can see in my solution, I have a Module called MO_Assets and a folder called Scripts. The elements file for this Module is as follows:

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <Module Name="Assets">
    <File Path="MO_Assets\Scripts\jquery-2.1.1.min.map" Url="Assets/Scripts/jquery-2.1.1.min.map" ReplaceContent="TRUE" />
    <File Path="MO_Assets\Scripts\jquery-2.1.1.min.js" Url="Assets/Scripts/jquery-2.1.1.min.js" ReplaceContent="TRUE" />
    <File Path="MO_Assets\Scripts\CF.SharePoint.CoreSiteConfiguration.js" Url="Assets/Scripts/CF.SharePoint.CoreSiteConfiguration.js" ReplaceContent="TRUE"/>
  </Module>
</Elements>

 

This JavaScript is inserted into my page using a Custom Action CA_JavascriptConfiguration.
Take note: JQuery is Sequence 10, the CoreSiteConfiguraiton.js is inserted as Sequence 11.

<?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <CustomAction ScriptSrc="~SiteCollection/assets/Scripts/jquery-2.1.1.min.js"
              Location="ScriptLink"
              Sequence="10">
  </CustomAction>
  <CustomAction ScriptSrc="~SiteCollection/assets/Scripts/CF.SharePoint.CoreSiteConfiguration.js"
                                Location="ScriptLink"
                                Sequence="11">
  </CustomAction>
</Elements>

Lastly I have an aspx page that will display the JavaScript. This page is just a standard SharePoint aspx page you might write.

<%@ Assembly Name="Microsoft.SharePoint, Version=15.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Import Namespace="Microsoft.SharePoint.WebPartPages" %>
<%@ Register TagPrefix="SharePoint" Namespace="Microsoft.SharePoint.WebControls" Assembly="Microsoft.SharePoint, Version=15.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register TagPrefix="Utilities" Namespace="Microsoft.SharePoint.Utilities" Assembly="Microsoft.SharePoint, Version=15.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Import Namespace="Microsoft.SharePoint" %>
<%@ Assembly Name="Microsoft.Web.CommandUI, Version=15.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register TagPrefix="WebPartPages" Namespace="Microsoft.SharePoint.WebPartPages" Assembly="Microsoft.SharePoint, Version=15.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Page Language="C#" MasterPageFile="~masterurl/default.master" Inherits="Microsoft.SharePoint.WebPartPages.WebPartPage,Microsoft.SharePoint,Version=15.0.0.0,Culture=neutral,PublicKeyToken=71e9bce111e9429c" EnableViewState="false" meta:webpartpageexpansion="full" meta:progid="SharePoint.WebPartPage.Document" %>
 
<asp:Content ID="Content1" ContentPlaceHolderID="PlaceHolderAdditionalPageHead" runat="server" >
</asp:Content>
 
<asp:Content ID="Content2" ContentPlaceHolderID="PlaceHolderPageTitleInTitleArea" runat="server">
               Display JavaScript Page
</asp:Content>
 
<asp:Content ID="Content3" ContentPlaceHolderID="PlaceHolderSearchArea" runat="server" />
 
<asp:Content ID="Content4" ContentPlaceHolderID="PlaceHolderMain" runat="server">
                <SharePoint:FormDigest ID="FormDigest1" runat="server"/>
</asp:Content>

Within the PlaceHolderMain after the FormDigest1 we add a <pre> box to display the code.

<pre id="DisplayText"></pre>

Within the PlaceHolderAdditionalPageHead we will add the CSS and the Javascript that will get the ConfigurationData, then Stringify it, then lastly syntax highlight it to prettify it for the demo, before adding it to the <pre> html tag ID “DisplayText”. Note: If the JavaScript within this page was the actual configuration functions, it would probably be in a separate file, then added to the page using a Custom Action. This custom action sequence would need to be higher that the JQuery and the Configuration data we added earlier. Ideally, it should be a few sequence’s lower, so that you can add more JavaScript files before your configuration code if needed. In this case, because it is on the page, it is ran after the custom actions anyway.

<style type="text/css">
        #DisplayText {outline: 1px solid #ccc; padding: 5px; margin: 5px; }
        .string { color: green; }
        .number { color: darkorange; }
        .boolean { color: blue; }
        .null { color: magenta; }
        .key { color: red; }
    </style>

 

<script type="text/javascript">
        function syntaxHighlight(json) {
            json = json.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
            return json.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, function (match) {
                var cls = 'number';
                if (/^"/.test(match)) {
                    if (/:$/.test(match)) {
                        cls = 'key';
                    } else {
                        cls = 'string';
                    }
                } else if (/true|false/.test(match)) {
                    cls = 'boolean';
                } else if (/null/.test(match)) {
                    cls = 'null';
                }

                return '<span class="' + cls + '">' + match + '</span>';
            });
        }
               

        function loadFunction() {
            var str = JSON.stringify(CF.SharePoint.CoreSiteConfiguration.Data, undefined, 4);
            jQuery("#DisplayText").append(syntaxHighlight(str));
        };

        _spBodyOnLoadFunctionNames.push("loadFunction");
    </script>

The Page module has an elements file, here I’m just adding the DisplayJavascript.aspx to the web file which will only show up in the RootWeb.

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <Module Name="MO_Pages" Path="MO_Pages" RootWebOnly="TRUE">
    <File Path="DisplayJavascript.aspx" Url="DisplayJavascript.aspx" Type="Ghostable" ReplaceContent="TRUE" />
  </Module>
</Elements>

 

After adding the Module, Custom action and the Page to the Web Feature, we can package up the WSP and deploy to our teamsite. Activate the Web Feature, mine is called CFSP Merging JavaScript. Then navigate to your site [sitecollection]/DisplayJavascript.aspx.

Solution 2 AdditionalJavaScript.

Ok, so we have the basic configuration in place. This would be the JavaScript objects that would be used during configuration. However in a second web site, we still want the Core solution to be installed, but when we configure we want the configuration script to use a different/merged set of JavaScript objects. This demo solution is made of up just the new JavaScript objects and a custom action. Below is the solution structure.

The Module MO_SiteConfigurationFile has a JavaScript file which is added to the same Assets library of the original Site Configuration data file. This file doesn’t overwrite the Site Configuration, it is just added to the folder.

var CF = CF || {};
CF.SharePoint = CF.SharePoint || {};
CF.SharePoint.SiteConfiguration = CF.SharePoint.SiteConfiguartion || {};
 
CF.SharePoint.SiteConfiguration.Data = {
    Branding: {
       ColorPaletteUrl: "/_catalogs/theme/15/CF.orange.spcolor",
       FontSchemeUrl: "/_catalogs/theme/15/CF.spfont",
       MasterPageUrl: "/_catalogs/masterpage/CF/CFWithLeftNav.master",
       CustomMasterPageUrl: "/_catalogs/masterpage/CF/CFWithLeftNav.master",
       BackgroundImageUrl: null
   },

    NonPublishingNavigation: {
        QuickLaunchNavigation: {
            List: [
                { Title: 'Home', Url: '/' },
                { Title: 'Notebook', Url: '/SiteAssets/$WebTitle Notebook' },
                { Title: 'Documents', Url: '/Documents/Forms/AllItems.aspx' },
                { Title: 'Calendar', Url: '/Lists/Calendar/calendar.aspx' },
                { Title: 'Tasks', Url: '/Lists/Tasks/AllItems.aspx' },
                { Title: 'Site Contents', Url: '/_layouts/15/viewlsts.aspx' }
            ],
            KeepRecent: false
        }
    },

    RequiredSharePointJSFiles: [
        "sp.js",
        "sp.ui.dialog.js",
        "sp.taxonomy.js",
        "sp.publishing.js",
        "sp.userprofiles.js"
    ]    
}
 

//Merge new and updated objects over existing objects.
if (CF.SharePoint.CoreSiteConfiguration.Data != null) {
    jQuery.extend(CF.SharePoint.CoreSiteConfiguration.Data, CF.SharePoint.SiteConfiguration.Data);
};

You will notice that I’m using a different namespace. CF.SharePoint.SiteConfiguration, where the configuration data file of the core solution was CF.SharePoint.CoreSiteConfiguration. The Branding is different, I’m using a different colour file, different master pages too. I’m not making any changes to the original Taxonomy Fields, Content Type Bindings, or Default Content Types. I have added configuration for the Quick Launch Navigation, and the RequiredSharePointJSFiles has an extra value “sp.userprofiles.js”. Note: When you are merging the files, an object structure needs to be copied over as a whole, and any values that are to remain the same need to be included in the new file. Otherwise it will assume this value is replace everything.

For example the RequiredSharePointJSFiles.

If in my new configuration data file I just put:

RequiredSharePointJSFiles: [
        "sp.userprofiles.js"
    ]    

When merged, only that value would be remaining, it merges at the top object level (Branding, TaxonomyFields, ContentTypeBindings, DefautlContentTypes, NonPublishingNavigation, RequiredSharePointJSFiles). Therefore to ensure all the original values are there including your new ones, you need to include everything you want to keep at that top level too.

RequiredSharePointJSFiles: [
        "sp.js",
        "sp.ui.dialog.js",
        "sp.taxonomy.js",
        "sp.publishing.js",
        "sp.userprofiles.js"
    ]    

Lastly at the bottom of this file, we are checking if the original CoreSiteConfiguraiton exist, and if so Merge CF.SharePoint.SiteConfiguration.Data into CF.SharePoint.CoreSiteConfiguration.Data, using the jQuery.extend function. The merge is happening at the .Data level.

The element file for the SiteConfigurationFile module as stated earlier is added to the same asset folder we added our JavaScripts file to in the first solution.

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/"&gt;
<Module Name="MO_SiteConfigurationFile">
<File Path="MO_SiteConfigurationFile\CF.SharePoint.Configuration.Data.js" Url="Assets/Scripts/CF.SharePoint.Configuration.Data.js" ReplaceContent="TRUE"/>
</Module>
</Elements>

The custom action inserts this JavaScript into the page. Note: The Sequence number for CF.SharePoint.Configuration.Data.js is higher in value than CF.SharePoint.SiteConfiguration.Data.js meaning it is loaded after the CF.SharePoint.SiteConfiguration.Data.js file. As stated earlier this sequence number needs to be a higher value than the original configuration data script file, but lower than the actual configuration script. In our case, our configuration script is on the page, meaning it will be loaded last.

<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <CustomAction
        ScriptSrc="~SiteCollection/assets/Scripts/CF.SharePoint.Configuration.Data.js?version=1.0.0.0"
        Location="ScriptLink"
        Sequence="12">
  </CustomAction>
</Elements>

Add both these modules to the solutions web feature. My feature title is called CFSP.AdditionalJavaScript. Package up your solution and then deploy to your site where your original solution already is.

Activate the web feature, then navigate back to the page located at [sitecollection]/DisplayJavascript.aspx.

You can now see that file files have truly been merged together. We never touched the original JavaScript code on the DisplayJavaScript.aspx page, but yet the file that had a different namespace is clearly merged in with the original configuration data. Branding now has the new values, the NonPublishingNavigation is now there, and the RequiredSharePointJSFiles have the “sp.userprofiles.js” included.

To prove that it has truly merged, using Console in Chrome, the NonPublishingNavigation is a new value that is actually part of the Namespace CF.SharePoint.SiteConfiguration.Data, but if you type in CF.SharePoint.CoreSiteConfiguration.Data, you can clearly see that NonPublishingNavigation is part of this namespace now.

Link to this solution can be found on my OneDrive

 

 

 

 

Importing Taxonomy to SharePoint using Powershell

In my previous post I showed you how to Export your Taxonomy from SharePoint, either on premise or Online. It was a PowerShell script that using CSOM reads in the Taxonomy and saves the information to an XML file.

However to import this XML file back into SharePoint, you will require the Import PowerShell script too. This blog post will explain the separate functions within the Import PowerShell. At the end of this blog post you can download the full PowerShell file from my OneDrive. When this PowerShell is run it will check to ensure that the Group, TermSet, Term is not already there, if it cannot find it then it will add it. This can be useful if you were trying to merge (assuming ID’s are the same), or restore terms that may have been deleted from an Export you done as a back up.

Breaking the PowerShell file down.

Parameters

There are 5 different parameters and they are all Manatory.

AdminUser

The user who has administrative access to the term store. (e.g., On-Prem: Domain\user or for 365: user@sp.com)

AdminPassword

The password for the Admin User.

AdminUrl

The URL of Central Admin for On-Prem or Admin site for 365

FilePathOfExportXMLTerms

The path of the Exported XML file, which you have created using the Export Script.

PathToSPClientdlls

The script requires to call the following dlls:
Microsoft.SharePoint.Client.dll
Microsoft.SharePoint.Client.Runtime.dll
Microsoft.SharePoint.Client.Taxonomy.dll

(e.g., C:\Program Files\Common Files\microsoft shared\Web Server Extensions\15\ISAPI) Or you can download SharePoint Client SDK which will have the dll’s

Load and Connect to SharePoint Function

This function will return a SPContext, it will use CSOM to connect to the SharePoint Admin site. There is a line of code that checks if the URL contains “.sharepoint.com”, we can assume that if it does then it is an online SharePoint tenant and will require to connect using a different sign in method. The function requires the SharePoint admin URL, User, Password and path to the client dlls. This is also the same function and code used in the Export script.

function LoadAndConnectToSharePoint($url, $user, $password, $dllPath){
 #Convert password to secure string
 $securePassword = ConvertTo-SecureString $password -AsPlainText -Force
 #Get SPClient Dlls Path
 $spClientdllsDir = Get-Item $dllPath
 #Add required Client Dlls
 Add-Type -Path "$($spClientdllsDir.FullName)\Microsoft.SharePoint.Client.dll"
 Add-Type -Path "$($spClientdllsDir.FullName)\Microsoft.SharePoint.Client.Runtime.dll"
 Add-Type -Path "$($spClientdllsDir.FullName)\Microsoft.SharePoint.Client.Taxonomy.dll"
 $spContext = New-Object Microsoft.SharePoint.Client.ClientContext($url)

 if($url.Contains(".sharepoint.com")) # SharePoint Online
 {
    $credentials = New-Object Microsoft.SharePoint.Client.SharePointOnlineCredentials($User, $securePassword)
 }
 else # SharePoint On-premises
 {
    $networkCredentials = new-object -TypeName System.Net.NetworkCredential
    $networkCredentials.UserName = $user.Split('\')[1]
    $networkCredentials.Password = $password
    $networkCredentials.Domain = $user.Split('\')[0]

    [System.Net.CredentialCache]$credentials = new-object -TypeName System.Net.CredentialCache
    $uri = [System.Uri]$url
    $credentials.Add($uri, "NTLM", $networkCredentials)
}

#See if we can establish a connection
 $spContext.Credentials = $credentials
 $spContext.RequestTimeOut = 5000 * 60 * 10;
 $web = $spContext.Web
 $site = $spContext.Site
 $spContext.Load($web)
 $spContext.Load($site)
 try
 {
    $spContext.ExecuteQuery()
    Write-Host "Established connection to SharePoint at $Url OK" -foregroundcolor Green
 }
 catch
 {
    Write-Host "Not able to connect to SharePoint at $Url. Exception:$_.Exception.Message" -foregroundcolor red
    exit 1
 }

 return $spContext
}

Get TermStore Info
This function using the SPContext will return the TermStore. If you have multiple termstores (which you might have in your on prem environment) you might need to modify the code not to just bring back the termstore at index 0. This is also the same function and code used in the Export script.
function Get-TermStoreInfo($spContext){
 $spTaxSession = [Microsoft.SharePoint.Client.Taxonomy.TaxonomySession]::GetTaxonomySession($spContext)
 $spTaxSession.UpdateCache();
 $spContext.Load($spTaxSession)

 try
 {
 $spContext.ExecuteQuery()
 }
 catch
 {
  Write-host "Error while loading the Taxonomy Session " $_.Exception.Message -ForegroundColor Red
  exit 1
 }

 if($spTaxSession.TermStores.Count -eq 0){
  write-host "The Taxonomy Service is offline or missing" -ForegroundColor Red
  exit 1
 }

 $termStores = $spTaxSession.TermStores
 $spContext.Load($termStores)

 try
 {
  $spContext.ExecuteQuery()
  $termStore = $termStores[0]
  $spcontext.Load($termStore)
  $spContext.ExecuteQuery()
  Write-Host "Connected to TermStore: $($termStore.Name) ID: $($termStore.Id)"
 }
 catch
 {
  Write-host "Error details while getting term store ID" $_.Exception.Message -ForegroundColor Red
  exit 1
 }

 return $termStore
}

Get Terms To Import
This function loads the XML file into a Linq XDocument and then returns the file. This will allow us to read in and loop through the XML.
function Get-TermsToImport($xmlTermsPath){
 [Reflection.Assembly]::LoadWithPartialName("System.Xml.Linq") | Out-Null

 try
 {
     $xDoc = [System.Xml.Linq.XDocument]::Load($xmlTermsPath, [System.Xml.Linq.LoadOptions]::None)
     return $xDoc
 }
 catch
 {
      Write-Host "Unable to read ExportedTermsXML. Exception:$_.Exception.Message" -ForegroundColor Red
      exit 1
 }
}

Create Groups
This function get passed the SPContext, the TermStore and the XML file. From the XML file it grab all Group nodes and iterates over them, by grabbing relevant information such as Name, Description, ID. Once it has the ID it calls the SharePoint TermStore you are connecting to, and attempts to get the Group by ID. If nothing is returned then it means the group doesn’t exist and the group is added to the TermStore. If it already exist it moves directly onto creating the TermSets for the group.
function Create-Groups($spContext, $termStore, $termsXML){
     foreach($groupNode in $termsXML.Descendants("Group"))
     {
        $name = $groupNode.Attribute("Name").Value
        $description = $groupNode.Attribute("Description").Value;
        $groupId = $groupNode.Attribute("Id").Value;
        $groupGuid = [System.Guid]::Parse($groupId);
        Write-Host "Processing Group: $name ID: $groupId ..." -NoNewline

        $group = $termStore.GetGroup($groupGuid);
        $spContext.Load($group);

        try
        {
            $spContext.ExecuteQuery();
        }
        catch
        {
            Write-host "Error while finding if " $name " group already exists. " $_.Exception.Message -ForegroundColor Red
            exit 1
        }

        if ($group.ServerObjectIsNull) {
            $group = $termStore.CreateGroup($name, $groupGuid);
            $spContext.Load($group);
            try
            {
                $spContext.ExecuteQuery();
                write-host "Inserted" -ForegroundColor Green
            }
            catch
            {
                Write-host "Error creating new Group " $name " " $_.Exception.Message -ForegroundColor Red
                exit 1
            }
        }
        else {
            write-host "Already exists" -ForegroundColor Yellow
        }

        Create-TermSets $termsXML $group $termStore $spContext

     }

     try
     {
         $termStore.CommitAll();
         $spContext.ExecuteQuery();
     }
     catch
     {
       Write-Host "Error commiting changes to server. Exception:$_.Exception.Message" -foregroundcolor red
       exit 1
     }
}

Create TermSets
This function is called from within the Create Groups function. The XML file, current Group, TermStore and SharePoint Context is passed into the function. Firstly from the XML file we grab all TermSets that are related to the current Group. Then we iterate over these TermSets. For the given TermSet we grab all the information in the XML, and then try and get the TermSet using the ID from the TermStore. As with the groups function, if the TermSet doesn’t exists, then the TermSet is created. If when the TermSet is being created an error occurs, a flag is marked so that we can inform the user that an error occurred, but not affect the running and importing of the rest of the XML. If the TermSet does exist then it skips the creation, and checks to see if there are any Terms and call the Create-Term function.
function Create-TermSets($termsXML, $group, $termStore, $spContext) {

    $termSets = $termsXML.Descendants("TermSet") | Where { $_.Parent.Parent.Attribute("Name").Value -eq $group.Name }

    foreach ($termSetNode in $termSets)
    {
        $errorOccurred = $false
        $name = $termSetNode.Attribute("Name").Value;
        $id = [System.Guid]::Parse($termSetNode.Attribute("Id").Value);
        $description = $termSetNode.Attribute("Description").Value;
        $customSortOrder = $termSetNode.Attribute("CustomSortOrder").Value;
        Write-host "Processing TermSet $name ... " -NoNewLine

        $termSet = $termStore.GetTermSet($id);
        $spcontext.Load($termSet);

        try
        {
            $spContext.ExecuteQuery();
        }
        catch
        {
            Write-host "Error while finding if " $name " termset already exists. " $_.Exception.Message -ForegroundColor Red
            exit 1
        }

        if ($termSet.ServerObjectIsNull)
        {
            $termSet = $group.CreateTermSet($name, $id, $termStore.DefaultLanguage);
            $termSet.Description = $description;

            if($customSortOrder -ne $null)
            {
                $termSet.CustomSortOrder = $customSortOrder
            }

           $termSet.IsAvailableForTagging = [bool]::Parse($termSetNode.Attribute("IsAvailableForTagging").Value);
           $termSet.IsOpenForTermCreation = [bool]::Parse($termSetNode.Attribute("IsOpenForTermCreation").Value);

            if($termSetNode.Element("CustomProperties") -ne $null)
            {
                foreach($custProp in $termSetNode.Element("CustomProperties").Elements("CustomProperty"))
                {
                   $termSet.SetCustomProperty($custProp.Attribute("Key").Value, $custProp.Attribute("Value").Value)
                }
            }

           try
            {
                $spContext.ExecuteQuery();
            }
            catch
            {
                Write-host "Error occured while create Term Set" $name $_.Exception.Message -ForegroundColor Red
                $errorOccurred = $true
            }

            write-host "created" -ForegroundColor Green
        }
        else {
            write-host "Already exists" -ForegroundColor Yellow
        }

        if(!$errorOccurred)
        {
            if ($termSetNode.Element("Terms") -ne $null)
            {
              foreach ($termNode in $termSetNode.Element("Terms").Elements("Term"))
               {
                  Create-Term $termNode $null $termSet $termStore $termStore.DefaultLanguage $spContext
               }
            }
        }
    }
}

Create Term
The Create Term can be called from Create Terms or recursively from itself. It is passed the XML Term, the parent term (which is used for recursive calls, otherwise null), the TermSet that the Term is from, the TermStore, language of the Term and the SPContext. This script just uses your TermStore default language, but with some small code change (I’ll leave that for you) you can allow it to use any language. This function reads in the Terms XML values, then tries and get the Term by ID from the TermStore. If the Term doesn’t exist it will process the term and add it to SharePoint either to the TermSet, or to another Term as a SubTerm. If the Term already exists then it will skip the creation and check to see if it has any subterms in the XML and recursively call itself, otherwise it will return up the stack for the next Term/TermSet/Group.

function Create-Term($termNode, $parentTerm, $termSet, $store, $lcid, $spContext){
    $id = [System.Guid]::Parse($termNode.Attribute("Id").Value)
    $name = $termNode.Attribute("Name").Value;
    $term = $termSet.GetTerm($id);
    $errorOccurred = $false

    $spContext.Load($term);
    try
    {
        $spContext.ExecuteQuery();
    }
    catch
    {
        Write-host "Error while finding if " $name " term id already exists. " $_.Exception.Message -ForegroundColor Red
        exit 1
    }

     write-host "Processing Term $name ..." -NoNewLine
    if($term.ServerObjectIsNull)
    {
        if ($parentTerm -ne $null)
        {
            $term = $parentTerm.CreateTerm($name, $lcid, $id);
        }
        else
        {
           $term = $termSet.CreateTerm($name, $lcid, $id);
        }

        $customSortOrder = $termNode.Attribute("CustomSortOrder").Value;
        $description = $termNode.Element("Descriptions").Element("Description").Attribute("Value").Value;
        $term.SetDescription($description, $lcid);
        $term.IsAvailableForTagging = [bool]::Parse($termNode.Attribute("IsAvailableForTagging").Value);

        if($customSortOrder -ne $null)
        {
            $term.CustomSortOrder = $customSortOrder
        }

        if($termNode.Element("CustomProperties") -ne $null)
        {
            foreach($custProp in $termNode.Element("CustomProperties").Elements("CustomProperty"))
            {
                $term.SetCustomProperty($custProp.Attribute("Key").Value, $custProp.Attribute("Value").Value)
            }
        }

        if($termNode.Element("LocalCustomProperties") -ne $null)
        {
            foreach($localCustProp in $termNode.Element("LocalCustomProperties").Elements("LocalCustomProperty"))
           {
               $term.SetLocalCustomProperty($localCustProp.Attribute("Key").Value, $localCustProp.Attribute("Value").Value)
           }
        }

       try
        {
            $spContext.Load($term);
            $spContext.ExecuteQuery();
            write-host " created" -ForegroundColor Green
        }
        catch
        {
            Write-host "Error occured while create Term" $name $_.Exception.Message -ForegroundColor Red
            $errorOccurred = $true
        }
    }
    else
    {
     write-host "Already exists" -ForegroundColor Yellow
    }

   if(!$errorOccurred)
    {
        if ($termNode.Element("Terms") -ne $null)
        {
            foreach ($childTermNode in $termNode.Element("Terms").Elements("Term"))
            {
                Create-Term $childTermNode $term $termSet $store $lcid $spContext
            }
        }
    }
}

How to Import XML into SharePoint with the PowerShell command.
This example use a SharePoint online account/site, but you can easily point it to an on premise site. To view all details of the PowerShell file has a help file which can be called ./Import-Taxonomy.ps1 – help. This will import the entire XML into your given SharePoint site, it will add any information that is missing from the given TermStore.
  ./Import-Taxonomy.ps1 -AdminUser user@sp.com -AdminPassword password -AdminUrl https://sp-admin.onmicrosoft.com -FilePathOfExportXMLTerms c:\myTerms\exportedterms.xml -PathToSPClientdlls "C:\Program Files\Common Files\microsoft shared\Web Server Extensions\15\ISAPI"


Screenshot as Importing to SharePoint Online.

Screen shot of Terms in my On Premise environment.

Screen shot of the same terms imported into my SharePoint Online environment.
Link to the PowerShell file can be found on my One Drive.
Link to blog about Exporting Taxonomy from SharePoint.
Again, lastly I would like to thank tow of my colleagues who without their initial work I wouldn’t have been able to create this final PS1 file. Kevin Beckett and Luis Manez (http://geeks.ms/blog/imanez)
			

Exporting Taxonomy from SharePoint using Powershell

In a previous post I showed you how to connect your Site Managed Metadata Column to your Term Set in your Taxonomy using JavaScript. The code I put in that blog relies on Taxonomy Term Set ID to be hard coded in the JavaScript. This is not really ideal if you are going through multiple environments. One solution to this was to change my JavaScript code to make additional calls to find the TermSet name instead of using the ID. Even if you did do this, it is most likely your term store is quite large, and re-typing from one environment to another could take some time. Especially if you have a Store with multiple groups, TermSets, Terms and sub terms.

Above is a small example from my Developer machine of a Group and TermSets. Countries alone has around 240 terms. Think you will agree not easy to type out again in another environment. (Dev, Test, Staging, Production).

There are tools currently out there, and a very good tool is by Gary Lapointe, which can be downloaded under the header ‘SharePoint 2013 STSADM Commands and PowerShell Cmdlets WSP Files’ http://blog.falchionconsulting.com/index.php/downloads/ . With Gary Lapointe code, you first need to install the WSP onto the SharePoint server you wish to Export/Import to, then using powershell you can export to XML, and then use that XML to re-import back to another SharePoint environment with Gary Lapointe solution also installed on.

Import-SPTerms – http://www.falchionconsulting.com/PowerShellViewer/Default.aspx?Version=SP2013&Cmdlet=Import-SPTerms

Export-SPTerms – http://www.falchionconsulting.com/PowerShellViewer/Default.aspx?Version=SP2013&Cmdlet=Export-SPTerms

As I said this is a very good tool, and the XML gave me a good jumping off point, however it has some shortcomings for my requirements, and these are the main two that meant I had to create my own tool.

• It On Prem Only, no good to export/import to SharePoint Online
• When using the term store for SharePoint navigation, the additional information were not exported.

Using the similar XML design of what Gary Lapointe created, I created a PowerShell solution that can export an entire TermStore or a given Term Group. I will explain the separate functions within the powershell to you. At the end of this blog post you can download the full powershell file from my onedrive.

Breaking the PowerShell file down

Parameters

There are 7 different parameters and 6 of them are Manatory.

AdminUser

The user who has adminitrative access to the term store. (e.g., On-Prem: Domain\user or for 365: user@sp.com)

AdminPassword

The password for the Admin User.

AdminUrl

The URL of Central Admin for On-Prem or Admin site for 365

PathToExportXMLTerms

The path you wish to save the XML Output to. This path must exist.

XMLTermsFileName

The name of the XML file to save. If the file already exists then it will be overwritten.

PathToSPClientdlls

The script requires to call the following dlls:
Microsoft.SharePoint.Client.dll
Microsoft.SharePoint.Client.Runtime.dll
Microsoft.SharePoint.Client.Taxonomy.dll

(e.g., C:\Program Files\Common Files\microsoft shared\Web Server Extensions\15\ISAPI) Or you can download SharePoint Client SDK which will have the dll’s

GroupToExport

An optional parameter, if included only the Group will be exported. If omitted then the entire termstore will be written to XML.

Load and Connect to SharePoint Function

This function will return an SPContext, it will use CSOM to connect to the SharePoint Admin site. There is a line of code that checks if the URL contains “.sharepoint.com”, we can assume that if it does then it is an online SharePoint tenant and will require to connect using a different sign in method. The function requires the SharePoint admin URL, User, Password and path to the client dlls.

function LoadAndConnectToSharePoint($url, $user, $password, $dllPath){

 #Convert password to secure string

 $securePassword = ConvertTo-SecureString $password -AsPlainText -Force

 #Get SPClient Dlls Path

 $spClientdllsDir = Get-Item $dllPath

 #Add required Client Dlls

 Add-Type -Path "$($spClientdllsDir.FullName)\Microsoft.SharePoint.Client.dll"

 Add-Type -Path "$($spClientdllsDir.FullName)\Microsoft.SharePoint.Client.Runtime.dll"

 Add-Type -Path "$($spClientdllsDir.FullName)\Microsoft.SharePoint.Client.Taxonomy.dll"

 $spContext = New-Object Microsoft.SharePoint.Client.ClientContext($url)

 if($url.Contains(".sharepoint.com")) # SharePoint Online

 {    

    $credentials = New-Object Microsoft.SharePoint.Client.SharePointOnlineCredentials($User, $securePassword)

 }

 else # SharePoint On-premises

 {    

    $networkCredentials = new-object -TypeName System.Net.NetworkCredential

    $networkCredentials.UserName = $user.Split('\')[1]

    $networkCredentials.Password = $password

    $networkCredentials.Domain = $user.Split('\')[0]

    [System.Net.CredentialCache]$credentials = new-object -TypeName System.Net.CredentialCache

    $uri = [System.Uri]$url

    $credentials.Add($uri, "NTLM", $networkCredentials)

}

 #See if we can establish a connection

 $spContext.Credentials = $credentials

 $spContext.RequestTimeOut = 5000 * 60 * 10;

 $web = $spContext.Web

 $site = $spContext.Site

 $spContext.Load($web)

 $spContext.Load($site)

 try

 {

    $spContext.ExecuteQuery()

    Write-Host "Established connection to SharePoint at $Url OK" -foregroundcolor Green

}

catch

{

    Write-Host "Not able to connect to SharePoint at $Url. Exception:$_.Exception.Message" -foregroundcolor red

    exit 1

}

 return $spContext

}


Get TermStore Info
This function using the SPContext will return the TermStore. If you have multiple termstores (which you might have in your on prem environment) you might need to modify the code not to just bring back the termstore at index 0.
function Get-TermStoreInfo($spContext){
 $spTaxSession = [Microsoft.SharePoint.Client.Taxonomy.TaxonomySession]::GetTaxonomySession($spContext)
 $spTaxSession.UpdateCache();
 $spContext.Load($spTaxSession)

 try
 {
 $spContext.ExecuteQuery()
 }
 catch
 {
  Write-host "Error while loading the Taxonomy Session " $_.Exception.Message -ForegroundColor Red
  exit 1
 }

 if($spTaxSession.TermStores.Count -eq 0){
  write-host "The Taxonomy Service is offline or missing" -ForegroundColor Red
  exit 1
 }

 $termStores = $spTaxSession.TermStores
 $spContext.Load($termStores)

 try
 {
  $spContext.ExecuteQuery()
  $termStore = $termStores[0]
  $spcontext.Load($termStore)
  $spContext.ExecuteQuery()
  Write-Host "Connected to TermStore: $($termStore.Name) ID: $($termStore.Id)"
 }
 catch
 {
  Write-host "Error details while getting term store ID" $_.Exception.Message -ForegroundColor Red
  exit 1
 }
 return $termStore
}

Get XML TermStore Template To File
This creates an empty XML template, very similar to Gary Lapointe XML file. I’m passing in the Term Store Name and the path to where I want to save the .XML file. The code creates a template.xml file which is a temporary file. This blank template is used later on. It should contain all the relevant bits of information about the term store. Through XPath, which you will see later, we can recursively node sections (e.g, Custom Properties, Terms, TermSets, Groups etc.)
function Get-XMLTermStoreTemplateToFile($termStoreName, $path){
 ## Set up an xml template used for creating your exported xml
 $xmlTemplate = '<TermStores>
 <TermStore Name="' + $termStoreName + '" IsOnline="True" WorkingLanguage="1033" DefaultLanguage="1033" SystemGroup="c6fb3e37-0997-42b1-8e3c-2706a36adbc4">
 <Groups>
 <Group Id="" Name="" Description="" IsSystemGroup="False" IsSiteCollectionGroup="False">
 <TermSets>
 <TermSet Id="" Name="" Description="" Contact="" IsAvailableForTagging="" IsOpenForTermCreation="" CustomSortOrder="False">
 <CustomProperties>
 <CustomProperty Key="" Value=""/>
 </CustomProperties>
 <Terms>
 <Term Id="" Name="" IsDeprecated="" IsAvailableForTagging="" IsKeyword="" IsReused="" IsRoot="" IsSourceTerm="" CustomSortOrder="False">
 <Descriptions>
 <Description Language="1033" Value="" />
 </Descriptions>
 <CustomProperties>
 <CustomProperty Key="" Value="" />
 </CustomProperties>
 <LocalCustomProperties>
 <LocalCustomProperty Key="" Value="" />
 </LocalCustomProperties>
 <Labels>
 <Label Value="" Language="1033" IsDefaultForLanguage="" />
 </Labels>
 <Terms>
 <Term Id="" Name="" IsDeprecated="" IsAvailableForTagging="" IsKeyword="" IsReused="" IsRoot="" IsSourceTerm="" CustomSortOrder="False">
 <Descriptions>
 <Description Language="1033" Value="" />
 </Descriptions>
 <CustomProperties>
 <CustomProperty Key="" Value="" />
 </CustomProperties>
 <LocalCustomProperties>
 <LocalCustomProperty Key="" Value="" />
 </LocalCustomProperties>
 <Labels>
 <Label Value="" Language="1033" IsDefaultForLanguage="" />
 </Labels>
 </Term>
 </Terms>
 </Term>
 </Terms>
 </TermSet>
 </TermSets>
 </Group>
 </Groups>
 </TermStore>
 </TermStores>'

try
{
 #Save Template to disk
 $xmlTemplate | Out-File($path + "\Template.xml")

 #Load file and return
 $xml = New-Object XML
 $xml.Load($path + "\Template.xml")
 return $xml
 }
 catch{
 Write-host "Error creating Template file. " $_.Exception.Message -ForegroundColor Red
 exit 1
 }
}
 
Get XML File Object Templates
Using Global variables, the template XML file is being broken down into sections, so at the given time when I’m exporting the TermSet I can grab a node, fill it in, and then add it to the final XML file. Using XPath I’m grabbing, Group, TermSet, Term, Term Label, Term Description, Term Custom Properties and Tern Local Custom properties.
function Get-XMLFileObjectTemplates($xml){
 #Grab template elements so that we can easily copy them later.
   $global:xmlGroupT = $xml.selectSingleNode('//Group[@Id=""]')
    $global:xmlTermSetT = $xml.selectSingleNode('//TermSet[@Id=""]')
    $global:xmlTermT = $xml.selectSingleNode('//Term[@Id=""]')
 $global:xmlTermLabelT = $xml.selectSingleNode('//Label[@Value=""]')
 $global:xmlTermDescriptionT = $xml.selectSingleNode('//Description[@Value=""]')
 $global:xmlTermCustomPropertiesT = $xml.selectSingleNode('//CustomProperty[@Key=""]')
 $global:xmlTermLocalCustomPropertiesT = $xml.selectSingleNode('//LocalCustomProperty[@Key=""]')
}

Get Groups
This function will be called from the actual Export Taxonomy Function. A call would have already been made to obtain all Groups within the TermStore and passed into this function. It will loop through each Group, ignoring system groups, and if the parameter $GroupToExport was supplied it will skip all groups until it finds the given group. Once found it will grab a clone of GroupXMLTemplate and fill out the required information, then add the clone to the template XML in the correct place. It will then try to load any TermSets for the group.
function Get-Groups($spContext, $groups, $xml, $groupToExport){
 #Loop through all groups, ignoring system Groups
 $groups | Where-Object { $_.IsSystemGroup -eq $false} | ForEach-Object{

 #Check if we are getting groups or just group.
 if($groupToExport -ne "")
 {
 if($groupToExport -ne $_.name){
 #Return acts like a continue in ForEach-Object
 return;
 }
 }

 #Add each group to export xml by cloning the template group,
 #populating it and appending it
 $xmlNewGroup = $global:xmlGroupT.Clone()
 $xmlNewGroup.Name = $_.name
 $xmlNewGroup.id = $_.id.ToString()
 $xmlNewGroup.Description = $_.description
 $xml.TermStores.TermStore.Groups.AppendChild($xmlNewGroup) | Out-Null

 write-Host "Adding Group " -NoNewline
 write-Host $_.name -ForegroundColor Green

 $spContext.Load($_.TermSets)
 try
 {
 $spContext.ExecuteQuery()
 }
 catch
 {
 Write-host "Error while loaded TermSets for Group " $xmlNewGroup.Name " " $_.Exception.Message -ForegroundColor Red
 exit 1
 }

 Get-TermSets $spContext $xmlNewGroup $_.Termsets $xml
 }
}

Get Term Sets
This function is called from Get-Groups Function. A call was made in Get-Groups to obtain all TermSets within the Group and passed into this function. It will loop through each TermSet, grab a clone of TermSetXMLTemplate and fill out the required information, skipping CustomSortOrder and Custom properties if they do not exist, or grabbing a clone of their template and filling in the information. Then add the clone to the template XML in the correct place. It will then try to load any Terms for the termset.
You will notice on the 6th line down I am replacing an ampersand with another. This is because the one that SharePoint is a different character to ampersand you get when you press & on your keyboard. This just tidies the data in the XML and prevents problems with string matching in importing.
function Get-TermSets($spContext, $xmlnewGroup, $termSets, $xml){
 $termSets | ForEach-Object{
 #Add each termset to the export xml
 $xmlNewSet = $global:xmlTermSetT.Clone()
 #Replace SharePoint ampersand with regular
 $xmlNewSet.Name = $_.Name.replace("＆", "&")

 $xmlNewSet.Id = $_.Id.ToString()

 if ($_.CustomSortOrder -ne $null)
 {
 $xmlNewSet.CustomSortOrder = $_.CustomSortOrder.ToString()
 }

 foreach($customprop in $_.CustomProperties.GetEnumerator())
 {
 ## Clone Term customProp node
 $xmlNewTermCustomProp = $global:xmlTermCustomPropertiesT.Clone()    

 $xmlNewTermCustomProp.Key = $($customProp.Key)
 $xmlNewTermCustomProp.Value = $($customProp.Value)
 $xmlNewSet.CustomProperties.AppendChild($xmlNewTermCustomProp) | Out-Null
 }

 $xmlNewSet.Description = $_.Description.ToString()
 $xmlNewSet.Contact = $_.Contact.ToString()
    $xmlNewSet.IsOpenForTermCreation = $_.IsOpenForTermCreation.ToString()
    $xmlNewSet.IsAvailableForTagging = $_.IsAvailableForTagging.ToString()
    $xmlNewGroup.TermSets.AppendChild($xmlNewSet) | Out-Null

 Write-Host "Adding TermSet " -NoNewline
 Write-Host $_.name -ForegroundColor Green -NoNewline
 Write-Host " to Group " -NoNewline
 Write-Host $xmlNewGroup.Name -ForegroundColor Green

 $spContext.Load($_.Terms)
 try
 {
 $spContext.ExecuteQuery()
 }
 catch
 {
 Write-host "Error while loading Terms for TermSet " $_.name " " $_.Exception.Message -ForegroundColor Red
 exit 1
 }
 # Recursively loop through all the terms in this termset
    Get-Terms $spContext $_.Terms $xml
 }

Get Terms
This function is called from Get-TermSets Function. A call was made in Get-TermSets (Or Get-Terms if collection is a sub terms) to obtain all Terms within the TermSet and passed into this function. It will loop through each Terms, grab a clone of TermXMLTemplate and fill out the required information. A Term has lots of repeating data for it, such as Custom Properties, Local Properties etc, which uses given XMLTemplates to store information then append to the XML term. Lastly Labels, TermSets information, Parent information and subTerms require an additional context load. The parent and TermSet information is used to ensure if sub terms, they are added to the correct location within the XML Template. The loading of the Terms (sub terms) for this current term is then passed back into Get-TermSet function, recursively calling itself until no sub terms can be found. *Hopefully the code is more explanatory to you then my description here.
#Terms could be either the original termset or parent term with children terms
 $terms | ForEach-Object{
 #Create a new term xml Element
 $xmlNewTerm = $global:xmlTermT.Clone()
 #Replace SharePoint ampersand with regular
 $xmlNewTerm.Name = $_.Name.replace("＆", "&")
 $xmlNewTerm.id = $_.Id.ToString()
 $xmlNewTerm.IsAvailableForTagging = $_.IsAvailableForTagging.ToString()
 $xmlNewTerm.IsKeyword = $_.IsKeyword.ToString()
 $xmlNewTerm.IsReused = $_.IsReused.ToString()
 $xmlNewTerm.IsRoot = $_.IsRoot.ToString()
    $xmlNewTerm.IsSourceTerm = $_.IsSourceterm.ToString()
    $xmlNewTerm.IsDeprecated = $_.IsDeprecated.ToString()

 if($_.CustomSortOrder -ne $null)
 {
 $xmlNewTerm.CustomSortOrder = $_.CustomSortOrder.ToString()
 }

 #Custom Properties
 foreach($customprop in $_.CustomProperties.GetEnumerator())
 {
 # Clone Term customProp node
 $xmlNewTermCustomProp = $global:xmlTermCustomPropertiesT.Clone()    

 $xmlNewTermCustomProp.Key = $($customProp.Key)
 $xmlNewTermCustomProp.Value = $($customProp.Value)
 $xmlNewTerm.CustomProperties.AppendChild($xmlNewTermCustomProp)  | Out-Null
 }

 #Local Properties
 foreach($localProp in $_.LocalCustomProperties.GetEnumerator())
 {
 # Clone Term LocalProp node
 $xmlNewTermLocalCustomProp = $global:xmlTermLocalCustomPropertiesT.Clone()    

 $xmlNewTermLocalCustomProp.Key = $($localProp.Key)
 $xmlNewTermLocalCustomProp.Value = $($localProp.Value)
 $xmlNewTerm.LocalCustomProperties.AppendChild($xmlNewTermLocalCustomProp) | Out-Null
 }

 if($_.Description -ne ""){
 $xmlNewTermDescription = $global:xmlTermDescriptionT.Clone()
 $xmlNewTermDescription.Value = $_.Description
 $xmlNewTerm.Descriptions.AppendChild($xmlNewTermDescription) |Out-Null
 }

 $spContext.Load($_.Labels)
 $spContext.Load($_.TermSet)
 $spContext.Load($_.Parent)
 $spContext.Load($_.Terms)

 try
 {
 $spContext.ExecuteQuery()
 }
 catch
 {
 Write-host "Error while loaded addition information for Term " $xmlNewTerm.Name " " $_.Exception.Message -ForegroundColor Red
 exit 1
 }

 foreach($label in $_.Labels)
 {
 ## Clone Term Label node
 $xmlNewTermLabel = $global:xmlTermLabelT.Clone()
 $xmlNewTermLabel.Value = $label.Value.ToString()
 $xmlNewTermLabel.Language = $label.Language.ToString()
 $xmlNewTermLabel.IsDefaultForLanguage = $label.IsDefaultForLanguage.ToString()
        $xmlNewTerm.Labels.AppendChild($xmlNewTermLabel) | Out-Null
 }

 # Use this terms parent term or parent termset in the termstore to find it's matching parent
     # in the export xml
     if ($_.parent.Id -ne $null) {
      # Both guids are needed as a term can appear in multiple termsets
        $parentGuid = $_.parent.Id.ToString()
        $parentTermsetGuid = $_.Termset.Id.ToString()
 #$_.Parent.Termset.Id.ToString()
     }
 else
 {
      $parentGuid = $_.Termset.Id.ToString()
     }     

 # Get this terms parent in the xml
     $parent = Get-TermByGuid $xml $parentGuid $parentTermsetGuid     

 $parentGuid = $null;

 #Append new Term to Parent
 $parent.Terms.AppendChild($xmlNewTerm) | Out-Null

 Write-Host "Adding Term " -NoNewline
 Write-Host $_.name -ForegroundColor Green -NoNewline
 Write-Host " to Parent " -NoNewline
 Write-Host $parent.Name -ForegroundColor Green

 #If this term has child terms we need to loop through those
 if($_.Terms.Count -gt 0){
 #Recursively call itself
 Get-Terms $spContext $_.Terms $xml
 }
 }
}

Get Terms By Guid
This function is used with Get-Terms. All it is doing is returning the corresponding selected nodes from the XML template, passing in either the TermGuid, or Parent TermSet Guid.
function Get-TermByGuid($xml, $guid, $parentTermsetGuid) {
      if ($parentTermsetGuid) {
        return  $xml.selectnodes('//Term[@Id="' + $guid + '"]')
    } else {
        return  $xml.selectnodes('//TermSet[@Id="' + $guid + '"]')
    }
}

Clean Template
The Clean template function is called just before saving the completed XML to disk. This ensures any empty elements are removed from the XML.
function Clean-Template($xml) {
    #Do not cleanup empty description nodes (this is the default state)

 ## Empty Term.Labels.Label
    $xml.selectnodes('//Label[@Value=""]') | ForEach-Object {
        $parent = $_.get_ParentNode()
        $parent.RemoveChild($_)  | Out-Null
    }
 ## Empty Term
 $xml.selectnodes('//Term[@Id=""]') | ForEach-Object {
        $parent = $_.get_ParentNode()
        $parent.RemoveChild($_)  | Out-Null
    }
 ## Empty TermSet
    $xml.selectnodes('//TermSet[@Id=""]') | ForEach-Object {
        $parent = $_.get_ParentNode()
        $parent.RemoveChild($_)  | Out-Null
    }
 ## Empty Group
    $xml.selectnodes('//Group[@Id=""]') | ForEach-Object {
        $parent = $_.get_ParentNode()
        $parent.RemoveChild($_)   | Out-Null
    }
 ## Empty Custom Properties
 $xml.selectnodes('//CustomProperty[@Key=""]') | ForEach-Object {
 $parent = $_.get_ParentNode()
 $parent.RemoveChild($_) | Out-Null
 }

 ## Empty Local Custom proeprties
 $xml.selectnodes('//LocalCustomProperty[@Key=""]') | ForEach-Object {
 $parent = $_.get_ParentNode()
 $parent.RemoveChild($_) | Out-Null
 }

 $xml.selectnodes('//Descriptions')| ForEach-Object {
 $childNodes = $_.ChildNodes.Count
 if($childNodes -gt 1)
 {
 $_.RemoveChild($_.ChildNodes[0]) | Out-Null
 }
 }

 While ($xml.selectnodes('//Term[@Id=""]').Count -gt 0)
 {
 #Cleanup the XML, remove empty Term Nodes
 $xml.selectnodes('//Term[@Id=""]').RemoveAll() | Out-Null
 }

Export Taxonomy
This function ties all the other functions together really. It starts at calling the groups, then once that has pushed down and iterated through all the other methods, the XML is tidied, then saved to the filename given in the parameters. All temporary file are deleted.
function ExportTaxonomy($spContext, $termStore, $xml, $groupToExport, $path, $saveFileName){
 $spContext.Load($termStore.Groups)
 try
 {
 $spContext.ExecuteQuery();
 }
 catch
 {
 Write-host "Error while loaded Groups from TermStore " $_.Exception.Message -ForegroundColor Red
 exit 1
 }

 Get-Groups $spContext $termStore.Groups $xml $groupToExport

 #Clean up empty tags/nodes
 Clean-Template $xml

 #Save file.
 try
 {
 $xml.Save($path + "\NewTaxonomy.xml")

 #Clean up empty <Term> unable to work out in Clean-Template.
 Get-Content ($path + "\NewTaxonomy.xml") | Foreach-Object { $_ -replace "<Term><\/Term>", "" } | Set-Content ($path + "\" + $saveFileName)
 Write-Host "Saving XML file " $saveFileName " to " $path

 #Remove temp file
 Remove-Item($path + "\Template.xml");
 Remove-Item($path + "\NewTaxonomy.xml");
 }
 catch
 {
 Write-host "Error saving XML File to disk " $_.Exception.Message -ForegroundColor Red
 exit 1
 }
}

How to Export TermSet with the PowerShell command.
Both these examples use a SharePoint online account/site, but you can easily point it to an on premise site. To view all details the powershell file has a help file which can be called ./Export-Taxonomy.ps1 -help
This exports the entire termstore.
    ./Export-Taxonomy.ps1 -AdminUser user@sp.com -AdminPassword password -AdminUrl https://sp-admin.onmicrosoft.com -PathToExportXMLTerms c:\myTerms -XMLTermsFileName exportterms.xml -PathToSPClientdlls "C:\Program Files\Common Files\microsoft shared\Web Server Extensions\15\ISAPI"

This exports just the Term Store Group ‘Client Group Terms’
    ./Export-Taxonomy.ps1 -AdminUser user@sp.com -AdminPassword password -AdminUrl https://sp-admin.onmicrosoft.com -PathToExportXMLTerms c:\myTerms -XMLTermsFileName exportterms.xml -PathToSPClientdlls "C:\Program Files\Common Files\microsoft shared\Web Server Extensions\15\ISAPI" -GroupToExport 'Client Group Terms'

When running the script, (as you can see below) the progress of the exporting.

Link to the powershell file can be found on my One Drive
In my next blog I’ll explain about Importing Taxonomy into SharePoint using SharePoint.
Lastly I would like to thank two of my colleagues who without their initial work I wouldn’t have been able to create this final PS1 file. Kevin Beckett (Has no public blog) and Luis Manez (http://geeks.ms/blog/lmanez)