Dynamics 365 portals: Administrative Wizard

With the release of the July 2017 update for Dynamics 365, comes v8.3 of Dynamics 365 portals. One of the new features of this release is the new administrative wizard which allows you to easily add an entity to the portal. This can really make the pace for development increase and removes the barrier to creating all the components necessary to properly surface Dynamics 365 data on your external portal. Below we will walk through what exactly the administrative wizard create for you and how you can access and use it yourself.

Firstly you need to decide what you want to expose on the portal. This could just be creating a new page and not associating any data other than just CMS content or other web templates. But the administrative wizards real power is that it also allows you to configure full entity interaction on the portal by it creating all the necessary components like entity list, entity form, web pages, and entity permissions. This could be an out of box entity or a custom entity you have created.

For our example we are going to use a custom entity Economic Development Sites. Whichever entity you decide to use you will want to ensure you configure the CRM forms and views that you will expose on the portal prior to starting the wizard.

To start the administrative wizard, in Dynamics 365 navigate to Portals, then with 8.3.x solutions installed you will have a new Administration section with a tile called Portal Management.

Within the Portal Management select Create Portal Content.

You should now be presented with a Create Portal Content dialog which will allow you to create a web page and optionally display an entity. At a minimum you need to fill in the Page Name field. This will auto populate the title and the partial URL with the same value as page name automatically. You can select the parent page you want to associate this new page to (it will default to the home page of the selected website), and change the default layout for the web page.

Optionally you can now enable an entity with this page in the portal by changing the “Display organization entity in the portal” to yes which will review some additional options. Namely you need to first select which entity you want to display, then the view(s) (which can be multiple), the form that will be used for details, edit, and create forms.

Creation can be turned on and off, as can anonymous access. If anonymous access is turned off you will need to select the contact relationship which will require your entity to have a reference/lookup to the contact entity.

Finally you can enable editing of a record as well as if the records should be filtered to only those owned by the user.

With all your options selected you can then click the create button and the wizard will go about creating all the portal data components for you. It will create multiple web pages (if you have enabled create, and edit), entity forms for each function (create, edit, details), an entity list to display all the records on the main web page, and finally an entity permission that allows the functions enabled to work.

On complete of the creation you will be navigated in the CRM to the newly created web page, which has your entity list linked and if you check the child pages will include the create, edit and details web pages with the appropriate entity forms associated to each.

The wizard also does have some error checking so if you were to try to create the same partial URL that already exists to the parent page it will prevent this.

The administrative wizard is a great way to quickly get the scaffolding for your entity on the portal even if the initial configuration isn’t your desired output. With all the portal data it quickly creates it can help cut down your time entering all the information manually and you can now easily go and further enhance each of the components.

Dynamics 365 portals: Upgrade to July 2017 Update (v8.3)

The July 2017 update for Dynamics 365 portals is now available for existing portal customers in the North American region and rolling out to other regions over the coming days and weeks. How can you get this update and all the new cool functionality that is in it is a little different from the previous releases.

When the Dynamics 365 portals came out, you had no control over the time in which your portal was upgraded. With the July 2017 update this changes somewhat. Portal code updates will still be managed and done automatically but now the Dynamics 365 solutions for the portal must be customer initiated.

To initiate your portal solution upgrade you need to navigate to the Dynamics 365 Administration Center where you can manage all the instances in your tenant. From the instance listing select the organization that has the portal already installed and select the edit icon beside solutions in the right hand pane.

Within the Manage Solutions listing for the organization if the upgrade has been made available you will see “Upgrade Available” beside your existing installed portal solution. Highlighting the solution will provide you the details of the upgrade and also allow you to initiate the upgrade process.

Upon selecting upgrade you will be prompted to select the terms and the installation will start.

This process can take some time depending on the portal upgrade you are doing. From my experience and those at Adoxio we have seen this range from 30 minutes to 4 hours. So ensure you plan an appropriate window for this maintenance as it could cause the portal service to be unresponsive at times due to the solution upgrade/install process with the Dynamics 365 instance. To monitor the installation you can just refresh the Manage Solutions or go into the Dynamics 365 instance and go the solutions listing and wait until all solutions show as version 8.3.x.

As in previous upgrades the portal code is fully managed and not currently customer driven. You can check your current portal version by navigating to https://[portaladdress].microsoftcrmportals.com/_services/about. If you do have an 8.3.x portal and signed as an administrator you will now also see a lot more details about your portal including a new admin tool for clearing the cache!

If you haven’t yet got the 8.3.x update then you can still subscribe to the early update functional outlined in Dynamics 365 portals: Early Upgrade Option – July 2017 Update.

Build an ASP.NET Core Web App with Adoxio Connect Framework

Microsoft’s ASP.NET team is going through a big transition period right now to an open source redesign of ASP.NET called ASP.NET Core. ASP.NET Core has major changes that are meant to try to make it more accessible to a larger set of developers as well as bringing it to many platforms with incredible performance improvements. If you’re a web developer building ASP.NET sites that connect to Dynamics 365 this will be an important platform to investigate and use in your solutions. In this post we will walk through a sample of a Dynamics 365 Web App that is built on ASP.NET Core and use the Server-to-Server authentication that Adoxio Connect Framework provides.

Previously we have built samples for a Console Application and a standard ASP.NET Web Application. What makes ASP.NET Core different is that is all the new versions of MVC, Web Api, OWIN and the entire framework being built on .NET Standard instead of the .NET Framework. The change of building ASP.NET Core by following .NET Standard is the single largest change and is what makes the framework now cross platform and able to run on Linux. As Dynamics developers we need to continue using the .NET Framework due to the dependencies the Dynamics 365 SDK has to use .NET Framework components. It is not unexpected though, removing .NET Framework is big change and will take considerable time to make a shift (v8.2 shows approximately 75% compatibility with .NET Standard). This however does not mean they we can’t use ASP.NET Core as Dynamics developers because ASP.NET Core can also be run on .Net Framework since it is .NET Standard compatible. This means you can use .NET Framework based libraries like the Dynamics 365 SDK or others like SharePoint, and even Adoxio Connect Framework.

So Why Use ASP.NET Core
Their are huge changes that are great for developers and builders to make use of. There are major benefits in terms of modularization of the request pipeline, dependency injection a core part of the platform, performance (a factor of 10 compared to ASP.NET 4.6), new MVC version, and open source! If you’re build a brand new web app then you should strong consider starting with ASP.NET Core.

As such let’s look at how you can use Adoxio Connect Framework with this version and understand some of the differences from the ASP.NET implementation.


Firstly let’s start by creating a new ASP.NET Core project. You can do this with the latest version of Visual Studio, 2017. Select from the ASP.NET Core Web Application (.NET Framework) template under Visual C# > Web area. It’s important you select the .NET Framework version so we can support the Dynamics 365 SDK, and select .NET Framework 4.6.1 which Adoxio Connect Framework requires.

Next select Web Application while ensuring that ASP.NET Core 1.1 is selected in the version drop down.

With the new web project just like the standard ASP.NET sample we want to include the necessary NuGet packages necessary to connect to Dynamics 365. As we are going to use a Server-to-Server based authentication we are going to use Adoxio Connect Framework to make that implementation easy in the application. Within the project, right click Dependencies in the Solution Explorer and select Manage NuGet Packages… Within the NuGet package manager, select Browse and search for “Adoxio”, then select and install the latest version of Adoxio.Dynamics.Connect.

Adoxio Connect Framework will also bring in the necessary dependencies when it installs including the Dynamics 365 SDK.

This is the only package to install with ASP.NET Core to get started, making it super simple to start. Now with all the dependencies installed to the project the next step is to ensure you have done the necessary setup for server-to-server authentication. This includes creating an Azure AD application with the appropriate API access, and creating an application user with a security role in CRM. To learn more about the server-to-server authentication setup follow the MSDN documentation. Follow the same steps for multi-tenant for building this single tenant web application, other than you don’t need to worry about creating a process to deploy the application user as it will be a one time process per Dynamics instance. Use Multi-Tenant Server-to-server authentication

Once your have your S2S settings created (you will need a Client Id, Client Secret, the instance or resource – your Dynamics instance URL, and Azure AD tenant ID) then we need to input them into the ASP.NET Core app settings. This differs from the standard ASP.NET application as that configuration was all XML based and heavily used the Configuration Manager. Both in ASP.NET Core are no more. Settings are now stored in JSON and are retrieved via dependency injection in the OWIN App Startup services configuration. First let’s put a structure to read in the appsettings.json file.


  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "AdoxioConnect": {
    "dynS2S": {
      "ClientId": "1d8925fd-8cbe-4f07-a83f-f59f7b111350",
      "ClientSecret": "ckrtN4TrckIAF1i5ccEcJw+C4/ESfcyjWGBRBI80a3A=",
      "Resource": "https://connectexampleinstance.crm.dynamics.com",
      "TenantId": "ae83bd39-7849-4089-3965-1e5749dc4dc2"
    }
  }
}

These are just sample values.

With the settings now input we need to have the ASP.NET Core application add them to its dependency injection pipeline so we can then use them when forming the CrmContext constructor so we have a context to communicate with Dynamics 365.

Open the Startup.cs class and navigate to the ConfigureServices method. In this method we are going to use the S2SAppSettings class that comes with Adoxio Connect Framework to register the settings in the appsettings.json as an object that can be accessed in the application.

services.Configure<S2SAppSettings>(Configuration.GetSection("AdoxioConnect:dynS2S"));

We can use S2SAppSettings because the names we used in the appsettings.json match that class definition. This class object will now be available to the entire application through the platform based dependency injection. You can read more about the DI in ASP.NET Core here – Introduction to Dependency Injection in ASP.NET Core

With the settings now available we need to make a small extension class to support the DI in ASP.NET Core in Adoxio Connect Framework. Create a new folder called Extensions if you want, and then a new class which you can call CrmContextCore.cs. In this class we simply just want to add a new constructor to the CrmContext that is part of Adoxio Connect Framework which will allow it to read the S2SAppSettings through the dependency injection.

using Adoxio.Dynamics.Connect;
using Microsoft.Extensions.Options;

namespace Adoxio.Connect.WebCore.Extensions
{
    public class CrmContextCore : CrmContext
    {
        public CrmContextCore(IOptions<S2SAppSettings> s2sAppSettingsOptions) : base(s2sAppSettingsOptions.Value)
        {
        }
    }
}

Why didn’t we just add this to Adoxio Connect? It would require making a library for both ASP.NET Core and standard ASP.NET because of the IOptions dependency so we decided this was such a small simple change as well as a place to start building extensions to the framework in your own project that we would stick with a single library until there were more benefits.

All that is in this class is firstly it inherits and extends the CrmContext class and add a new constructor that reads the S2SAppSettings as an IOptions object that then calls the base constructor with the value of the S2SAppSettings object. If you wanted to use the Xrm Tooling, CrmServiceClient this would be a good class to make those changes as well. This CrmContextCore class is what we will next be adding to the ASP.NET Core application as a singleton so that it is also available to the whole application through dependency injection.

Back in Startup.cs under the ConfigureServices method we can now add our new class as that singleton object.

services.AddSingleton<CrmContextCore>();

Why AddSingleton? You can read more about the different service types for adding objects to the pipeline here with Service Lifetimes and Registration Options, as well there is a good answer on StackOverflow depicting an example of all of them. The reason here is that we really only need 1 connection to the Dynamics 365 instance in the entire application and there is no need to recreate the object on every request. So with a singleton we get a single object created at the startup of the application which makes for great performance on every request.

The ConfigureServices method should now have 2 additional lines as below and that is all the configuration that is actually needed to use the Adoxio Connect Framework and have a context that will allow you to interact with the Dynamics 365 instance through that Server-to-Server connection.

public void ConfigureServices(IServiceCollection services)
{
    // Add framework services.
    services.AddMvc();

    services.Configure<S2SAppSettings>(Configuration.GetSection("AdoxioConnect:dynS2S"));
    services.AddSingleton<CrmContextCore>();
}

Now that the application is setup we can now start creating controllers and other functions in the application that can access these objects easily through the dependency injection. Let’s look at a simple controller that implements some simple SDK calls.

using Microsoft.AspNetCore.Mvc;
using WebApplication13.Extensions;

namespace WebApplication13.Controllers
{
    public class CrmSdkController : Controller
    {
        private readonly CrmContextCore _crmContext;

        public CrmSdkController(CrmContextCore crmContext)
        {
            _crmContext = crmContext;
        }

        public IActionResult Index()
        {
            return View();
        }
    }
}

The addition we make to our class to make use of our context is just simply adding a constructor to the class that calls to singleton object we added to the application and then stores it in a private object that is accessible throughout the class. ASP.NET Core’s dependency injection makes it all this easy.

Now you can build methods that use the context to call Dynamics 365 using your normal SDK calls. Below is the same method as both a MVC view and an API JSON return within the exact same controller which is all now combined in ASP.NET Core MVC.

public IActionResult Index()
{
    var contacts = _crmContext.ServiceContext.CreateQuery("contact").ToList();
    return View(model: string.Join(",", contacts.Select(a => a.GetAttributeValue<string>("fullname"))));
}

[Produces("application/json")]
[Route("api/CrmSdk")]
public IEnumerable<Entity> GetContacts()
{
    var contacts = _crmContext.ServiceContext.CreateQuery("contact").ToList();
    return contacts;
}

All of this new ASP.NET Core sample code is now part of the samples on the Adoxio Connect Framework GitHub repo.

Again if your starting a new web development project for Dynamics 365 definitely consider ASP.NET Core even though your still using .NET Framework. There is still significant benefit to mixing the 2 together.

If your interested to know more about the Adoxio Connect Framework and Dynamics 365 Server-to-Server authentication I will be giving a webinar with the Xrm Virtual User Group this Tuesday July 11th at 12pm EST / 9am PST.