Everything began from nothing.

Friday, 17 February 2017

SharePoint XSN provisionning with WSP

it's not very simple to package a form xsn in the wsp solution, specialy if you want to do a provisionning.

You probably tried to use something like:
1 <elements xmlns="http://schemas.microsoft.com/sharepoint/">
2    <module name="DefaultForms" rootwebonly="FALSE" url="Lists/Forms">
3      <file path="DefaultForms\TestForm.xsn" type="GhostableInLibrary" url="TestForm.xsn"/>
4    </module>
5 </elements>

But if you just put the XSN files in a module and deploy it to a Form-library like this, or just upload the xsn file to the library, the Info Path form will not be able to render (error: form is not browser enabled).
What you have to do to fix this is adding some extra properties:
 1 <elements xmlns="http://schemas.microsoft.com/sharepoint/">
 2   <module 
 3        name="DefaultFormulieren" 
 4        rootwebonly="FALSE" 
 5        url="Lists/Forms">
 6      <file path="DefaultForms\myform.xsn" 
 7            type="GhostableInLibrary" url="TestForm.xsn">
 8        <property name="ContentTypeId"
 9                  value="XXXXXXXXXXXXXXXXXXXXXXXXXXX"/>
10        <property name="ContentType" value="Form"/>
11        <property name="vti_contenttag" type="string" 
12                  value="{xxxxxxxxxxxxxxxxxxxxxxxxx},2,1"/>
13        <property name="ipfs_streamhash" type="string"
14                  value="u+Z+9oSpboLO+KfE7V3NmgN0DfxlgCQB0/R8/S3pVBM="/>   

15      </file>
16   </module>
17 </elements>

  • ContentTypeId and ContentType are self explaining, but how to find the vti_contenttag and ipfs_streamhash?

  1.  open the form in InfoPath-designer and publish it to a SharePoint site.
  2.  create a WSP from the existing site.

If it’s a publishing site you cannot in a normal way access the ‘save site as template’ page. So you should browse to / _layouts/savetmpl.aspx. There's no shame in doing this (or in forgetting), just remeber that it's hidden for a reason!

Make sure ‘Include content’ is selected.
Download the WSP and rename to .cab
Now you can extract this file with (for example) winrar.
Browse to the just extracted files. 

Open the Modules folder
Under 'files' you’ll find the XSN file (under a subfolder with the name of the library), I always use this file to be absolutely sure it’s exactly the same as when a user publishes the original XSN with infopath.

Go back to the root folder of your extracted WSP and open the 'propertybag' folder.
In this folder open the elements.xml. 

Find the File tag for your XSN file. (just search for .xsn).

Here you’ll find the vti_contenttag and ipfs_streamhash values. You can just add these to your module, since SharePoint itself figures out if values are fields or need to be set to the propertybag.

Thursday, 16 February 2017

Deploy Info path using PowerShell, SharePoint 2013

This post aims to describe how to deploy infopath forms as form templates in a sharepoint site using Powershell.

This post will not detail out how to create a custom infopath form. It will assume that there is already an existing Infopath source files that are for deployment.
Sharepoint 2010
Microsoft Infopath Designer 2010


1.Locate the manifest.xml, right-click and click on Design. The Infopath Designer should load.

2.Whenever modifications have been made to the form, it is a good practice to change the version of the infopath form. This is because when you create a version 1.0 and so on for a form, all of the previous versions will be saved in Sharepoint. To do this, Click on File on the Infopath Form Designer. On the Info Ribbon tab, Click on Advanced Form Options.
The Form Option dialog box should appear.

3.Change the version on the Version field.
4.[Not Required] If you would like to create another set of source files for the modified Infopath form, you can do so by re-exporting the source files into another location.
Click File and select the Publish Ribbon. Click on the Export Source Files.

5.Select the folder where you want to save the Source Files. On the Folder field, type in the folder name where you want to save the files.

6.To publish your form into an Infopath .xsn format, Click on File and Click on the Info Ribbon Tab. On the Info Ribbon Tab, Click on the Quick Publish button.

7.Please take note on the location of the .xsn to be published. The directory is displayed on the right hand part of the Quick Publish section.

8.This operation will result in the creation of a .xsn file. A .xsn file defines the data structure, appearance, and behavior of Finished forms. This particular file is what is to be deployed in sharepoint.

9.Deploy Infopath form using Powershell. Click on Start>All Programs>Microsoft Sharepoint 2010 Products. Click on Sharepoint 2010 Management Shell.

10.To Uninstall the existing xsn Form Template. Type in the Management shell

Uninstall-SPInfoPathFormTemplate -Identity Exampleform.xsn

11.Install the new solution based on the .xsn file path. For example, the .xsn is located in drive c:/

Install-SPInfoPathFormTemplate -Path C:\Form.xsn

12.To disable the feature on the site collection level, type in the management shell. For example, the site collection URL is http://SPSite.

Disable-SPInfoPathFormTemplate -Identity "Form.xsn" -Site http://SPSite 

13.To enable the feature on the site collection level, type in the management shell. For example, the site collection URL is http://SPSite.

Enable-SPInfoPathFormTemplate -Identity "Form.xsn" -Site "http://SPSite"

14.Verify that the form was indeed deployed on the Sharepoint site. Browse to your site, make sure that you have the necessary rights to view the Form Templates. Click on Site Actions > View All Site Contents and Click on Form Templates.

15.The Infopath form should be on the List of the Form Templates.

Source :http://sharepointfruity.blogspot.com/2012/09/infopath-deployment-using-powershell.html 

Friday, 10 February 2017

Activate / Deactivate Feature with PowerShell on all site collections of the webapp


When we do some change on the solution  specially on the branding  for exmple ( display teamplate),we should update also existing sites collection and replace old files with new one after the deployment. So this powershell Script with do this on the all farm.
$feature = Get-SPFeature -Identity "ID OF THE FEATURE"
$siteCollections = Get-SPSite –WebApplication $webhubUrl -Limit ALL
$siteCollections | foreach-object {
   Write-Host "Deactivating" $feature.DisplayName "on" $_.Url -foregroundcolor yellow
   Disable-SPFeature $feature -Url $_.Url -confirm:$false

$siteCollections | foreach-object {
   Write-Host "Activating" $feature.DisplayName "on" $_.Url -foregroundcolor green
   Enable-SPFeature $feature -Url $_.Url

Thursday, 26 January 2017

Build a RESTtful Application using C#

Hello Everyone,

we will build a Restful application with C#,
First of all , we should have :
-Visual Studio
-A WebBrowser

-Create a new solution with C#
-Create a new Library project and create an Interface.

[ServiceContract(Name = "RESTDemoServices")] // specifiy the name of the services in this WS ...
[WebGet(UriTemplate = Routing.GetClientRoute, // the root BodyStyle = WebMessageBodyStyle.Bare // the body style ( encapsulate) ,RequestFormat =WebMessageFormat.Json) // output type JSON ]
-create a new Rooting class :
public static class Routing
public const string GetClientRoute = "/Client/{id}";
public const string HelloWorld = "/hello/{value}";
this class specify roots in the app : localhost:8000/DEMOService/hello/7ouma
-create a new class :
implement the methods :D

-create a Console project and in Program.cs

Execute and test the methods in browser :
http://localhost:8000/DEMOService/hello/[your text]

Thanks and Share.

Tuesday, 17 January 2017

SharePoint 2013 Autocomplete textbox using the term store and CSOM

Hello Everyone,

you don't have sometimes the idea to customise the textbox by getting the terms from the termstore ?
if yes, continue reading this post,
ok it's very easy let's start:
you need  jQuery UI Autocomplete.  

The code loads the terms from the term store and then sets the source.

  This implementation is really only ideal for a small amount of terms, but it’s enough to get you started.

For this example, I am going to use a simple set of terms using state names in the United States.  My terms are included in a group named Jobs and a Term Set named Persons.  Here is what my term store looks like.

In this example, we’re going to build our code inside a Client Web Part.  Take a look at that post if you are not familiar with the process yet.  We then need to add a heap of JavaScript references.  Some of these are included already, but specifically we need to load SP.Taxonomy.js.  We also need to include init.js as I mentioned in an earlier blog post.
<script type="text/javascript" src="../Scripts/jquery-1.7.1.min.js"></script>
<script type="text/javascript" src="/_layouts/15/MicrosoftAjax.js"></script>
<script type="text/javascript" src="/_layouts/15/init.js"></script>
<script type="text/javascript" src="/_layouts/15/sp.runtime.js"></script>
<script type="text/javascript" src="/_layouts/15/sp.js"></script>
<script type="text/javascript" src="/_layouts/15/sp.taxonomy.js"></script>
My web part is called AutocompleteWebPart.aspx so I am going to add a JavaScript file for my code called AutocompleteWebPart.js.  We also need to include a reference to jQuery UI  You’ll need to download this and include it in your project or pull it from a CDN.
<script type="text/javascript" src="../Scripts/AutocompleteWebPart.js"></script>
<script type="text/javascript" src="../Scripts/jquery-ui-1.9.1.custom.min.js"></script>
Lastly to use jQuery UI, you need to include it’s CSS file in the Content folder of your project.
<link rel="Stylesheet" type="text/css" href="../Content/jquery-ui-1.8.22.custom.css"/>
Now, I am just going to add a textbox to the body of our page.
        <input id="autocompleteTextBox" type="text" />
The process for querying terms is involved.  You first need to get a reference to the Taxonomy Session, followed by the Group, the Term Set, and finally you can iterate the terms.  There are a lot of good examples out there but many of them take short cuts by using GUIDs for values for things like the group and term set.  This works but is absolutely useless when you are writing proper code that can be deployed to any environment.  You need to be able to reference these items by name, but unfortunately the API makes accessing anything in the term store by name difficult.  It’s not impossible though, it just requires extra code and iteration.  Let’s walk through our JavaScript example below with absolutely no hard-coded GUIDs.
We’ll start by adding some global variables.  We’ll populate these as we go.
var context;

var session;
var termStore;
var groups;
var termSets;
var termsArray = [];
We’ll start in a document ready function.  We use the standard code to get a reference to the current context.  We’ll need this to create a new TaxonomySession object.  We then session.GetDefaultSiteCollectionTermStore() to get the default term store.  From there, we need to context.load on the session and termStore objects.  We then use a typical executeQueryAsync method to execute our query.  The onTaxonomySession method will handle success and we’ll use a shared onTaxonomyFailed method to handle any failures.
    function () {
        context = new SP.ClientContext.get_current();

        session = SP.Taxonomy.TaxonomySession.getTaxonomySession(context);
        termStore = session.getDefaultSiteCollectionTermStore();
        context.executeQueryAsync(onTaxonomySession, onTaxonomyFailed);
Just like with the managed API, you must configure your Managed Metadata Service Application Client appropriately in order for the default term store call to work.  Click on the Managed Metadata Service Connection and then click Properties.  Now, make sure the checkbox next to This service application is the default storage location for column specific term sets is checked.  Once, you have made this change your code should work.

The onTaxonomySession method then retrieves a list of groups.  We have to retrieve all groups because there isn’t a method to just retrieve one by name.  Although there is a method to retrieve a group by id.  Since we don’t want to hard code any GUIDs though.  We have to retrieve all groups and iterate them to find the one we want.  A successful query will call onGroupsLoaded.
function onTaxonomySession() {
    groups = termStore.get_groups();
    context.executeQueryAsync(onGroupsLoaded, onTaxonomyFailed);
In this method we have a list of the groups so we need to iterate through them and find the one we want.  In this case, Classification.  The code isn’t ideal but it works.  We start by getting an enumerator with getEnumerator().  We then use this enumerator to examine the groups.  In our loop, we use get_current() to get currentGroup.  We then use get_name() to compare against the one we want.  When a match is found, we call another method getTermSets and pass the term set.
function onGroupsLoaded() {
    // iterate termStores
    var groupEnumerator = groups.getEnumerator();

    while (groupEnumerator.moveNext()) {
        var currentGroup = groupEnumerator.get_current();
        if (currentGroup.get_name() == 'Jobs')
In the getTermSets method, we call get_termSets.
function getTermSets(currentGroup) {
    termSets = currentGroup.get_termSets();
    context.executeQueryAsync(onTermSetsLoaded, onTaxonomyFailed);
The onTermSetLoaded method will then iterate through the term sets returned and compare by name in the same way.  In this case, we are looking for the term set named States.  When the match is found, we call getTerms().
function onTermSetsLoaded() {
    var termSetEnumerator = termSets.getEnumerator();

    while (termSetEnumerator.moveNext()) {
        var currentTermSet = termSetEnumerator.get_current();
        var termSetName = currentTermSet.get_name();
        if (termSetName == 'Person')
This is now the last call we need to make.  This retrieves all of the terms for the term set.  Unfortunately, we have to get all of them (as far as I know) which is why I don’t recommend this with large term sets.
function getTerms(termSet) {
    terms = termSet.get_terms();
    context.executeQueryAsync(onTermsLoaded, onTaxonomyFailed);
The onTermsLoaded method will iterate through the terms and add them to an array that the jQuery UI autocomplete method will accept.  There you have it all of the code to get items from a term set without a hard coded GUID.  It’s a lot of code, but not too bad once you get used to it.
Lastly, we’ll get a reference to our textbox and use the .autocomplete() method passing in the value of our array.
function onTermsLoaded() {
    var termsEnumerator = terms.getEnumerator();

    while (termsEnumerator.moveNext()) {
        var currentTerm = termsEnumerator.get_current();

    $("#autocompleteTextBox").autocomplete({ source: termsArray });
At this point, we are done, but we do need to implement our failure method.
function onTaxonomyFailed(sender, args) {
    alert('Taxonomy Error:' + args.get_message());
If you are using this code in an app, the last thing you need to do is set the Taxonomy permission to Read in the AppManifest.xml file.  This will let us query the term store.

At this point, we can test it.  Deploy your app and add the app part to a page.

So, a little code involved here but the results are great.  You can configure the jQuery autocomplete plugin in a variety of ways too.  This code could probably be optimized some so if you have improvements, let me know.

Create an OTB SharePoint notification


Today i will show you how we can create a sharePoint notification  using the SP.UI.Notify.addNotification with javaScript :

   var nid = SP.UI.Notify.addNotification("<img src='/_layouts/15/images/loadingcirclests16.gif?rev=23' style='vertical-align:bottom; display:inline-block; margin-" + (document.documentElement.dir == "rtl" ? "left" : "right") + ":2px;' />&nbsp;<span style='vertical-align:top;'>your custom message.</span>", false);

this is the result:

Set custom level permission SharePoint PowerShell


Some time we need to apply a script on all the web application, today we can set the permission level for a specific group.

for the base permission you can use:

below the script :

$sites = get-spsite -Limit ALL –webapplication [webapp url]
ForEach ($spSite in $Sites)       

$spWeb = $spSite.RootWeb

# Enter the Name of the Permission Level to Change

if ($PermissionLevel=$spWeb.RoleDefinitions["custom deinifition"])

Write-Host "working with : " $spSite -ForegroundColor Green
$bps = $PermissionLevel.BasePermissions

Write-Host "saving base permission ..."
Write-Host $bps -ForegroundColor Cyan

# Enter all the permissions that Permission Level should have enabled


Write-Host "Applying new base permission on ..."
Write-Host  $PermissionLevel.BasePermissions -ForegroundColor Magenta

Write-Host "no custom definition  in " $spSite -red