Archive for March, 2017

Introduction
In this article we will explore how to maintain the version of the field and fetch the attachment URL of a list item. Here, I will show how to do it using client side mode via SharePoint Web service using Webservice only ( _vit_bin/lists.asmx)..

Scenario:
The scenario is best suited when in migration from one SharePoint version to another, we need to maintain the attachment URL and the versioning of the fields using Webservice only ( _vit_bin/lists.asmx).
Solutions:
Code:
  1. public static void getListData(string weburl)
  2. {
  3.     Lists.Lists myservice = new Lists.Lists();
  4.     myservice.Credentials = System.Net.CredentialCache.DefaultCredentials;
  5.     myservice.Url = weburl + “/_vti_bin/Lists.asmx”;
  6.     try
  7.     {
  8.         /* Assign values to pass the GetListItems method*/
  9.         string listName = “Test List”;
  10.         string viewName = “”;
  11.         string rowLimit = “100”;
  12.         // Instantiate an XmlDocument object
  13.         System.Xml.XmlDocument xmlDoc = new System.Xml.XmlDocument();
  14.         System.Xml.XmlElement query = xmlDoc.CreateElement(“Query”);
  15.         System.Xml.XmlElement viewFields = xmlDoc.CreateElement(“ViewFields”);
  16.         System.Xml.XmlElement queryOptions = xmlDoc.CreateElement(“QueryOptions”);
  17.         /*Use CAML query*/
  18.         query.InnerXml = string.Format(“<Where><And>” +
  19.             “<Gt>” +
  20.             “<FieldRef Name=’ID’ /><Value Type=’Counter’>{0}</Value>” +
  21.             “</Gt>” +
  22.             “<Leq><FieldRef Name=’ID’ /><Value Type=’Counter’>{1}</Value></Leq>” +
  23.             “</And></Where>”, 0, 100);
  24.         viewFields.InnerXml = “<FieldRef Name=’Title’ />” +
  25.             “<FieldRef Name=’Created’ />” +
  26.             “<FieldRef Name=’Modified’ />” +
  27.             “<FieldRef Name=’Author’ />” +
  28.             “<FieldRef Name=’Editor’ />”;
  29.         queryOptions.InnerXml = “”;
  30.         System.Xml.XmlNode nodeListItems = myservice.GetListItems(listName, viewName, query, viewFields, rowLimit, nullnull);
  31.         XmlDataDocument xmlDocResult = new XmlDataDocument();
  32.         xmlDocResult.LoadXml(nodeListItems.InnerXml);
  33.         XmlNodeList rows = xmlDocResult.GetElementsByTagName(“z:row”);
  34.         foreach(XmlNode attribute in rows) {
  35.             Console.WriteLine(attribute.Attributes[“ows_Title”].Value);
  36.             string AttachmentUrl = GetAttachmentUrls(weburl, listName, attribute.Attributes[“ows_ID”].Value, “”);
  37.             string vesrsion = GetVersions(weburl, listName, attribute.Attributes[“ows_ID”].Value, “Title”);
  38.         }
  39.     } catch (Exception ex)
  40.     {
  41.         Console.WriteLine(ex.Message);
  42.     }
  43. }
  44. public static string GetAttachmentUrls(string siteUrl, string listId, string itemId, string fieldName)
  45. {
  46.     StringBuilder sb = new StringBuilder();
  47.     Lists.Lists listService = new Lists.Lists();
  48.     listService.Credentials = System.Net.CredentialCache.DefaultCredentials;
  49.     listService.Url = siteUrl + “/_vti_bin/lists.asmx”;#
  50.     region Get the list of attachments
  51.     XmlNode nodeAttachments = listService.GetAttachmentCollection(listId, itemId);
  52.     List < string > values = new List < string > ();
  53.     foreach(System.Xml.XmlNode xNode in nodeAttachments)
  54.     {
  55.         values.Add(xNode.InnerText);
  56.     }
  57.     return string.Join(“;”, values.ToArray());#
  58.     endregion
  59. }
  60. public static string GetVersions(string siteUrl, string listId, string itemId, string fieldName)
  61. {
  62.     StringBuilder sb = new StringBuilder();
  63.     Lists.Lists listService = new Lists.Lists();
  64.     listService.Credentials = System.Net.CredentialCache.DefaultCredentials;
  65.     listService.Url = siteUrl + “/_vti_bin/lists.asmx”;
  66.   #region Get version histories
  67.     if (!string.IsNullOrEmpty(fieldName))
  68.     {
  69.         XmlNode nodeVersions = listService.GetVersionCollection(listId, itemId, fieldName);
  70.         foreach(System.Xml.XmlNode xNode in nodeVersions)
  71.         {
  72.             string dateHistory = xNode.Attributes[“Modified”].Value;
  73.             dateHistory = FormatDateFromSP(dateHistory);
  74.             string commentHistory = xNode.Attributes[fieldName].Value;
  75.             string editor = GetEditor(xNode.Attributes[“Editor”].Value);
  76.             sb.Append(editor + ” (“ + dateHistory + “) “ + commentHistory + “\n\n”);
  77.         }
  78.     }
  79.     return sb.ToString();#
  80.     endregion
  81. }
  82. private static string FormatDateFromSP(string dateHistory)
  83. {
  84.         string result;
  85.         result = dateHistory.Replace(“T”” “);
  86.         result = result.Replace(“Z”“”);
  87.         return result;
  88.     }
  89.     /// <summary>
  90.     /// The XmlNode for version on the Editor contains the Editor Name
  91.     /// </summary>
  92.     /// <param name=”ienumEditor”></param>
  93.     /// <returns></returns>
  94. private static string GetEditor(string nodeValue)
  95. {
  96.     string[] arr;
  97.     char[] sep =
  98.       {
  99.         ‘#’
  100.     };
  101.     // Go for the Editor attribute value
  102.     // A sample is: 30;#Jo�o Faneca,#VIATECLA\\jfaneca,#joao.faneca@viatecla.pt,#joao.faneca@viatecla.pt,#Jo�o Faneca
  103.     arr = nodeValue.Split(sep);
  104.     // Grab the second element for the array
  105.     nodeValue = arr[1];
  106.     // Remove the last comma from the Editor value
  107.     return nodeValue.Remove(nodeValue.Length – 1);
  108. }
  109. }
Summary
Using SharePoint web services to retrieve the version history and attachment URLs for the list item at client side.
Advertisements

CSOM vs JSOM vs SSOM vs REST

Posted: March 12, 2017 in SharePoint2013

Introduction

In this article we will explore different hosting types and technology abbreviations used in SharePoint 2010/2013 and elsewhere too. Useful API reference of the most frequently used types and objects implemented in Server object model (SSOM) and at least one client programming model: .NET client-side object model (CSOM), JavaScript object model (JSOM), and/or REST. Here’s the difference between CSOM/ JSOM/ SSOM/ REST.

image

Model Types

  • CSOM:CSOM core assembly is Microsoft.SharePoint.Client.Runtime.dll and Microsoft.SharePoint.Client.dll, which stands for Client-Side Object Model. It is a web service based API of SharePoint. It allows access to SharePoint data and features from remote clients. CSOM was introduced in SharePoint 2010 and greatly enhanced in SharePoint 2013.SP.ClientContext.get_current() for normal use. New SP.ClientContext(‘url…’) for specific SPWeb.
  • SSOM:Server Object Model core assembly is Microsoft.SharePoint.dll which is installed in the Global Assembly Cache. The Server Object Model will be executed in the server side & it provides rich set of classes in representing & manipulating SharePoint objects. Must be deployed on same farm Server-side object model. C# (or Visual Basic) uses only Microsoft.SharePoint (14) DLL. Must be deployed on same farm.
  • REST:The SharePoint REST interface is based on the REST-based Open Data protocol (OData) which is a platform-independent open standard. REST in 2010 is only for ListData.svc. Note that SPServices (jQuery plugin) utilizes the.asmx services in _/vti/bin , such as /_vti_bin/Webs.asmx.

table

image

Model Types

CSOM:

CSOM, which stands for Client-Side Object Model, is a web services-based API of SharePoint. It allows access to SharePoint data and features from remote clients. CSOM was introduced in SharePoint 2010 and greatly enhanced in SharePoint 2013.

JSOM:

Access information in the host web using the Javascript Object Model, you need to use an SP.ClientContext.get_current() for normal use. New SP.ClientContext(‘url…’) for specific SPSite. Note this works cross-SPSite in 2013.

SSOM:

Server Object Model is the most extensive API set available for SharePoint 2013. The core assembly is Microsoft.SharePoint.dll which is installed in the Global Assembly Cache. The Server Object Model will be executed in the server side & it provides rich set of classes in representing & manipulating SharePoint objects. Must be deployed on same farm.

REST:

The REST Services in SharePoint offer nearly the same functionality like JSOM. Furthermore, it is easier to use for a developer not coming from the SharePoint world since REST interfaces are standardized. This makes the choice of technology easier than for JSOM.

Hosting

SharePoint hosted:

A SharePoint-hosted app may provision basic resources into its app web such as HTML/CSS/JS files, site column/content type/list definitions, etc. Under no circumstances can server-side code run within a SharePoint-hosted app.

Provider hosted:

Provider-hosted apps for SharePoint include components that are deployed and hosted outside the SharePoint farm. They are installed to the host web, but their remote components are hosted on another server, but is meant to be hosted more manually (i.e. On Azure). So you fire up a web application, on any server, and then use S2S to connect to SharePoint.

Sandboxed:

Remnant from 2010, can be uploaded to Solution gallery. Support for limited subset of the SSOM. No file access, so can’t deploy anything to _layouts folder. If you use the limited SSOM-part (C#) your solution will be considered deprecated. Support for templates such as list templates and content types, deployed directly to host web.

Farm solution: Full access, deploy through PowerShell.

table

Note:

Microsoft officially announced the discontinuation of Autohosted apps model in SharePoint Online/Office 365 after it has been tested for the last few months.

Introduction

SharePoint 2013 has greatly expanded the REST services available to developers. With this, we have much more SharePoint functionality exposed via JSOM and Web Services. The goal of this article is to provide how to perform basic create, read, update, and delete (CRUD) operations on lists and list items with the REST services.

SharePoint REST endpoint Overview:

The following table contains typical REST endpoint URL examples to get you started working with SharePoint data. Prepend http://server/site/_api/ to the URL fragments shown in the table to construct a fully qualified REST URL. Below is a list of the basic commands used to get List Items from a SharePoint List through the SharePoint 2013 REST Services.

URL endpoint Description Supported HTTP Method
/_api/Web/Lists/ getbytitle(‘listname’) Getting a list details by its title and updating it as well. Ifanyone changes your list title, your code will break. GET, POST
/_api/Web/Lists(guid’guid id of your list’) Same as above but changing list title will not affect the code. GET, POST
/_api/Web/Lists/getbytitle(‘ listname ‘)/Fields Retrieving all fields associated with a list and add new fields GET, POST
/_api/Web/Lists/getbytitle(‘listname’)/
Fields/getbytitle(‘fieldname’)
Getting details of a field, modifying and deleting it. GET, PUT, PATCH, MERGE, DELETE
/_api/Web/Lists/getbytitle(‘listname’)/Items Retrieving all items in a list and adding new items GET, POST
/_api/web/lists/getbytitle(‘listname’)
/GetItemById(itemId)
This endpoint can be used to get, update and delete a single item. GET, PUT, PATCH, MERGE, DELETE
/_api/lists/ getbytitle (‘’listname’)/items?$orderby=Title Order Your Results GET, POST
/_api/lists/ getbytitle (‘’listname’)/items?$select=Title,Id Retrieve Selected Column Data value GET, POST
/_api/web/lists/getbytitle(‘listname’)/Items/
?$select=Title,FieldName/Id&$expand= FieldName /Id
Retrieving the lookup value GET, POST

Now, I will demo all the operations on list items, including retrieve, create, update and delete on list items.

list

Retrieve the list items

item

Here is the main code in detail:

  1. function retriveListItem()
  2. {
  3.     $.ajax
  4.     ({
  5.         url: _spPageContextInfo.webAbsoluteUrl + “/_api/web/lists/GetByTitle(‘companyInfo’)/items?$select=Company,Industry”,
  6.         type: type,
  7.         data: data,
  8.         headers:
  9.         {
  10.             “Accept”“application/json;odata=verbose”,
  11.             “Content-Type”“application/json;odata=verbose”,
  12.             “X-RequestDigest”: $(“#__REQUESTDIGEST”).val(),
  13.             “IF-MATCH”“*”,
  14.             “X-HTTP-Method”null
  15.         },
  16.         cache: false,
  17.         success: function(data)
  18.         {
  19.             $(“#ResultDiv”).empty();
  20.             for (var i = 0; i < data.d.results.length; i++)
  21.             {
  22.                 var item = data.d.results[i];
  23.                 $(“#ResultDiv”).append(item.Company + “\t” + item.Industry + “<br/>”);
  24.             }
  25.         },
  26.         error: function(data)
  27.         {
  28.             $(“#ResultDiv”).empty().text(data.responseJSON.error);
  29.         }
  30.     });
  31. }

Create list item

create

Here is the main code in detail:

  1. function AddListItem()
  2. {
  3.     var industryVal = $(“#Industry”).val();
  4.     var Company = $(“#Company”).val();
  5.     $.ajax
  6.         ({
  7.         url: _spPageContextInfo.webAbsoluteUrl + “/_api/web/lists/GetByTitle(‘companyInfo’)/items”,
  8.         type: “POST”,
  9.         data: JSON.stringify
  10.         ({
  11.             __metadata:
  12.             {
  13.                 type: “SP.Data.TestListItem”
  14.             },
  15.             Company: Company,
  16.             Industry: industryVal
  17.         }),
  18.         headers:
  19.         {
  20.             “Accept”“application/json;odata=verbose”,
  21.             “Content-Type”“application/json;odata=verbose”,
  22.             “X-RequestDigest”: $(“#__REQUESTDIGEST”).val(),
  23.             “X-HTTP-Method”“POST”
  24.         },
  25.         success: function(data, status, xhr)
  26.         {
  27.             retriveListItem();
  28.         },
  29.         error: function(xhr, status, error)
  30.         {
  31.             $(“#ResultDiv”).empty().text(data.responseJSON.error);
  32.         }
  33.     });
  34. }

Update list item

update

Here is the main code in detail:

  1. function updateListItem()
  2. {
  3.     var industryVal = $(“#Industry”).val();
  4.     $.ajax
  5.     ({
  6.         url: _spPageContextInfo.webAbsoluteUrl + “/_api/web/lists/GetByTitle(‘companyInfo’)/items(7)”// list item ID
  7.         type: “POST”,
  8.         data: JSON.stringify
  9.         ({
  10.             __metadata:
  11.             {
  12.                 type: “SP.Data.TestListItem”
  13.             },
  14.             Industry: industryVal
  15.         }),
  16.         headers:
  17.         {
  18.             “Accept”“application/json;odata=verbose”,
  19.             “Content-Type”“application/json;odata=verbose”,
  20.             “X-RequestDigest”: $(“#__REQUESTDIGEST”).val(),
  21.             “IF-MATCH”“*”,
  22.             “X-HTTP-Method”“MERGE”
  23.         },
  24.         success: function(data, status, xhr)
  25.         {
  26.             retriveListItem();
  27.         },
  28.         error: function(xhr, status, error)
  29.         {
  30.             $(“#ResultDiv”).empty().text(data.responseJSON.error);
  31.         }
  32.     });

Delete list item

delete

Here is the main code in detail:

  1. function deleteListItem()
  2. {
  3.     $.ajax
  4.     ({
  5.         url: _spPageContextInfo.webAbsoluteUrl + “/_api/web/lists/GetByTitle(‘companyInfo’)/items(7)”,
  6.         type: “POST”,
  7.         headers:
  8.         {
  9.             “X-RequestDigest”: $(“#__REQUESTDIGEST”).val(),
  10.             “IF-MATCH”“*”,
  11.             “X-HTTP-Method”“DELETE”
  12.         },
  13.         success: function(data, status, xhr)
  14.         {
  15.             retriveListItem();
  16.         },
  17.         error: function(xhr, status, error)
  18.         {
  19.             $(“#ResultDiv”).empty().text(data.responseJSON.error);
  20.         }
  21.     });
  22. }

Summary

In this article we explored SharePoint 2013 REST API for (CRUD) operations on list items level. I’ve tried to explore crud operation using REST Services, JavaScript Client Side Object Model, and SOAP Services to work on the client side.