PLEASE NOTE: THIS IS STRICTLY A CONCEPT THAT I HAVE UTILIZED AND MAY/MAY NOT CONFIRM TO OFFICIAL MICROSOFT PRODUCT GROUP STATEMENT

With SharePoint 2013, the emphasis is on loosely coupled architecture that utilizes CSOM/REST. Going forward, it is recommended that custom Solutions like Web Parts be built as Apps or App parts, Event Receivers be Remote Event receivers etc. App scoped External Content Type for BCS is possible as well, and same goes for Workflows. In fact the Workflow framework utilizes Workflow Manager 1.0 that runs outside the SharePoint process.

So, the benefits are two-fold:

1) Secure SharePoint Farm from us ‘Developers’ writing against w3wp.exe :)

2) Ensure our solutions work seamlessly in SharePoint Online as well.

All good; but what happens to Custom Timer Job that we all have been writing in the past. Though I can still write it using Server Side Object Model (SSOM) for On Premises, it doesn’t really confirm to the recommendation and what happens with SharePoint Online (SP-O)? No SSOM possible :(

Well, here is what I did to create a Custom Timer Job Simulator service that’s uses App Model & CSOM. Now, this service doesn’t inherits SPJobDefinition but instead this Windows Service runs based on a schedule and utilizes CSOM to perform what is required.

It’s a two step process.

• Create a Provider Hosted App that uses App Only policy for SharePoint 2013/Online
• Create a Windows service that utilizes the code created above

Step 1. Create a Provider Hosted App that uses App Only policy

Steve Peschka has this nice blog post that highlights the use of Apps with App Only policy at Security in SharePoint Apps - Part 6. Also, Kirk Evans[MSFT] has a fantastic post on the subject at SharePoint 2013 App Only Policy Made Easy.

This gives us a head start onto creating Provider Hosted Apps that utilizes ‘AppOnly; policy. If you are working with On Premise then you have the flexibility to use either High Trust or Low Trust Apps. But in SP-O you can only use Low Trust. Setting up a low trust App for SP-O is simple with no additional configuration as o365 has an ACS. But for On-Premise please visit here to set it up.

1. For simplicity let’s just use Low Trust App since it works with On-Premise & SP-O. So go ahead and create a SharePoint Provider Hosted App using Visual Studio 2012 (don’t change the default option of using ACS).

Below is the snapshot of the code used inside my Low Trust App. It creates an ‘AppOnlyAccessToken’ that’s used to create the ‘ClientContext’ which eventually updates a custom List. This could very well do any other task as well (things which are possible with the powerful CSOM). Verify that the App works fine with both On Premise & Online. Full sample code solution is attached below.

   protected void Page_Load(object sender, EventArgs e)
        {
            //constant string SharePoint principal
            string SharePointPrincipal = "00000003-0000-0ff1-ce00-000000000000";

            var contextToken = TokenHelper.GetContextTokenFromRequest(Page.Request);
           
            Uri hostWeb = new Uri(Page.Request["SPHostUrl"]);

            string realm = TokenHelper.GetRealmFromTargetUrl(hostWeb);

            string appOnlyAccessToken = TokenHelper.GetAppOnlyAccessToken(SharePointPrincipal, hostWeb.Authority, realm).AccessToken;

            using (ClientContext clientContext = TokenHelper.GetClientContextWithAccessToken(hostWeb.ToString(), appOnlyAccessToken))
            {
               
                if (clientContext != null)
                {
                    //ShariqTest is a custom List in my SharePoint site -both Om Prem & Online
                    var myList = clientContext.Web.Lists.GetByTitle("ShariqTest");
                    ListItemCreationInformation listItemCreate = new ListItemCreationInformation();
                    Microsoft.SharePoint.Client.ListItem newItem = myList.AddItem(listItemCreate);
                    newItem["Title"] = "Testing " ;
                    newItem.Update();
                    clientContext.ExecuteQuery();
                }
            }
        }

2.  If you are looking at using only the High Trust App, then the process pretty much remains same. The code to get ‘AppOnlyAccessToken’ is a bit different. Please follow this and the attached sample that Steve Peschka shared.

3. Please provide appropriate App permissions.  

4. Now, once you are happy with the App functionality (mine just adds an item in a list). Verify the ‘App Identifier’ with the ‘App Display Name’ at Site Settings -> Site app permissions . Please note that another ‘F5’ Hit from VS 2012 would generate a new ‘App Identifier’ as VS will generate a new ‘ClientId’.

Step 2. Create a Windows Service that is scheduled to run [it utilizes the above code]

Check this How to: Create Windows Services, if you want to understand the details around creating a windows service that runs based on a schedule. Though I will mention it for everyone’s interest.

1. Create a Windows Service by selecting Windows Service in the list of Visual C# project templates. I named it ‘SPTimerJobSimulation’.

2. Add ‘TokenHelper.cs’ class from the App project created above (Step 1). Then remove the namespace declaration from this class along with additional braces ‘{}’ from the code.

3. Add the additional references (ref below). As this service needs to work with CSOM and other references needed for ‘TokenHelper.cs‘ class.

4. Open ‘Service1.cs’ and switch to code view. I have pasted almost the entire code below. Essentially, I have moved the code from Default.aspx.cs. Just make sure to comment out the hard coded Uri to point to the relevant On Premise or SP-O site.

public partial class Service1 : ServiceBase
    {
        private static string SharePointPrincipal = "00000003-0000-0ff1-ce00-000000000000";
        static Timer SPtimer;
       
        public Service1()
        {
            InitializeComponent();
        }

        protected override void OnStart(string[] args)
        {
            SPtimer = new Timer();
            //schedule an interval of 2 minutes
            SPtimer.Interval = 1000 * 60 * 2;
            SPtimer.Elapsed += SPtimer_Elapsed;
            startSPtimer();
           
        }

        void SPtimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            //Comment out either of the below based on On Premise server or Online
            Uri hostWeb = new Uri("https://tenant/sites/DevCenter");

            //Below line works with On line
            Uri hostWeb = new Uri("https://tenant.sharepoint.com/sites/Develop");

            string realm = TokenHelper.GetRealmFromTargetUrl(hostWeb);

            string appOnlyAccessToken = TokenHelper.GetAppOnlyAccessToken(SharePointPrincipal, hostWeb.Authority, realm).AccessToken;

            using (ClientContext clientContext = TokenHelper.GetClientContextWithAccessToken(hostWeb.ToString(), appOnlyAccessToken))
            {
                if (clientContext != null)
                {
                    var myList = clientContext.Web.Lists.GetByTitle("ShariqTest");
                    ListItemCreationInformation listItemCreate = new ListItemCreationInformation();
                    Microsoft.SharePoint.Client.ListItem newItem = myList.AddItem(listItemCreate);
                    newItem["Title"] = "Added from Timer Job";
                    newItem.Update();
                    clientContext.ExecuteQuery();
                }
            }
        }

        private static void startSPtimer()
        {
            SPtimer.Start();
        }

        protected override void OnStop()
        {
        }
    }

5. Next up, we need to add the Application settings (ref below). So go to Project settings and Select ‘Settings’ to add the relevant <appSettings> from the Web.Config of your App project. Add ‘ClientId’ & ‘ClientSecret’ with relevant values (point ‘3’, under Step 1 above). Also change scope to ‘Application’.

Edit: Also you need to open your TokenHelper.cs file and comment out private static readonly string ClientId and replace it with yourAppsNamespace.Properties.Settings.Default.ClientId. Same goes for private static readonly string ClientSecret, replace it with yourAppsNamespace.Properties.Settings.Default.IssuerId.

6. We are almost done. Now we need to Debug and Install this windows service, let’s create the installers by opening Service1.cs file and with the designer in focus, right-click, Add Installer (ref below).

 

7.  To install a Windows service. Open Developer Command Prompt as Administrator. Navigate to the folder that contains your project's output. Install the service using the ‘installutil.exe’ command (ref below).

8.  It will prompt you for Service Login credentials. Provide appropriately. 

9.  The Service would be installed (ref below).

10. Open ‘Services’ and you should see your service listed. Go ahead and Start our service (ref below).

11.  Now let’s go and debug the service. Go to Debug –>Attach to Process and attach relevant process.

12.  Now you should be able to debug your service. It should hit the breakpoint based on the schedule that you coded under OnStart method.

Now this Scheduled Service adds an item every 2 minutes to my SharePoint site :). But it could do anything (possible with CSOM) on either SharePoint On-Premise or Online based on your requirement. There might be an additional request around hosting this Service in Azure specially while you are working with SP-O. So a nice pattern could be:

• Host the workload processing logic inside a regular Azure worker role.
• Use Windows Azure Scheduler to queue work items in recurring scheduled fashion.
• Have the Azure worker role pick-up work items from queue and execute the workload. After the work is finished, delete the item from queue.

A couple of scenario which made me write a SharePoint timer job in the 2010 world was:

• Sending a reminder email based on a particular list value. This was used with a workflow.
• Updating SharePoint List data to have fresh data based on an external database change.

So, both these scenarios can be easily implemented with my Custom Timer Job simulator that doesn’t use SSOM.

You can download the complete sample from here.

This is super powerful and I enjoyed it. Hope you like this too! 

Your comments/suggestions are welcome, as always!

Cheers !

Shariq

This time with my experiences with the ever engrossing SharePoint 2013. Last week I was setting up High Trust Apps that uses the server-to-server (S2S) protocol. This is a Provider Hosted App deployed in a private network which eliminates the need to involve ACS for creating Authentication tokens. In essence an S2S trust represents a trusted connection between a client app running on a local app server and the web servers in the SharePoint farm.

We need to set up the S2S Security token issuer service (STS) to provide access tokens for authentication. The S2S STS creates temporary access tokens signed with your own certificate.

So, lets go ahead and see the steps needed to set up your High Trust Apps. But at the outset, please ensure that you have the below mentioned steps in place to avoid any issues.

Prerequisite Step:

1. App Isolation set up : utilize either Configure an environment for apps for SharePoint or Setting up your App domain for SharePoint 2013 via PowerShell to set it up.
2. Use non Farm Account (SHAREPOINT\SYSTEM) : instead use a separate Developer Account that will used for App development. Ensure this user has right set of privileges (part of local administrators group on the Developer box, right permissions set on the relevant databases etc.).
3. User Profile Service Application set up :  shouldn’t be difficult for most folks; anyways you can refer to SharePoint 2013 - User Profile Service Application & Create, edit, or delete User Profile service applications in SharePoint Server 2013 for additional info.

Step 1: Create a Certificate

1. In the development environment you can use a self-signed certificate, but you would need a commercial certificate when you publish your Apps to store. So we will create a self signed one. In the IIS manager, click on Server Certificates.

2. Click on Create Self Signed Certificate

3. Enter some meaningful name like HighTrustCert and Click on Ok.

4. Now we need to export the personal exchange format (.pfx) file. Right Click on the Certificate in IIS click on Export and provide an accessible location. Also enter the password that you want to use and Click on Ok 

 

5. Next, double click on the Certificate in IIS. Click on Details tab and click on Copy to File.

6. Now you should see the Certificate Export Wizard (remember earlier we exported the .pfx file). The first screen elucidate the significance of what we are doing. Keep Clicking Next across the three screens. Below screenshots demonstrate the same. I keep all the default options. Just one thing to mark that now we are now exporting the .cer file. I choose the same location. Click on Save.

 

and finally, click on Finish. You should see you the message “The export was successful”.

7. To verify, go to your Trusted Root Certification Authorities Store  and you should see your Certificate there. If you can’t locate it, follow the first 7 steps (only) described at Adding certificates to the Trusted Root Certification Authorities store for a local computer. Remember we just need to confirm our certificate is available or not. If you are here, the battle is half won.

Step 2 : Run Windows PowerShell cmdlets to set up trusted security token service

1. Run SharePoint 2013 Management Shell as administrator. First thing first, you need an Issuer ID. Use the below PowerShell cmdlets to get one. Remember to make note of this, as we will use it later. An important point, it has to be Lowercase only.

[System.Guid]::NewGuid()

2. Run the below PowerShell cmdlets to create trusted security token service.

$issuerID = "29b0ebdd-791b-41c3-b1f7-a4152a1b7a8d"
$publicCertPath = "C:\HighTrustCert.cer"
$certificate = Get-PfxCertificate $publicCertPath
$web = Get-SPWeb "https://sp/sites/DevCenter"
$realm = Get-SPAuthenticationRealm -ServiceContext $web.Site
$fullAppIdentifier = $issuerId + '@' + $realm
New-SPTrustedSecurityTokenIssuer -Name "High Trust App" -Certificate $certificate -RegisteredIssuerName $fullAppIdentifier -IsTrustBroker
iisreset

Significance/additional info of the cmdlets

1. issuerID : assigning the GUID generated in the previous step
2. publicCertPath : path where I saved my .cer file.
3. web : your Developer site URL
4. realm : should be the same as your farm ID
5. New-SPTrustedSecurityTokenIssuer : Just a tip, when you use the Name parameter it can be helpful to include a readable name, such as “High Trust App” or “Contoso S2S apps” instead of the issuer ID.
6. -IsTrustBroker: this flag ensures that you can use the same certificate for other apps as well. If you don’t include this, you might receive “The issuer of the token is not a trusted issuer" error. So we have two possible approaches each having their own pros and cons .i.e. use the same certificate shared by multiple apps Or use a separate certificate for each app. Read additional details at Guidelines for using certificates in high-trust apps for SharePoint 2013
7. iisreset : to ensure the Issuer becomes valid, else it takes 24 hours.

                   

3. Additionally you can turn off the https requirements using below PowerShell cmdlets. But ensure to turn it on by changing $true to $false in the second cmdlet below.

$serviceConfig = Get-SPSecurityTokenServiceConfig
$serviceConfig.AllowOAuthOverHttp = $true
$serviceConfig.Update()

4. Refer to the screenshot below of for the complete steps:

If you are here, you are almost done

Step 3 : Create a Simple “High Trust” Provider Hosted App using Visual Studio 2012

1.  Open Visual Studio 2012, under Office/SharePoint section select App for SharePoint 2013. Enter a name and click OK

2. Select Provider-hosted and don’t forget to Click Next (and not Finish)

3. Then select Use a Certificate and provide the location of your certificate .pfx file. Provide the same password as provided in sub-step 4 under Step 1.  The Issuer ID should be same as created above, under sub-step 1 of Step 2. Then Click Finish.

4. The App Solution should be set up with its two projects.  Since we don’t intend to do anything extravagant, if you go ahead and Hit F5. After a few seconds you should see the below screen asking whether you ‘Trust’ this App. Click Trust it.

5. And we are done!! You should see the title of your Developer site displayed as shown below. Yay

6. Note that the App is right now hosted on the IIS Express.

 

Important troubleshooting tips & tricks

Each step above should not take more than 5 minutes each, if there are no issues with your environment. In case you face any issues. then follow the important tips & tricks that I have collated below which I learnt along the way. Big thanks to Kirk Evans[MSFT] for helping me with this.

1. Make sure all the Prerequisite Steps listed at the start of the article are in place.
2. If you run into 401 unauthorized error when running a high-trust app. Try the steps below:

• Use the PowerShell cmdlet to get the List of all TrustedSecurityTokenIssuer in your Farm

            Get-SPTrustedSecurityTokenIssuer | select Name,RegisteredIssuerName | fl

• This shows the Name, Registered Issuer Name for all registered security token issuers.  I had five of them.
• The first one 00000005-0000-0000-c000-000000000000 is for Workflows.
• Observe rest of the list, the correct token issuer should be of the format issuerID@Realm if you have a registration in there that’s missing the issuerID or Realm portion of the RegisteredIssuerName, you can see the 401 error. 
• For us it is 29b0ebdd-791b-41c3-b1f7-a4152a1b7a8d@8165b002-8510-4d2d-b0f7-67b0a716a3f6. The portion before ‘@’ is our ‘issuerID’ and after is the ‘Realm’ (ref to the above screenshot).
• The realm should be the same for any issuers that you registered manually, and it should be the same as your farm ID (use the below cmdlet to find that):

Get-SPFarm | select Id

And you can verify the Realm using the below cmdlet

$spurl ="https://sp/sites/DevCenter"
$spsite = Get-SPSite $spurl
$realm = Get-SPAuthenticationRealm -ServiceContext $spsite
Write $realm

• If you see a token issuers that is not in correct format, that’s the killer and you must remove that (but don’t dare to remove the one for the workflows ). You can use the below PS to remove any SPTrustedSecurityTokenIssuer. Make sure to supply correct RegisteredIssuerName found above.

            Get-SPTrustedSecurityTokenIssuer | ?{$_.RegisteredIssuerName -eq "29b0ebdd-791b-41c3-b1f7-a4152a1b7a8d@8165b002-8510-4d2d-b0f7-            67b0a716a3f6"} | Remove-SPTrustedSecurityTokenIssuer 

• You should also double-check that you are using the correct public key portion (the .CER file) for the private key (the .PFX file) that is on your app’s IIS server.  It is always worth verifying this step again. 
• Then make sure that the issuerID that’s in the RegisteredIssuerName (before the “@” symbol) matches the value that you have in web.config. Open the web.config file of your App’s web project.

 

• Also navigate to the ‘Site App Permissions’ page and you will see all the App Identifier listed. Notice that your App Identifier is of the structure ClientID@Realm. Verify the clientId in the web.config (above step).;

• Next, use Get-SPTrustedSecurityTokenIssuer and look at the certificate thumbprint for your issuer and compare it with the thumbprint of the certificate you used in PowerShell.

     3. I would recommend reviewing these blogs as well:

• High-trust apps (server-to-server apps) on-premises 
• More Troubleshooting Tips for High Trust Apps on SharePoint 2013
• Guidelines for using certificates in high-trust apps for SharePoint 2013

 

That was a lot of info, I'm gonna call it a day!

Cheers!

Part 3: Publishing CRM entities in SharePoint.

Hello SharePointers !!

I have been working with SharePoint for many years, but this is the first time I decided to blog about something.

The driving force behind choosing this particular topic is the two-fold: Firstly, there is not enough information available and secondly, due to the constant reminders by colleague Andy to help the larger community out there.

Andy, himself has published multi-part blog series on this topic and in essence this post forms the part 3 of his series.

Over here we will see how we can fetch and display complete set of entity information from CRM 2011 in a SharePoint Web part. That is in the SharePoint Web Part I will have a drop down list with the collection of all CRM ‘Entity’ and another drop down that will contain the associated ‘Views’ and finally the Entity Result set. But before we do that it’s important to understand why this is not straight forward!

Thought Process:

1) CRM 2011 provides SDK and I can always develop custom solutions. If I choose to refer to “Walkthrough: Build a Web Application That Connects to Microsoft Dynamics CRM 2011 Using Developer Extensions” I can easily display CRM 2011 entity information in a Web Application.

2) That means I can easily transform those custom solutions (like a Web Application) into a SharePoint 2010 web part, and bingo! We are all set!

Catch:

1) CRM 2011 is based on .Net framework 4.0 and SP 2010 is on .Net 3.5. So if you try to implement the step 2 you can’t even build your SharePoint Web Part forget about deploying it.

Resolution [Important Steps]:

1) Publish an intermediary WCF service with relevant methods to expose information from CRM 2011.

2) Create a SharePoint Web Part and make appropriate calls to the WCF service and then transform the result set as per your needs for the end user.

The Steps in detail:

1) We need to create and publish a WCF service to call in CRM 2011. This service can have multiple facets based on your needs; may be you intend to perform add/edit/delete apart from just “display” so create the WCF methods judiciously. For now I will stick to the display part.

IMP: The code blocks below doesn’t confirm to the coding best practices but does work, and I am sure you guys can transform it accordingly. I have ripped the pieces from from all over the web

a) Generate Early Bound Types:

Run the CrmSvcUtil.exe tool, with the Microsoft.Xrm.Client.CodeGeneration extension, to generate your entity classes and service contexts.

The following example command creates a file called “Xrm.cs” that points at an instance of Microsoft Dynamics CRM. Note that the Microsoft.Xrm.Client.CodeGeneration.dll file must be in the same directory as the CrmSvcUtil.exe file, or in the system GAC, when you run this command.

crmsvcutil.exe /codeCustomization:"Microsoft.Xrm.Client.CodeGeneration.CodeCustomization, Microsoft.Xrm.Client.CodeGeneration"
/out:Xrm\Xrm.cs /url:https://dpm2012/fabrikam/XRMServices/2011/Organization.svc /domain:CONTOSO /username:spfarm
/password:Welcome@123 /namespace:Xrm /serviceContextName:XrmServiceContext

b) Use Visual Studio 2010 to create a WCF Service Application (ensure .NET Framework 4).

public string MyProperty { get; set; }

public string MyProperty1 { get; set; }

h) Right-click the project in Visual Studio and add the Service Reference for the Organization.svc

i) Open the interface IService1.cs and replace the ServiceContract with the code below:

[ServiceContract]

    public interface IService1

    {

        [OperationContract]

        string GetMessage();

        [OperationContract]

        List<Entities> GetEntityData();

        [OperationContract]

        List<Views> GetViewData(int SelectedEntity);

        [OperationContract]

        DataSet GetCompleteData(string _SavedQueryId);

    }

j) Now we need to implement the Service1.svc, copy the below code (make appropriate changes for your OrganizationUri i.e. Organization.svc )

    public class Service1 : IService1
    {
        public List<Entities> GetEntityData()
        {
        ClientCredentials Credentials = new ClientCredentials();

        Credentials.Windows.ClientCredential = CredentialCache.DefaultNetworkCredentials;

        //This URL needs to be updated to match the servername and Organization for the environment. 

        Uri OrganizationUri = new Uri("https://DPM2012/TailspinToysDB/XRMServices/2011/Organization.svc");
        List<Entities> EntityList = new List<Entities>();
        Uri HomeRealmUri = null;
        using (OrganizationServiceProxy serviceProxy = new OrganizationServiceProxy(OrganizationUri, HomeRealmUri, 

        Credentials, null))
        {

            Microsoft.Xrm.Sdk.IOrganizationService service = serviceProxy as Microsoft.Xrm.Sdk.IOrganizationService;

            RetrieveAllEntitiesRequest request = new RetrieveAllEntitiesRequest()
            {
                EntityFilters = EntityFilters.Attributes,
                RetrieveAsIfPublished = true
            };

            // Retrieve the MetaData.
            RetrieveAllEntitiesResponse response = (RetrieveAllEntitiesResponse)serviceProxy.Execute(request);

            foreach (EntityMetadata currentEntity in response.EntityMetadata)
            {
                if (currentEntity.IsCustomizable.Value == true)
                {
                    foreach (AttributeMetadata currentAttribute in currentEntity.Attributes)
                    {

                        Entities e = new Entities();
                        e.MyProperty = currentEntity.LogicalName;
                        e.MyProperty1 = currentEntity.ObjectTypeCode.Value.ToString();

                        if (EntityList.Where(en => en.MyProperty.Equals(e.MyProperty) && 

                        en.MyProperty1.Equals(e.MyProperty1)).Count() == 0)
                        {
                            EntityList.Add(e);
                        }
                    }
                }
            }

        }
        return EntityList;
        }

        public List<Views> GetViewData(int paramSelectedEntity)
        {
        ClientCredentials Credentials = new ClientCredentials();

        Credentials.Windows.ClientCredential = CredentialCache.DefaultNetworkCredentials;

        //This URL needs to be updated to match the servername and Organization for the environment. 

        Uri OrganizationUri = new Uri("https://dpm2012/TailspinToysDB/XRMServices/2011/Organization.svc");

        Uri HomeRealmUri = null;
        List<Views> ViewsList = new List<Views>();

        using (OrganizationServiceProxy serviceProxy = new OrganizationServiceProxy(OrganizationUri, HomeRealmUri, 

        Credentials, null))
        {
            serviceProxy.EnableProxyTypes();

            Microsoft.Xrm.Sdk.IOrganizationService service = (Microsoft.Xrm.Sdk.IOrganizationService)serviceProxy;

            // Retrieve Views
            QueryExpression mySavedQuery = new QueryExpression
            {
                ColumnSet = new ColumnSet("savedqueryid", "name", "querytype", "isdefault", "returnedtypecode", 

                "isquickfindquery"),
                EntityName = SavedQuery.EntityLogicalName,
                Criteria = new FilterExpression
                {
                    Conditions =
        {
                
            new ConditionExpression
            {
                AttributeName = "returnedtypecode",
                Operator = ConditionOperator.Equal,
                Values = {paramSelectedEntity}
            }
        }
                }
            };
            RetrieveMultipleRequest retrieveSavedQueriesRequest = new RetrieveMultipleRequest { Query = mySavedQuery };

            RetrieveMultipleResponse retrieveSavedQueriesResponse = 

            (RetrieveMultipleResponse)serviceProxy.Execute(retrieveSavedQueriesRequest);

            DataCollection<Entity> savedQueries = retrieveSavedQueriesResponse.EntityCollection.Entities;
                
            foreach (Entity ent in savedQueries)
            {
                SavedQuery rsq = (SavedQuery)ent;
                if (rsq.IsDefault == true)
                {
                    Views e = new Views();
                    e.MyProperty = rsq.Name.ToString();
                    e.MyProperty1 = rsq.Id.ToString();
                    ViewsList.Add(e);
                }
            }
        }

        return ViewsList;           

        }

        public DataTable convertEntityCollectionToDataTable(EntityCollection BEC)
        {
            DataTable dt = new DataTable();
            int total = BEC.Entities.Count;
            for (int i = 0; i < total; i++)
            {
                DataRow row = dt.NewRow();
                Entity myEntity = (Entity)BEC.Entities[i];
                var keys = myEntity.Attributes.Keys;
                foreach (var item in keys)
                {
                    string columnName = item;
                    string value = getValuefromAttribute(myEntity.Attributes[item]);
                    if (dt.Columns.IndexOf(columnName) == -1)
                    {
                        dt.Columns.Add(item, Type.GetType("System.String"));
                    }
                    row[columnName] = value;
                }
                dt.Rows.Add(row);
            }
            return dt;
        }

        private string getValuefromAttribute(object p)
        {
            if (p.ToString() == "Microsoft.Xrm.Sdk.EntityReference")
            {
                return ((EntityReference)p).Name;
            }
            if (p.ToString() == "Microsoft.Xrm.Sdk.OptionSetValue")
            {
                return ((OptionSetValue)p).Value.ToString();
            }
            if (p.ToString() == "Microsoft.Xrm.Sdk.Money")
            {
                return ((Money)p).Value.ToString();
            }
            if (p.ToString() == "Microsoft.Xrm.Sdk.AliasedValue")
            {
                return ((Microsoft.Xrm.Sdk.AliasedValue)p).Value.ToString();
            }
            else
            {
                return p.ToString();
            }
        }

        public DataSet GetCompleteData(string _strSavedQueryId)
        {
        DataSet ds = new DataSet();

        Guid _SavedQueryId = new Guid(_strSavedQueryId);

        ClientCredentials Credentials = new ClientCredentials();

        Credentials.Windows.ClientCredential = CredentialCache.DefaultNetworkCredentials;

        //This URL needs to be updated to match the servername and Organization for the environment. 

        Uri OrganizationUri = new Uri("https://dpm2012/TailspinToysDB/XRMServices/2011/Organization.svc");

        Uri HomeRealmUri = null;


        using (OrganizationServiceProxy serviceProxy = new OrganizationServiceProxy(OrganizationUri, HomeRealmUri, 

        Credentials, null))
        {
            serviceProxy.EnableProxyTypes();

            Microsoft.Xrm.Sdk.IOrganizationService service = (Microsoft.Xrm.Sdk.IOrganizationService)serviceProxy;

            ColumnSet cSet = new ColumnSet("savedqueryid", "fetchxml");

            SavedQuery rsq = (SavedQuery)service.Retrieve(SavedQuery.EntityLogicalName, _SavedQueryId, cSet);

            RetrieveMultipleRequest req = new RetrieveMultipleRequest();
            FetchExpression fetch = new FetchExpression(rsq.FetchXml);
            req.Query = fetch;
            RetrieveMultipleResponse resp = (RetrieveMultipleResponse)service.Execute(req);
            DataTable ObjDT = convertEntityCollectionToDataTable(resp.EntityCollection);
            ds.Tables.Add(ObjDT);

        }
        return ds;
        }
    }

k) Now the CRM WCF Service is ready and we can publish it at IIS. The steps to publish any WCF service can be found easily over web. Starters can refer to https://debugmode.net/2010/09/07/walkthrough-on-creating-wcf-4-0-service-and-hosting-in-iis-7-5/. Skip the Service creation steps from this blog just refer to Publishing steps and also ensure to test it locally using a local Client.

If you have reached here successfully, the battle is almost won

2) Now we just need to create a simple SharePoint 2010 Visual Web Part to consume this service as per need.

a) Use Visual Studio 2010 to create a new Visual Web Part project.

b) Right Click the project and Add the Service Reference for our CRM Service published in Step 1.

c) Add the following code to VisualWebPart1UserControl.ascx :

<asp:DropDownList ID="ddlEntityList" runat="server" AutoPostBack="True" 
OnSelectedIndexChanged="ddlEntityList_SelectedIndexChanged"></asp:DropDownList>
<asp:DropDownList ID="ddlViewsList" runat="server" AutoPostBack="True" 
OnSelectedIndexChanged="ddlViewsList_SelectedIndexChanged"></asp:DropDownList>
<asp:GridView ID="gdEntity" ViewStateMode="Disabled" runat="server" />

d) Add the following code to VisualWebPart1UserControl.ascx.cs:

       protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                Service1Client proxy = new Service1Client();

                ddlEntityList.DataSource = proxy.GetEntityData();
                ddlEntityList.DataTextField = "MyProperty";
                ddlEntityList.DataValueField = "MyProperty1";
                ddlEntityList.DataBind();
            }
        }

        protected void ddlEntityList_SelectedIndexChanged(object sender, EventArgs e)
        {
            ddlViewsList.Items.Clear();
            int index = Convert.ToInt32(ddlEntityList.SelectedValue);
            Service1Client proxy = new Service1Client();

            ddlViewsList.DataSource = proxy.GetViewData(index);
            ddlViewsList.DataTextField = "MyProperty";
            ddlViewsList.DataValueField = "MyProperty1";
            ddlViewsList.DataBind();


        }

        protected void ddlViewsList_SelectedIndexChanged(object sender, EventArgs e)
        {            
            string str = ddlViewsList.SelectedValue;
            Service1Client proxy = new Service1Client();
            gdEntity.DataSource = proxy.GetCompleteData(str);
            gdEntity.DataBind();
        }

e) Right click the Project and deploy to the SharePoint Site.

f) Go to the SharePoint 2010 Site and add the Visual Web Part to a page where you want to display the Web Part. And ‘Bingo’. You should see the something like this:

This SharePoint Web Part code above is pretty basic in nature for now, but I am sure you can improve upon this sample code – you know, things like:

• When not to show the ‘View’ Drop Down when the Entity is refreshed.
• Or when there is no result set we must show appropriate result rather than the Yellow screen of death.
• Or you want to filter the Grid by removing certain columns from the dataset or renaming the column Header etc.

I leave all it all up to you, as the sample is attached. Use it/Break it and Enjoy !!!

Food for thought

1) In principle this should work for MOSS 2007, for those who are still on it

2) In SharePoint 2013, we can merge the WCF code implementation within the SharePoint web part itself.

You can download the complete sample from here.

Code References

https://mscrmbi.blogspot.com/2012/02/crm-2011-convert-entitycollection-to.html

https://msdn.microsoft.com/en-us/library/gg695790.aspx

Hope this helps a needy soul! If it does, please leave your comment/feedback.

Cheers!