Consume a SharePoint 2013 Online REST feed using .NET managed code

Posted on July 6, 2014 by Sundar Narasiman

In this post, we’ll see how we can consume a SharePoint 2013 online REST feed using managed c# code. I’d be using a Provider Hosted App template in Visual Studio 2013 for this demonstration. It is very straight forward to consume a Restful .NET service by issuing HttpWebRequest from c# code and getting HttpWebResponse.

I will be invoking https://yoursite.sharepoint.com/_api/web/lists from c# code to get the list of SharePoint lists in this Office 365 site. The following screenshot shows the response for this Restful service in the browser.

Now let’s start creating a Provider hosted app project in Visual Studio 2013.

File –> New Project –> Visual C# –> Office/SharePoint –> App for SharePoint 2013 and name it as ‘ReadRESTCSharp’ & set the site for debugging and app type as ‘Provider-hosted’.

Specify the web project type as ‘ASP.NET Web Forms Application’. In the next step, Visual Studio 2013 would prompt for setting App Authentication Type, I did not see this option while using Visual Studio 2012 to create Provider hosted apps.

Set the App authentication type as ‘Use Windows Azure Access Control Service’ (mentioned in the above screenshot).

Click ‘Finish’ to create the app.

Go to ASP.NET Web Forms project and open the default.aspx.cs

Import the following three namespaces at the top.

using Microsoft.SharePoint.Client;
using System.Net;
using System.IO;

In page_load comment out the following lines of code.

//var spContext = SharePointContextProvider.Current.GetSharePointContext(Context);

            //using (var clientContext = spContext.CreateUserClientContextForSPHost())
            //{
              //  clientContext.Load(clientContext.Web, web => web.Title);
               // clientContext.ExecuteQuery();
                //Response.Write(clientContext.Web.Title);
            //}

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

Since I’m using my own developer tenant in Office 365, I would want to trust all the certificates issued by SharePoint Online to my browser. Otherwise, it will keeping popping up a message to trust the certificates in Visual Studio 2013, when I hit F5 and debug the app.

Open the TokenHelper.cs and the add the following static method ‘TrustAllCertificates’

public static void TrustAllCertificates()
        {
            //Trust all certificates
            System.Net.ServicePointManager.ServerCertificateValidationCallback =
                ((sender, certificate, chain, sslPolicyErrors) => true);
        }

If you are using Visual Studio 2012, it adds ‘TrustAllCertificates’ in TokenHelper.cs by default.
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

I will be using my Office 365 developer tenant for this demo, which forces the need to get the Access Token from Office 365 and pass it as a part of the header in the HttpWebRequest. First I need to get the ContextTokenString by invoking GetContextTokenFromRequest method in TokenHelper.cs. Then I need to get the actual SharePointContextToken by invoking ReadAndValidateContextToken method in the TokenHelper.cs. Finally I need to get AccessToken by invoking the GetAccessToken method in the TokenHelper.cs. I won’t go too detailed about this one. All the dynamics of the Token exchange is covered in one of my previous article.

Once the AccessToken is received, a HTTPWebRequest needs to be issued by setting the AccessToken with Bearer, also we need to set the HTTPRequest method as ‘GET’ and HTTPRequest accept headers as “application/json;odata=verbose”.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Net;
using System.IO;
using Microsoft.SharePoint.Client;

namespace ReadRESTCSharpWeb
{
    public partial class Default : System.Web.UI.Page
    {
        protected void Page_PreInit(object sender, EventArgs e)
        {
            Uri redirectUrl;
            switch (SharePointContextProvider.CheckRedirectionStatus(Context, out redirectUrl))
            {
                case RedirectionStatus.Ok:
                    return;
                case RedirectionStatus.ShouldRedirect:
                    Response.Redirect(redirectUrl.AbsoluteUri, endResponse: true);
                    break;
                case RedirectionStatus.CanNotRedirect:
                    Response.Write("An error occurred while processing your request.");
                    Response.End();
                    break;
            }
        }

        protected void Page_Load(object sender, EventArgs e)
        {
            
            // The following code gets the client context and Title property by using TokenHelper.
            // To access other properties, the app may need to request permissions on the host web.
            //var spContext = SharePointContextProvider.Current.GetSharePointContext(Context);

            //using (var clientContext = spContext.CreateUserClientContextForSPHost())
            //{
              //  clientContext.Load(clientContext.Web, web => web.Title);
               // clientContext.ExecuteQuery();
                //Response.Write(clientContext.Web.Title);


            //}

            TokenHelper.TrustAllCertificates();

            //Get the ContextTokenString
            string ContextTokenString = TokenHelper.GetContextTokenFromRequest(Request);



            if (ContextTokenString != null)
            {

                //Get the SharePointContextToken
                SharePointContextToken ContextToken = TokenHelper.ReadAndValidateContextToken(ContextTokenString, Request.Url.Authority);

                Uri sharepointUrl = new Uri(Request.QueryString["SPHostUrl"]);

                //Get the AccessToken
                string AccessToken = TokenHelper.GetAccessToken(ContextToken,sharepointUrl.Authority).AccessToken;

                HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(@"https://yoursite.sharepoint.com/_api/web/lists");
                request.Method = "GET";
                request.Accept = "application/json;odata=verbose";
                request.Headers.Add("Authorization", "Bearer " + AccessToken);

                HttpWebResponse response =(HttpWebResponse)request.GetResponse();
                StreamReader reader = new StreamReader(response.GetResponseStream());

                Response.Write("<h2>List of SharePoint lists in SharePoint Online fetched from managed code</h2>");
                Response.Write("<p>" + reader.ReadToEnd() + "</p>");
                Response.Flush();
            
            
            }




        }
    }
}

After executing the above we get the successful HTTPResponse which can be seen in debug mode in Visual Studio 2013.

Subscribe to my blog

How to retrieve current user in SharePoint 2013 Online using CSOM

Posted on July 1, 2014 by Sundar Narasiman

In this post, we’ll see how we can retrieve the current user in a SharePoint 2013 online site using client side object model (CSOM). We’ll be using a console application for the purpose of this demonstration.

Open Visual Studio 2013

File –> New Project –> C# –> Console application

Add reference to the following assemblies.

Microsoft.SharePoint.Client.dll

Microsoft.SharePoint.Client.runtime.dll

Import the following namespaces at the top of Program.cs

using Microsoft.SharePoint.Client;
using System.Security;

namespace Retrievecurrentuser
{
    class Program
    {
        static void Main(string[] args)
        {

            using (ClientContext oClientContext = new ClientContext(@"https://yoursite.sharepoint.com"))
            {

                //Assign User Id for your SharePoint Online tenant     
                string UserName = "userid@yoursite.onmicrosoft.com";

                //Assign password for your SharePoint online tenant
                string Password = "password";

                //Create a SecureString object from password string, needed for SharePointOnlineCredentials class
                SecureString SecurePassword = GetSecureString(Password);
                oClientContext.Credentials = new SharePointOnlineCredentials(UserName, SecurePassword);


                //load the properties of web object
                Web oWeb = oClientContext.Web;
                oClientContext.Load(oWeb);
                oClientContext.ExecuteQuery();

                //retrieve the site name
                string SiteName = oWeb.Title;

                //retrieve the current user
                oClientContext.Load(oWeb.CurrentUser);
                oClientContext.ExecuteQuery();

            Console.WriteLine("Login Name"+ oClientContext.Web.CurrentUser.LoginName);
                Console.WriteLine("Is Admin"+ oClientContext.Web.CurrentUser.IsSiteAdmin);
                Console.WriteLine("Email"+ oClientContext.Web.CurrentUser.Email);
                
                Console.ReadLine();


            }
        }

        private static SecureString GetSecureString(String Password)
        {
            SecureString oSecurePassword = new SecureString();

            foreach (Char c in Password.ToCharArray())
            {
                oSecurePassword.AppendChar(c);

            }
            return oSecurePassword;
        }

    }
}

Then create a clientcontext in the program.cs, load the web object (execute query) and then load the current user based on the web object.

Now we’ll be able to fetch the user properties like the below.

Subscribe to my blog

SharePoint Conference Videos 2014

Posted on April 15, 2014 by Sundar Narasiman

The SharePoint Conference 2014 videos are available in Channel9.
Please check it out
http://channel9.msdn.com/Events/SharePoint-Conference/2014

How to create a simple Remote Event Receiver for a Custom List in Office 365 SharePoint 2013 site

Posted on March 28, 2014 by Sundar Narasiman

In this article, we’ll see how to create a remote event receiver for a custom list (in App Web) in SharePoint 2013 Online. The Remote Event Receivers are components (classes) that makes SharePoint Apps to respond to events that occur in SharePoint lists or items.

Create a new App in Visual Studio 2012 and name it as ‘CustomListEventReceiver’

Set the Office 365 SharePoint site for debugging the App and select App Type as SharePoint Hosted App

Now the app project is created. The next step is to create or set up a Custom List in the App.

Right Click –> Add New Item –> List and name it as ‘TestCustomList’

Select ‘Default(CustomList)’ for Create a custom list template and list instance of it –> Finish

Now the Custom List is created. The next step is to add the Remote Event Receiver.

Right Click –> Add New Item –> RemoteEventReceiver and name it as TestEventReceiver.

This creates a RemoteWeb Project containing .svc file listening for remote events . The whole ideas is that in SharePoint 2013, the event handling for Lists and Items happened outside of SharePoint in the WCF Service (inside RemoteWeb Project).

Select the following 3 events to be handled

Now you’ll see a remote event receiver project (.svc file inside it) created as the part of the Solution.

Remove the ClientId and ClientSecret from Web.Config file

<add key="ClientId" value="b0b7eb35-8980-4910-a3f6-f7129bb16466" />
<add key="ClientSecret" value="oVS2tUbGHbnWEQMPk2i5VvwdyOH04iiWJZmp0N9HXSE=" />

Open the AppManifest.xml file and change the AppPrincipal to internal

<AppPrincipal>
   <Internal/>   
 </AppPrincipal>

Go to Project Properties in Visual Studio 2012 and set the following properties

Since this App is running in Office 365, we need to set an Azure Service Bus connection string is required for debugging the remote event receiver (.svc component). Otherwise, we’ll get this debugging error mentioned in one of my previous article.

Go to Elements.xml of default.aspx under Pages.xml.

Remove the following File tag in the Elements.xml

<File Path="PagesDefault.aspx" Url="Pages/Default.aspx" ReplaceContent="TRUE" />

Add the following File tag inside Elements.xml

 <File Path="PagesDefault.aspx" Url="Pages/Default.aspx" >
      <AllUsersWebPart WebPartZoneID="full" WebPartOrder="0">
        <![CDATA[ 
      <webParts>
      <webPart xmlns="http://schemas.microsoft.com/WebPart/v3">
      <metaData>
      <type
    name="Microsoft.SharePoint.WebPartPages.XsltListViewWebPart,
    Microsoft.SharePoint,Version=14.0.0.0,Culture=neutral,
    PublicKeyToken=71e9bce111e9429c" />
      <importErrorMessage>
      Cannot import this Web Part.
      </importErrorMessage>
      </metaData>
      <data>
        <properties>
          <property name="Title"
           type="string">TestCustomList</property>
          <property name="ListDisplayName"
           type="string">TestCustomList</property> 
           <property name="ChromeType"
           type="chrometype">TitleOnly</property>
        </properties>
      </data>
    </webPart>
  </webParts>
]]>
      </AllUsersWebPart>
    </File>

The above File element inserts an XSLST List View web part to render the list items of TestCustomList with the column name Title.

Open default.aspx and add the following webpart definition inside the PlaceHolderMain (just outside of the div containing <p> with id as message)

<WebPartPages:WebPartZone runat="server" FrameType="TitleBarOnly" ID="full" Title="loc:full" />

Open TestEventReceiver and implement the ProcessEvent(SPRemoteEventProperties properties) method for the ItemAdding and ItemDeleted events

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint.Client;
using Microsoft.SharePoint.Client.EventReceivers;

namespace CustomListEventReceiverWeb.Services
{
    public class TestEventReceiver : IRemoteEventService
    {
        public SPRemoteEventResult ProcessEvent(SPRemoteEventProperties properties)
        {
            SPRemoteEventResult oResult = new SPRemoteEventResult();
                       
            

            switch (properties.EventType)
            {
                case SPRemoteEventType.ItemAdding:


                   
                    
                    oResult.ChangedItemProperties.Add("Title", properties.ItemEventProperties.AfterProperties["Title"] += "Sundar");
                    break;

                case SPRemoteEventType.ItemDeleting:
                    oResult.ErrorMessage = "You cannot delete this list item";
                    oResult.Status = SPRemoteEventServiceStatus.CancelWithError;
                    break;
            }


            return oResult;
        }

        public void ProcessOneWayEvent(SPRemoteEventProperties properties)
        {
            if (properties.EventType == SPRemoteEventType.ItemAdded)
            {
                //Do something here ...
            }
        }
    }
}

Hit F5 and run the CustomListEventReceiver app

Now we’ll see the item Title appended with “Sundar” (execution of ItemAdding event)

When we try to delete the item, it throws an error message “You cannot delete this list item” (execution of item deleted event).

Subscribe to my blog

Retrieve Person or Group field using SharePoint 2013 Client Object Model

Posted on September 27, 2013 by Sundar Narasiman

I’m involved in troubleshooting a crazy people picker field issue in SharePoint 2013, which necessitates me to programmatically query the Person or Group field of SharePoint list using Client Object model. I was trying to figure out the exact syntax that can be used to grab the Person or Group field using FieldUserValue objects. Here is the complete code below :-

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Client;
using System.Net;

namespace ReadApproverNameField
{
    public class Program
    {
        static void Main(string[] args)
        {
            GetApproverDetails();
            Console.ReadLine();

        }

        public static void GetApproverDetails()
        {
            ClientContext clientContext = new ClientContext(http://servername/sites/sitecollectionname);
            
            NetworkCredential oNetworkCredential = new NetworkCredential();
            oNetworkCredential.Domain = @"Domain Name";
            oNetworkCredential.UserName = @"User Id";
            oNetworkCredential.Password = @"Password";
            clientContext.Credentials = oNetworkCredential;

            List list = clientContext.Web.Lists.GetByTitle("Name of the list");

            CamlQuery camlQuery = new CamlQuery();
            camlQuery.ViewXml = "<View/>";
            ListItemCollection listItems = list.GetItems(camlQuery);
            clientContext.Load(list); 
            clientContext.Load(listItems);
            clientContext.ExecuteQuery();


            foreach (ListItem oListItem in listItems)
            {
                
                FieldUserValue name = oListItem.FieldValues["ApproverName"] as FieldUserValue;
                string person = name.LookupValue;                
                Console.WriteLine(oListItem.Id + "     " + oListItem["Title"].ToString() + "     " + person);


            }
        }
    }
}

Basically we cannot create a new instance of FieldUserValue object, it needs to be casted from the current item’s field using ‘as FieldValue’ syntax

and then the LookupValue need to be invoked to fetch the value. If we run the above code, we’ll get the output below.

Subscribe to my blog

Programmatically update Author and Editor fields in SharePoint

Posted on July 17, 2013 by Sundar Narasiman

I’m working on a data-migration scenario, where there is a need to update the CreatedBy (Author) and ModifiedBy(Editor) fields in SharePoint.

            using (SPSite oSPSite = new SPSite(http://yoursitecollectionurl))
            {
                using (SPWeb oSPWeb = oSPSite.RootWeb)
                {
                    SPList oSPList = oSPWeb.Lists["testlist"];


                    foreach (SPListItem oSPListItem in oSPList.Items)
                    {
                        SPFieldUserValue oSPFieldUserValue = new SPFieldUserValue(oSPWeb, oSPWeb.AllUsers[@"domainuser"].ID,

                           oSPWeb.AllUsers[@"domainuser"].LoginName);

                        oSPListItem["Author"]= oSPFieldUserValue;
                        oSPListItem["Editor"]= oSPFieldUserValue;
                        oSPListItem.Update();                      

                                        }
                
                }

The above code-snippet updates the Author and Editor fields of SharePoint list, based on the specific user (SPFieldUserValue object).

string sourceSiteURL = "Your site url";//site to be exported SPExportObject exportObject = "Path where you site to be exported"; string folderPath = "folder path"; using (SPSite sourceSite = new SPSite(sourceSiteURL)) { using (SPWeb sourceWeb = sourceSite.OpenWeb()) { //Create the Export Setting object and update the setting properties. SPExportSettings settings = new SPExportSettings(); settings.SiteUrl = sourceWeb.Url; settings.ExportMethod = SPExportMethodType.ExportAll; settings.BaseFileName = EXPORT_FILENAME; // "export.cmp"; settings.FileLocation = "provide file location"; settings.LogFilePath = @folderPath + LOG_FILENAME; // "LogFile.log"; settings.IncludeSecurity = SPIncludeSecurity.All; setExcludeDependencies(migrationSettings, settings); settings.OverwriteExistingDataFile = true; settings.CommandLineVerbose = true; settings.FileMaxSize = 1024; settings.FileCompression = true; // Add the Export object to the ExportSetting Object settings.ExportObjects.Add(exportObject); // add the Export Settings to the SPExport object and Run the Export . SPExport export = new SPExport(settings); export.Run(); LogAll.logTextWriting(true, ServerConstant.exportSuccessfully); isExportCompleted = true; } }

// Get the Site collection Url from the config file. using (SPSite rootSiteColl = new SPSite(destinationSiteURL)) { SPWebApplication webApp = rootSiteColl.WebApplication; rootSiteColl.AllowUnsafeUpdates = true; using (SPWeb rootWeb = rootSiteColl.OpenWeb()) { // Package import System.Uri siteURL = new Uri(destinationSiteURL); string baseDataFileName = EXPORT_FILENAME; // "export.cmp"; string dataFileLocation = @folderPath; string logFileLocation = @folderPath + LOG_FILENAME; // "LogFile.log"; SPImportSettings importSettings = new SPImportSettings(siteURL, dataFileLocation, baseDataFileName); importSettings.IncludeSecurity = SPIncludeSecurity.All; importSettings.RetainObjectIdentity = true; importSettings.CommandLineVerbose = true; importSettings.LogFilePath = logFileLocation; importSettings.WebUrl = destinationSiteURL; importSettings.FileCompression = true; SPImport import = new SPImport(importSettings); import.Run(); rootWeb.AllowUnsafeUpdates = false; webApp.FormDigestSettings.Enabled = true; webApp.FormDigestSettings.Expires = true; rootWeb.Close(); } rootSiteColl.AllowUnsafeUpdates = false; } The power of the import functionality is that we can pick and choose whether to retain the security, versions, object ids etc. The main drawback of this approach

$spserver = [Microsoft.SharePoint.Administration.SPWebService]::ContentService.DeveloperDashboardSettings; $spserver.DisplayLevel = [Microsoft.SharePoint.Administration.SPDeveloperDashboardLevel]::OnDemand; $spserver.RequiredPermissions = 'EmptyMask'; $spserver.TraceEnabled = $true; $spserver.Update();

$spserver = [Microsoft.SharePoint.Administration.SPWebService]::ContentService.DeveloperDashboardSettings; $spserver.DisplayLevel = [Microsoft.SharePoint.Administration.SPDeveloperDashboardLevel]::On; $spserver.RequiredPermissions = 'EmptyMask'; $spserver.TraceEnabled = $true; $spserver.Update();

using System; using System.Collections.Generic; using System.Linq; using System.Runtime.Serialization; using System.ServiceModel; using System.ServiceModel.Web; using System.Text; namespace CreditCardService { // NOTE: You can use the "Rename" command on the "Refactor" menu to change the class name "VadlidationService" in code, svc and config file together. public class VadlidationService : IVadlidationService { public string GetCountry(int value) { return "India"; } } }

using System; using System.Collections.Generic; using System.Linq; using System.Runtime.Serialization; using System.ServiceModel; using System.ServiceModel.Web; using System.Text; namespace CreditCardService { [ServiceContract] public interface IVadlidationService { [OperationContract] string GetCountry(int value); // TODO: Add your service operations here } }

using System; using System.Collections.Generic; using System.Linq; using System.Text; using Microsoft.SharePoint.UserCode; namespace SimpleProxy { [Serializable] [Microsoft.SharePoint.Security.SharePointPermission(System.Security.Permissions.SecurityAction.LinkDemand, ObjectModel = true)] public class SimpleProxyArgs : SPProxyOperationArgs { public int CountryId { get; set; } public static string ProxyOperationTypeName { get { return "SimpleProxy.SimpleProxyOps"; } } public static string ProxyAssemblyName { get { return "SimpleProxy, Version=1.0.0.0, Culture=neutral, PublicKeyToken=a3daa9085766b846"; } } } }

using System; using System.Collections.Generic; using System.Linq; using System.Text; using Microsoft.SharePoint.UserCode; using Microsoft.SharePoint; using Microsoft.SharePoint.Security; using System.Runtime.Serialization; using System.ServiceModel; namespace SimpleProxy { [Microsoft.SharePoint.Security.SharePointPermission(System.Security.Permissions.SecurityAction.LinkDemand, ObjectModel = true)] public class SimpleProxyOps : SPProxyOperation { public override object Execute(SPProxyOperationArgs args) { WSHttpBinding oWSHttpBinding = new WSHttpBinding(SecurityMode.Message); oWSHttpBinding.Name = "WSHttpBinding_IVadlidationService"; oWSHttpBinding.CloseTimeout = new TimeSpan(0, 1, 0); oWSHttpBinding.OpenTimeout = new TimeSpan(0, 1, 0); oWSHttpBinding.ReceiveTimeout = new TimeSpan(0, 10, 0); oWSHttpBinding.SendTimeout = new TimeSpan(0, 1, 0); oWSHttpBinding.BypassProxyOnLocal = false; oWSHttpBinding.TransactionFlow = false; oWSHttpBinding.HostNameComparisonMode = HostNameComparisonMode.StrongWildcard; oWSHttpBinding.MaxBufferPoolSize = 524288; oWSHttpBinding.MaxReceivedMessageSize = 65536; oWSHttpBinding.MessageEncoding = WSMessageEncoding.Text; oWSHttpBinding.TextEncoding = Encoding.UTF8; oWSHttpBinding.UseDefaultWebProxy = true; oWSHttpBinding.AllowCookies = false; oWSHttpBinding.ReaderQuotas.MaxDepth = 32; oWSHttpBinding.ReaderQuotas.MaxStringContentLength = 8192; oWSHttpBinding.ReaderQuotas.MaxArrayLength = 16384; oWSHttpBinding.ReaderQuotas.MaxBytesPerRead = 4096; oWSHttpBinding.ReaderQuotas.MaxNameTableCharCount = 16384; oWSHttpBinding.ReliableSession.Ordered = true; oWSHttpBinding.ReliableSession.InactivityTimeout = new TimeSpan(0, 10, 0); oWSHttpBinding.ReliableSession.Enabled = false; oWSHttpBinding.Security.Mode = SecurityMode.Message; oWSHttpBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Windows; oWSHttpBinding.Security.Transport.ProxyCredentialType = HttpProxyCredentialType.None; oWSHttpBinding.Security.Transport.Realm = ""; oWSHttpBinding.Security.Message.ClientCredentialType = MessageCredentialType.Windows; oWSHttpBinding.Security.Message.NegotiateServiceCredential = true; EndpointAddress oEndPointAddress = new EndpointAddress(new Uri("http://lt012464.abc.com:1414/CreditCardService/ValidationService.svc")); var proxyArgs = args as SimpleProxyArgs; int CountryId = proxyArgs.CountryId; SimpleProxy.VadlidationServiceClient ovsc = new SimpleProxy.VadlidationServiceClient(oWSHttpBinding, oEndPointAddress); string result = ovsc.GetCountry(0); return result; } } }

public override void FeatureActivated(SPFeatureReceiverProperties properties) { SPUserCodeService userCodeService = SPUserCodeService.Local; var simpleOperation = new SPProxyOperationType(SimpleProxyArgs.ProxyAssemblyName,SimpleProxyArgs.ProxyOperationTypeName); userCodeService.ProxyOperationTypes.Add(simpleOperation); userCodeService.Update(); }

namespace SharePointSaturdayWebPart.SharePointSaturdayWebPart { [ToolboxItem(false)] public partial class SharePointSaturdayWebPart : System.Web.UI.WebControls.WebParts.WebPart { protected override void OnInit(EventArgs e) { base.OnInit(e); InitializeControl(); } protected void Page_Load(object sender, EventArgs e) { var proxyArgs = new SimpleProxyArgs(); proxyArgs.CountryId = 1; var result = SPUtility.ExecuteRegisteredProxyOperation(SimpleProxyArgs.ProxyAssemblyName,

Musings on Cloud, Machine Learning, Kubernetes, MLOps and Distributed Systems

Category Archives: SharePoint Development

Consume a SharePoint 2013 Online REST feed using .NET managed code

How to retrieve current user in SharePoint 2013 Online using CSOM

SharePoint Conference Videos 2014

How to create a simple Remote Event Receiver for a Custom List in Office 365 SharePoint 2013 site

Retrieve Person or Group field using SharePoint 2013 Client Object Model

Programmatically update Author and Editor fields in SharePoint

Migrate SharePoint sites using Content Migration APIs

SharePoint 2013 Programmatically read list items using Java Script

SharePoint 2010 Developer Dashboard Faqs

Consuming a WCF service from SharePoint 2010 Sandbox Solutions