One of the more common use cases in Microsoft Dynamics 365 tends to be writing plugins and needing to pass parameters that the plugin code can use.

The traditional format to pass parameters has been XML that is pasted in the unsecure configuration. Parsing XML tends to be cumbersome and one ends up writing more code and spends more time maintaining that code rather than focusing on the business logic within the plugin. The question is: can we do any better?

Yes, there is a better way! The following process is what we tend to use to simplify this task:

Step 1

Build a class that contains the variables that you want to pass in through the unsecure configuration.

For the purposes of our example, our class definition looks like the screenshot below.

Step 2

Instantiate the object and serialize it. You could use JSON.NET or write your own. In either case, the serialized output will be similar to below.

Step 3

Paste the JSON in the unsecure config of your plugin step.

Step 4

In your plugin code, deserialize the JSON as follows

Code for the Deserialize method is below.

Sample code for the JsonHelper class was derived from this Microsoft article.

Step 5

Now you are free to use variables defined within the reserialized object as you need in your plugin code. Mission accomplished!

For additional information, check out the following blogs:

Comparison: Using Workflows vs. JavaScript vs. Plugins in Dynamics 365

Setting Output Parameters in Plugins for Custom Actions

Happy Dynamics 365’ing!

As a user of Microsoft Dynamics 365 or CRM you are always looking to improve your skills, efficiency and use of this valuable business technology solution.

In Ledgeview’s monthly Dynamics CRM User Group 30 minute webinars, Dynamics experts will answer your submitted questions.

For example, how to use specific functionality within Dynamics 365/CRM (“How Do I…”) but also provide insight around specific features each month! Your questions can range from very basic to very complex – bring them on!

Here is a spotlight of a few topics we covered in previous user group webinars this year:

• Document Management Integration
• What’s New with Dynamics 365
• Using Queues
• Sharing Personal Views, Setting Default Views and Using Document Templates
• Custom Activities & Calculated Fields

This month’s featured topic is “Chat Capabilities with Cafe X” which is a very cool new feature in Dynamics 365 Portals!

These webinars are free and you do not need to be a customer of Ledgeview Partners to participate! So if you are in sales, marketing, service, management, an administrator, or any Microsoft Dynamics 365/CRM user sign up today to attend.

Webinar: Microsoft Dynamics 365/CRM User Group hosted by Ledgeview Partners
Date: Wednesday, August 23, 2017
Time: 1:30pm CDT

>>Register Now

If you cannot attend the live session, each session is recorded and we will send you a link to access the recording on-demand.

Go ahead and register– not only are they super educational, they will make you a rock star when you give these tips to other users!

The post Webinar: Microsoft Dynamics 365/CRM User Group – August 23rd appeared first on Ledgeview Partners.

When using SQL Server logins to conect to a database that has just been restored, most likely the following error will appear:

Login failed for User 'username'

or

Cannot open database 'dbname' requested by the login. The login failed. Login failed for user 'username'.

The reason for this error is that the user login and the database login have become disconnected. We need to relink the database user with the login:

sp_change_users_login 'UPDATE_ONE', 'username', 'username'

When trying to install the Microsoft Dynamics CRM for Outlook client on a Terminal Services computer, the following error is received:

"Microsoft Dynamics CRM 4 for Outlook cannot be installed on a computer where Microsoft Exchange Server versions prior to Exchange Server 2007 are installed."

This error can be remedied by modified a registry key under the Exchange hive. To modify the key following the steps below:

• Open the Registry Editor (run regedit from command prompt)
• Backup (export) everything under the following registry key: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Exchange
• Delete the Key
• Install the Microsoft Dynamics CRM  4 for Outlook Client
• Configure the Microsoft Dynamics CRM  4 for Outlook Client
• Re-install the key*

  * Note: Re-installing the key will prevent new users from configuring their Microsoft Dynamics for Outlook client with CRM the first time they log in. Re-installing the key should be done after all required users have configured their Microsoft Dynamics CRM for Outlook Client.

This issue sometimes happens when you deploy a web application that contains report files on IIS7. 
The reports work fine in the development environment, but once published nothing appears in the results.
The report window will either complete and show zero pages or the "Report is being generated" message will show up:

The problem is that the web browser is unable to locate Reserved.ReportViewerWebControl.axd, even though the http handler might be included in the web.config file.

To verify that this is the problem, open fiddler web debugger in your Internet Explorer session and check for any 404 errors with the Reserved.ReportViewerWebControl.axd url.

To resolve this issue we have to manually add the http handler to the web site in IIS. Report Viewer 2008 Redistributable with SP1 should be installed of course.

1. Open IIS.
2. Click on the web site that you want to add the Handler Mapping to
3. Double Click on the Handler Mappings
   
4. From the actions Task Menu click on Add Managed Handler
   
5. Enter the following information in the Add Managed Handler Window:
   Request Path: Reserved.ReportViewerWebControl.axd
   Type: Microsoft.Reporting.WebForms.HttpHandler, Microsoft.ReportViewer.WebForms, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
   Name: Reserved-ReportViewerWebControl-axd
   
6. Click OK and you're done.

Visual Studio 2010 and Report Builder 3.0 RDL reports use a new schema that is not supported by SQL Server 2008 Reporting Services. They are designed to work only with SSRS 2008 R2. Currently there is no way to publish a VS2010 Report on SQL Server 2008 without some modifications to the RDL code. 

In order to publish the RDL in SSRS 2008, the following steps have to be performed:

1. Open the RDL file (not project) with Visual Studio or an Xml Editor.

2. Replace the report namespace occurrences from 2010 to 2008:

<Report xmlns:rd="http://schemas.microsoft.com/SQLServer/reporting/reportdesigner"
  xmlns:cl="http://schemas.microsoft.com/sqlserver/reporting/2010/01/componentdefinition"
  xmlns="http://schemas.microsoft.com/sqlserver/reporting/2010/01/reportdefinition">

Should be replaced with:

<Report xmlns:rd="http://schemas.microsoft.com/SQLServer/reporting/reportdesigner"
  xmlns:cl="http://schemas.microsoft.com/sqlserver/reporting/2008/01/componentdefinition"
  xmlns="http://schemas.microsoft.com/sqlserver/reporting/2008/01/reportdefinition">

3. Report the following Xml Tags (Keep the Xml between the Tags)

<ReportSections><ReportSection></ReportSection></ReportSections>

4. Save the Xml file and publish the report. This should now work with SSRS 2008. 

Sometimes you write applications that contains some logic, that require you to create steps for your plugin based on other entities. For example, if you have an AutoNumber solution, you can create a plugin step for a particular entity every time you create a new AutoNumber record.

This process will allow your AutoNumber functionality to be immediately available when the user creates a new AutoNumber Settings record.

In order to do this, you will need to either retrieve or hard code the name of your assembly and plugin type as shown below.

conststring ASSEMBLY_NAME = "Dyn365.Xrm.Plugins.AutoNumber";conststring PLUGIN_TYPE_NAME = "Dyn365.Xrm.Plugins.AutoNumber.PluginEntryPoint";

We then need to get the Guid of the message that we are adding, as well as get the Object Type Code and check if this message already exists, so that we bypass this logic if there is already a step for this message.

publicvoid PublishSDKMessageProcessingStep(string entityName, Guid impersonatingUserId)
{
   Guid sdkMessageId = GetSdkMessageId("Create");int? objectTypeCode =  RetrieveEntityMetadataObjectTypeCode(entityName.ToLower());if (objectTypeCode.HasValue)
   {bool stepExists = RetrieveSdkMessageProcessingStep(sdkMessageId, objectTypeCode.Value);if (!stepExists)
         CreateSdkMessageProcessingStep(string.Format("{0}: Create of {1}", PLUGIN_TYPE_NAME, entityName), entityName.ToLower(), "", StepMode.Sync, 10, PluginStage.PostOperation, StepInvocationSource.Parent, impersonatingUserId);
   }
}

privateint? RetrieveEntityMetadataObjectTypeCode(string entityName)
{
    RetrieveEntityRequest request = new RetrieveEntityRequest()
    {
        EntityFilters = EntityFilters.Entity,
        LogicalName = entityName
    };

    RetrieveEntityResponse response = (RetrieveEntityResponse)service.Execute(request);
    int? result = response.EntityMetadata.ObjectTypeCode;return result;
}

The RetrieveSdkMessageProcessingStep is a queryexpression on the SdkMessageProcessingStep with multiple linked entities (SdkMessageFilter and PluginType) to check if the record already exists. It is probably easiest to do this as a FetchXml query, but works both ways. The CreateSdkMessageProcessingStep function was called after the retrieval of the required values. This method will create the SDKMessageProcessingStep record. We will need to get the Ids of some of the Plugin types in order to complete the save operation

private Guid CreateSdkMessageProcessingStep(string name, string entityName, string configuration, StepMode mode, int rank, PluginStage stage, StepInvocationSource invocationSource, Guid impersonatingUserId)
{
    Entity step = new Entity("sdkmessageprocessingstep");
    step["name"] = name;
    step["description"] = name;
    step["configuration"] = configuration;
    step["mode"] = new OptionSetValue(mode.ToInt());
    step["rank"] = rank;
    step["stage"] = new OptionSetValue(stage.ToInt());
    step["supporteddeployment"] = new OptionSetValue(0); // Server Only
    step["invocationsource"] = new OptionSetValue(invocationSource.ToInt());

    Guid sdkMessageId = GetSdkMessageId("Create");
    Guid sdkMessageFilterId = GetSdkMessageFilterId(entityName, sdkMessageId);

    Guid assemblyId = GetPluginAssemblyId(ASSEMBLY_NAME);
    Guid pluginTypeId = GetPluginTypeId(assemblyId, PLUGIN_TYPE_NAME);

    step["plugintypeid"] = new EntityReference("plugintype", pluginTypeId);
    step["sdkmessageid"] = new EntityReference("sdkmessage", sdkMessageId);
    step["sdkmessagefilterid"] = new EntityReference("sdkmessagefilter", sdkMessageFilterId);if (impersonatingUserId != Guid.Empty)
        step["impersonatinguserid"] = new EntityReference("systemuser", impersonatingUserId);try
    {
        Guid stepId = service.Create(step);return stepId;
    }catch (InvalidPluginExecutionException invalidPluginExecutionException)
    {throw invalidPluginExecutionException;
    }catch (Exception exception)
    {throw exception;
    }
}

private Guid GetSdkMessageId(string SdkMessageName)
{try
    {//GET SDK MESSAGE QUERY
        QueryExpression sdkMessageQueryExpression = new QueryExpression("sdkmessage");
        sdkMessageQueryExpression.ColumnSet = new ColumnSet("sdkmessageid");
        sdkMessageQueryExpression.Criteria = new FilterExpression
        {
            Conditions =
                {new ConditionExpression
                    {
                        AttributeName = "name",
                        Operator = ConditionOperator.Equal,
                        Values = {SdkMessageName}
                    },
                }
        };//RETRIEVE SDK MESSAGE
        EntityCollection sdkMessages = service.RetrieveMultiple(sdkMessageQueryExpression);if (sdkMessages.Entities.Count != 0)
        {return sdkMessages.Entities.First().Id;
        }thrownew Exception(String.Format("SDK MessageName {0} was not found.", SdkMessageName));
    }catch (InvalidPluginExecutionException invalidPluginExecutionException)
    {throw invalidPluginExecutionException;
    }catch (Exception exception)
    {throw exception;
    }
}

private Guid GetSdkMessageFilterId(string EntityLogicalName, Guid sdkMessageId)
{try
    {//GET SDK MESSAGE FILTER QUERY
        QueryExpression sdkMessageFilterQueryExpression = new QueryExpression("sdkmessagefilter");
        sdkMessageFilterQueryExpression.ColumnSet = new ColumnSet("sdkmessagefilterid");
        sdkMessageFilterQueryExpression.Criteria = new FilterExpression
        {
            Conditions =
                {new ConditionExpression
                    {
                        AttributeName = "primaryobjecttypecode",
                        Operator = ConditionOperator.Equal,
                        Values = {EntityLogicalName}
                    },new ConditionExpression
                    {
                        AttributeName = "sdkmessageid",
                        Operator = ConditionOperator.Equal,
                        Values = {sdkMessageId}
                    },
                }
        };//RETRIEVE SDK MESSAGE FILTER
        EntityCollection sdkMessageFilters = service.RetrieveMultiple(sdkMessageFilterQueryExpression);if (sdkMessageFilters.Entities.Count != 0)
        {return sdkMessageFilters.Entities.First().Id;
        }thrownew Exception(String.Format("SDK Message Filter for {0} was not found.", EntityLogicalName));
    }catch (InvalidPluginExecutionException invalidPluginExecutionException)
    {throw invalidPluginExecutionException;
    }catch (Exception exception)
    {throw exception;
    }
}

private Guid GetPluginAssemblyId(string assemblyName)
{try
    {//GET ASSEMBLY QUERY
        QueryExpression pluginAssemblyQueryExpression = new QueryExpression("pluginassembly");
        pluginAssemblyQueryExpression.ColumnSet = new ColumnSet("pluginassemblyid");
        pluginAssemblyQueryExpression.Criteria = new FilterExpression
        {
            Conditions =
                {new ConditionExpression
                    {
                        AttributeName = "name",
                        Operator = ConditionOperator.Equal,
                        Values = {assemblyName}
                    },
                }
        };//RETRIEVE ASSEMBLY
        EntityCollection pluginAssemblies = service.RetrieveMultiple(pluginAssemblyQueryExpression);
        Guid assemblyId = Guid.Empty;if (pluginAssemblies.Entities.Count != 0)
        {//ASSIGN ASSEMBLY ID TO VARIABLE
            assemblyId = pluginAssemblies.Entities.First().Id;
        }return assemblyId;
    }catch (InvalidPluginExecutionException invalidPluginExecutionException)
    {throw invalidPluginExecutionException;
    }catch (Exception exception)
    {throw exception;
    }
}

private Guid GetPluginTypeId(Guid assemblyId, string PluginTypeName)
{try
    {//GET PLUGIN TYPES WITHIN ASSEMBLY
            QueryExpression pluginTypeQueryExpression = new QueryExpression("plugintype");
            pluginTypeQueryExpression.ColumnSet = new ColumnSet("plugintypeid");
            pluginTypeQueryExpression.Criteria = new FilterExpression
            {
                Conditions =
                {new ConditionExpression
                    {
                        AttributeName = "pluginassemblyid",
                        Operator = ConditionOperator.Equal,
                        Values = {assemblyId}
                    },new ConditionExpression
                    {
                        AttributeName = "typename",
                        Operator = ConditionOperator.Equal,
                        Values = {PluginTypeName}
                    },
                }
            };//RETRIEVE PLUGIN TYPES IN ASSEMBLY
            EntityCollection pluginTypes = service.RetrieveMultiple(pluginTypeQueryExpression);//RETURN PLUGIN TYPE IDif (pluginTypes.Entities.Count != 0)
            {return pluginTypes.Entities.First().Id;
            }thrownew Exception(String.Format("Plugin Type {0} was not found in Assembly", PluginTypeName));
    }catch (InvalidPluginExecutionException invalidPluginExecutionException)
    {throw invalidPluginExecutionException;
    }catch (Exception exception)
    {throw exception;
    }
}

As you can see, the process is pretty simple, but requires a lot of trips to get the unique identifier values of the Assembly, Plugin Type, Plugin and Message Id, and Message Filter Id.

Recently I had this question come up, and wanted to discuss the difference between closing an incident (Case) as resolved, or closing an incident as cancelled. There are a few other options, but we will focus on these two.

The Case entity in CRM, has an associated entity called Case Resolution (incidentresolution). When a case was opened and then completed with a resolution, the closure of the case will be via the Incident Resolution Entity, as shown in the code below. 

IncidentResolution resolution = new IncidentResolution
{
   Subject = "Resolved Sample Incident",
   IncidentId = new EntityReference(Incident.EntityLogicalName, _incidentId)
};// Close the incident with the resolution.
CloseIncidentRequest request = new CloseIncidentRequest
{
   IncidentResolution = incidentResolution,
   Status = new OptionSetValue((int)incident_statuscode.ProblemSolved)
};

CloseIncidentResponse closeResponse = (CloseIncidentResponse)service.Execute(closeIncidentRequest);

However, when an incident as cancelled, there is no resolution, so the closure of the incident happens directly within the Case entity, and there is no need for a closure. See the code below to notice the difference.

SetStateIncidentRequest request = new SetStateIncidentRequest()
{
   IncidentState = new OptionSetValue(2), // Cancelled
   IncidentStatus = new OptionSetValue(6), // Cancelled
   EntityId = new EntityReference("incident", incidentId)
}

The telephone fields in account, contact and lead entities do not really come with any formatting rules for particular countries. The phone field format setting might resolve some issues, but not all of them.

Let’s take the following scenarios of users entering phone numbers:

In order to resolve this issue we first get remove all of the non-numeric characters. This logic might require if you want to support extensions. Once we remove the non-numeric characters, we need to check the length of the phone number and apply our business rules based on that.

The following JavaScript code takes care of this situation:

function formatPhoneNumber()
{var phoneNumber = Xrm.Page.getAttribute("telephone1").getValue()var fixedNumber = string.replace(/[^0-9]/g, '');var output = "";switch (fixedNumber.length)
    {case 7:
            output = fixedNumber.substring(0, 3) + "-" + fixedNumber.substring(4, 7);break;case 10:
            output = "(" + fixedNumber.substring(0, 3) + ") " + fixedNumber.substring(4, 6) + "-" + fixedNumber.substring(7, 10);break;case 11:if (fixedNumber.substring(0, 1) == "1")
                output = "(" + fixedNumber.substring(1, 4) + ") " + fixedNumber.substring(5, 7) + " " + fixedNumber.substring(8, 11);else
                output = fixedNumber;break;default:// Error No Output
            output = phoneNumberbreak;
    }
    Xrm.Page.getAttribute("telephone1").setValue(output);
}

You can modify the code above to accept the name of the field instead of hard coding it, so that the same logic can be applied to multiple controls

function formatPhoneNumber(fieldName)
{var phoneNumber = Xrm.Page.getAttribute(fieldName).getValue()// Phone Number formatting logic comes here
    Xrm.Page.getAttribute(fieldName).setValue(output);
}

Editable grids were introduced as a new custom control in Microsoft Dynamics 365, which provide inline editing capabilities for data within the main grid and form subgrids for web and mobile clients.

The editable grids include support for grouping, sort and filtering data within the grid, so that we don’t have to switch between records and views.

Editable grids support read-only fields, business rules and scripting, so that business logic can be applied to them.

To enable editable grid on the entity, we navigate to the Entity properties within the solution, and click on the Controls tab. There, we click on the Add Control… link (1), and select Editable Grid from the list of controls. Once added, change the Web option from Microsoft Dynamics Read-only Grid (default) to Editable Grid (2). Configure the properties of the grid (3), as shown below.

To enable the editable grid on a form (subgrid), navigate to the form design, click on the grid properties, and then click on the Controls Tab. Follow the same instructions as for the home page grid.

In the Editable Grid view, select the Grid View, and add any associated controls (lookup controls). You can also configure grouping and nested grids if necessary.

Editable grids are still in their first release, and I am sure that we will see more capabilities in the future, but after waiting for this for such a long time, I would say Microsoft has done a pretty good job for their first release.

If you are interested in looking at some of the contenders for editable grids, the following can assist:

EditAble CRM Grid by AbleBridge

Editable Grid by Sonoma Partners

PowerGrid by Power Objects

When developing web resources that are embedded on a CRM form, you sometimes have to call a function on the parent form. In the past (prior to CRM 2016), you could simply call the function by using parent.myFunction(), however that logic does not work anymore.

In CRM 2016 or Dynamics 365, we can only call the Xrm functions on the parent page such as Xrm.Utility...

In order to be able to address the issue that we have, the first thing that we need to do is create a new function on the parent JavaScript web resource that utilizes the Xrm namespace, such as Xrm.Utility.MyFunction:

Xrm.Utility.myFunction= function()
{var stage = new Object();
    stage.number = stageNumber;
    stage.name = stageName;return stage;
}

 Once we created this function, we can modify our Html Web Resource, and call the function in the following way:

var stage = parent.Xrm.Utility.getStage();if (stage.number > 0)
{// Change Stage
}else
{// Set Default Stage
}

Our CRM Exchange Sync with support for Microsoft Dynamics 365 has just been released, now with additional functionality and support for additional environments. The CRM Exchange Sync application provides the capability of synchronizing between Microsoft Dynamics CRM Marketing Lists and Contacts with Exchange Distribution Groups, Mail Contacts and Mail User records. The application retrieves the data from Microsoft Dynamics CRM Marketing Lists (both static or dynamic), and adds the members of the lists to Microsoft Exchange. If the members already exist in Exchange, the application can update them.

From the Microsoft Dynamics CRM side, the application supports Dynamics CRM 2013, CRM 2015, CRM 2016, Microsoft Dynamics CRM Online and Microsoft Dynamics 365. On the Exchange Server side, the application support Microsoft Exchange 2010, Microsoft Exchange 2013, Microsoft Exchange 2016, as well as Microsoft Exchange Online (via an Office 365 subscription).

The CRM Sync solution includes features such as such as Automatic Synchronization, Field Mapping and Custom entity relationships.

It is available for a 30-day trial.

Finally, after a long wait, editable grids are here. With the release of the editable grids, there have been some changes implemented not only on the grid, but also on the way that data that is manipulated from the form. There is now a single set of code that can be run from both the form and the grid, so that you don't have to write your code separately for each.

Since we can't use the Xrm.Page functions on the editable grid, we have to use the methods of the executionContext. The first thing that has to be done, is both on the editable grid field and on the form field, where we want to capture the event of the changed field, is pass the execution Context. This means our function header will look something like this:

function accountOnChange(context)

 Within our function, we will need to get the entity and field data of the field that we are trying to capture. In our case, our field will be accountid. We first need to get the entity object. In order to get the entity object, we can use data.entity or getData().getEntity() function of getFormContext, as shown below:

var entityObject = context.getFormContext().data.entity;// orvar entityObject = context.getFormContext().getData().getEntity();

 Next we need to get the value of the attribute that we are looking for. We can use the getByName method to retrieve the attribute by Name, or we can loop through list of attributes as well.

var account = entityObject.attributes.getByName("accountid").getValue();

 Finally, we can get the id and name values of the object that I just retrieved from the entityObject attribute by using the id and name properties:

var accountId = account[0].id;var accountName = account[0].name;

 That is basically it. We are using a single set of code to handle a field change event on both form and editable subgrid. Below is the full codeset:

function accountOnChange(context)
{var entityObject = context.getFormContext().getData().getEntity();var account = entityObject.attributes.getByName("accountid").getValue();var accountId = accountValue[0].id;var accountName = accountValue[0].name;
}

Towards the end of June, Microsoft announced that the Microsoft Dynamics CRM/365 Outlook client will be deprecated in a future release. The Legacy Outlook client has been around since early versions of Dynamics CRM. The deprecation of the Outlook client does not mean that this is happening immediately, but is planned for the next Major Release (version 10). Version 9.0 is on the way, and the Outlook client will still be included, but with no additional features or enhancements.

The main reason for deprecating the Outlook client is that it does not have the capabilities that are expected from it with the latest releases of CRM. The Outlook Client is a COM addin, which are only supported in some versions of Microsoft Outlook (such as the desktop version). In the last few years, the Microsoft Office product group releases the Office add-ins feature, which does not rely on code that is installed on the user machine, so that results more reliable and easier to maintain.

The new add-ins can run on the Outlook Web App, Mobile Outlook and Outlook for Mac. With the new enhancements to Microsoft Dynamics 365, the July update and future releases, additional enhancements and improvements will be added to the Outlook addin, which is now called the Dynamics 365 App for Outlook.

In the upcoming release of Dynamics CRM (July 2017 update, or v9) additional enhancement were introduced tto the addin, which include more information that is available to the user in addition to tracking and viewing of additional information related to email recipients or regarding records. Users will also be able to search for records or navigate to records all from within the app.

With the upcoming release of Dynamics CRM (version 9.0), or with the new Dynamics 365 Customer Engagement, Microsoft is continuing to provide additional tools for customizing your solutions.

The short list below contains some of the new customization features that will be available in the new release:

Virtual Entities

We might have ways to integrate our data with external systems, but now with Virtual entities, we will be able to make integration with third party system easier through connectivity to service endpoints and built-in data retrieval methods.

Virtual entities are custom entities that retrieve data in runtime for external data sources and appear as regular entities in CRM (Dynamics 365) using an OData4 data provider which is included for connectivity help.

Virtual entities provide end users, customizers and developer the same type of access that they would have with custom entities. Data from virtual entities is available on forms and views, data grids, reports, dashboards or via the CRM SDK.

Sitemap Designer

Although sitemap designer was release in the previous version Dynamics 365, it now contains a few new features which include: setting the interactive dashboard as the default dashboard subarea for apps based on the Unified Interface framework; Copying of sitemap components; and support for miscellaneous privileges within app subareas.

Form and View Designers

The new form and view designers in Dynamics 365 provides a new intuitive design with drag and drop capabilities for arranging the fields on the form or view, inline access to fields and sections.

The view designer also provides single click sorting of fields, side by side configuration of filters and columns and sample data in grids that provide a near-runtime snapshot of the view.

MultiSelect option set

System Customizers now have the ability to add multi-select option sets fields to forms, views and grids. The MultiSelect optionset field provides the ability of adding multiple values, such as Country or State

As we are all eagerly waiting for the release of the July 2017 Update (v9) of Microsoft Dynamics 365, let's take out time and look at some of the differences between the Business and Enterprise editions. Both editions combine the power of CRM and ERP, but what are the real differences.

Dynamics 365 Business Edition

The Dynamics 365 Business edition encompasses Sales and Customer Service (Customer Engagement), ERP, Marketing and Customer Insights using the tools that we have become familiarized with. The ERP functionalities of the Business edition are the same (or most of the same) functionalities that used to be in Dynamics NAV. All the Business Edition Modules have only a subset of the functionality of the Enterprise Edition.

Dynamics 365 Enterprise Edition

The Dynamics 365 Enterprise edition encompasses the same elements of the Business Edition, but is designed for larger enterprises, so some of the features though available for both are not the same. The ERP functionalities of the Enterprise Edition are build on Dynamics AX. This edition is usually recommended for larger organizations of 250 employees or more. Another difference for example is the marketing module. The Marketing module in Enterprise edition uses Adobe as the marketing tool, while the Business Edition uses a different tool (which we are all waiting to see the highlights of).

The enterprise edition has the full functionality of the following modules: Finance and Operations (ERP using AX), Sales and Customer Service (Customer Engagement), Marketing (Adobe Marketing Cloud), Project Service Automation, Field Service, Retail and Talent. Future modules will most likely become part of the Enterprise Edition.

Let's look at some of the differences of what is included in each of the product:

So the question is which to get? Based on the business needs of your organization, you have enough choice whether to choose Microsoft Dynamics 365 Business Edition or Microsoft Dynamics 365 Enterprise Edition. If still uncertain, wait for the release and get trial versions of Business and Enterprise editions and test the features out. It is still uncertain as the final details have not yet been completed, but businesses should be able to combine licenses for both Business and Enterprise edition.

Dynamics 365 for Outlook (Outlook Client)

The Dynamics 365 App for Outlook, which was introduced in the Dynamics CRM 2016 version is the most up-to-date solution designed to pair Dynamics 365 with Microsoft Outlook. With the Dynamics 365 App for Outlook, contextual information from Dynamics 365 can appear right inside the Outlook Inbox, and with a single click, Outlook messages or appointments can be linked to Dynamics 365 records. Note that the Dynamics 365 App for Outlook only works with Server Side Sync.

Service Scheduling in Dynamics 365 for Customer Service

The Unified Resource Scheduling solution is not included with Dynamics 365 Field Service. With this solution you can automatically set up scheduling of multiple booking requirements on recurring basis. URS takes many constaints into account, such as resource availability, required skills, working hours, duration and time windows to optimize schedule. The URS solution will provide feature parity with the existing service scheduling feature, and existing service scheduling users will be provided advance notice for a timebound migration to the new service scheduling capabilites.

Dialogs

Dialog processes create an interactive step by step data entry form that requires user input to start and run to completion. Dialogs are replaced by mobile task flows and business processe flows. Both task flows and business process flows will continue to evolve to make the transition easier.

Parature Knowledgebase

The Knowledge Management features in Dynamics 365 will be replacing the usage of Parature as the Dynamics 365 knowledge management solution. Parature will be removed from the Knowledge Base Management Settings dialog box, which provides the connection between Parature and Dynamics 365.

Project Service Finder app

The Project Service Finder App, available for use with Dynamics 365 for PSA will be replaced in a future release of Dynamics 365 in the Dynamics 365 for Project Service Automation application.

Contracts, Contract Line Items and Contract Templates

Contracts, Contract Line Items and Contract Templates will be removed in a future major release of Dynamics 365 and are being replaced by Entitlements in Dynamics 365 for Customer Service.

Standard SLAs in Dynamics 365 for Customer Service

Standard Service Level Agreements (where the SLA Type field is set to Standard) will be removed in a future major release of Dynamics 365, and will be replaced by Enhanced Service Level Agreements.

Relationship Roles

Connection Roles have been added to Microsoft Dynamics 365 a few years back and will be replacing the Relationship Roles which have been available for the time being.

Mail Merge

Server Side Document Generation using Microsoft Word and Microsoft Excel templates where introduced with Dynamics CRM 2016. These templates can be used to provide standarized documents or customized data analysis for your organization. The Mail Merge feature that was previously available is now being deprecated.

Announcements

Announcements are deprecated and will be completely removed in a future major release of Dynamics 365. No replacement will be provided at this point.

Ready-to-use business processes available through Add Ready to Use Business Processes settings

The Ready-to-use business processes that are available throught the Add Ready-to-Use Business Processes setting are bring replaced with business processes that are available on App Source.

EntityMetadata.IsInteractionCentricEnabled property

All entities supported in the Unified Interface are now enabled for the interactive experience using the new Customer Serice Hub app. This means that the IsInteractionCentricEnabled property is now irrelevant. The Enable for Interactive Experience is removed from the current release, and the IsInteractionCentricEnabled property will be removed from a future release of the SDK for Customer Engagment.

Silverlight (XAP) Web Resource

The Silverlight (XAP) web resource is no longer supported on the Unified Interface. Instead of using Silverlight web resouces, custom controls created using the Custom Control Framewok or HTML web resources with HTML5 must be used to created UI components and interact with data. CCF is introduced as a preview only in this release.

Client APIs

Some Client APIs are being deprecated. See separated blog post for deprecated Client APIs.