Blog

 While working on a Power Pages implementation I was consume the Power Pages API to get a Lookup table so I could show and hide information on the form using jQuery.  One issue I was having is I couldn't get a lookup field to return even though I had it as a field in the site setting for the table and included it in the my select statement in the URL.  I kept getting an `unexpected error occurred`.

This issue is caused because lookup's are made up using 3 fields.

1) Formatted Value = The information you see in the lookup field (i.e. the record name)

2) Logical Name = The table the related record is a part of

3) Id = The id of the related record

In the api there is a 4th field that is returned that is the Associated Navigation Property and it is the logical name of the lookup field.

When setting up our select and even saying what columns can be returned in the API, we have to think how the OData endpoint will return the data to us.  The easy way to do this with a lookup is to add a `_` to the beginning of the field schema name and append `_value` to the end of the schema name.

Example:

`_new_lookupField_value`

Place that value in the fields site setting for the enabled endpoint, if not using `*` and add it to your select statement in the URL.  You should see the error go away and you should see returned data similar to this

 {  
      "@odata.context": "https://myportal.powerappsportals.com/_api/$metadata#new_example(new_name,_new_lookupField_value)",  
      "@Microsoft.Dynamics.CRM.totalrecordcount": -1,  
      "@Microsoft.Dynamics.CRM.totalrecordcountlimitexceeded": false,  
      "@Microsoft.Dynamics.CRM.globalmetadataversion": "3068318",  
      "value": [  
           {  
                "@odata.etag": "W/\"3066510\"",  
                "new_name": "Example Name",  
                "_new_lookupField_value@OData.Community.Display.V1.FormattedValue": "Example Lookup",  
                "_new_lookupField_value@Microsoft.Dynamics.CRM.associatednavigationproperty": "new_LookupField",  
                "_new_lookupField_value@Microsoft.Dynamics.CRM.lookuplogicalname": "new_relatedTable",  
                "_new_lookupField_value": "2a9c7024-7ca0-4707-f086-419f27c27541"  
           },{  
                "@odata.etag": "W/\"2610804\"",  
                "new_name": "Example of Null",  
                "_new_lookupField_value": null  
           }  
      ]  
 }  

I have a handful of reusable code that I use when creating plugins or external process (i.e. Azure Functions) for working with DataVerse. The first one I am providing is Getting a Record By Id:

1:  private static Entity GetFullRecord(string entityName, string primaryKey, Guid recordId, IOrganizationService service)  
2:  {  
3:       using (OrganizationServiceContext context = new OrganizationServiceContext(service))  
4:       {  
5:            return (from e in context.CreateQuery(entityName)  
6:            where (Guid)e[primaryKey] == recordId  
7:            select e).Single();  
8:       }  
9:  }  

• entityName = The logical name of the entity
• primaryKey = The primary key field for the entity. If using late binding you can create this dynamically by doing:
• $"{target.LogicalName}id"
• recordId = Guid of the record to get
• service = Service to interact with DataVerse

 Recently while working on a Power Pages implementation for a client, I had the requirement to show the last time a user logged in on their profile page.  I thought this would be easy to do as there is already a field on the contact record for "Last Successful Login" (      adx_identity_lastsuccessfullogin).  This use to update when a user logged in, but it appears Microsoft has removed that automation.

While searching I came across a few different ways of achieving this task.  One used application insights in Azure and another one used an HTTP endpoint setup in Power Automate.  I thought, this needs to be simpler.  What I came up with is to use Liquid with JavaScript to tell if a user is logged in or not.  Then use the new Power Pages api to update the logged in users contact record to mark the last time they logged in.

Here is the approach I setup:

1) Make sure you turn on the api for contact in Site Settings.

1) Link to Microsoft Doc On How to turn on the api

2) Make sure you include "adx_identity_lastsuccessfullogin" in the list of fields to return.

2) I tested my process on the home page.  On the home page add two JavaScript Functions.  The first function (CheckIfUserJustLoggedIn) uses Liquid to tell if the user is logged in.  If they are not, it deletes our value from session memory.  If the user is logged in we check session memory to see if there is already a key in there with the date and time the user logged in.  If there is, we don't do anything else.  If there isn't then we create it and we update the contact record for the user via the Power Pages API.  The second function is Microsoft's wrapper function that handles the Ajax call and handles the authentication piece to make sure the user is authorized to perform the option.

1:  function CheckIfUserJustLoggedIn()  
2:  {  
3:    var sessionLastLogin = "sessionLastLogin";  
4:    var isLoggedIn = "{% if user %}true{% else %}false{% endif %}";  
5:    if (isLoggedIn == 'true')  
6:    {  
7:      var userId = "{{user.id}}";  
8:      userId = userId.replace('{', '').replace('}', '');  
9:      var lastLogin = sessionStorage.getItem(sessionLastLogin);  
10:      if (lastLogin == null)  
11:      {  
12:        var dateTimestamp = new Date();  
13:        sessionStorage.setItem(sessionLastLogin, dateTimestamp);  
14:        webapi.safeAjax({  
15:          type: "PATCH",  
16:          url: "/_api/contacts(" + userId + ")",  
17:          contentType: "application/json",  
18:          data: JSON.stringify({  
19:            "adx_identity_lastsuccessfullogin": dateTimestamp  
20:          }),  
21:          success: function (res) {  
22:            console.log(res);  
23:          }  
24:        });  
25:      }  
26:    }  
27:    else  
28:    {  
29:      sessionStorage.removeItem(sessionLastLogin);  
30:    }  
31:  }  

1:  (function(webapi, $){  
2:    function safeAjax(ajaxOptions) {  
3:        var deferredAjax = $.Deferred();  
4:        shell.getTokenDeferred().done(function (token) {  
5:            // add headers for AJAX  
6:            if (!ajaxOptions.headers) {  
7:                $.extend(ajaxOptions, {  
8:                    headers: {  
9:                        "__RequestVerificationToken": token  
10:                    }  
11:                });  
12:            } else {  
13:                ajaxOptions.headers["__RequestVerificationToken"] = token;  
14:            }  
15:            $.ajax(ajaxOptions)  
16:                .done(function(data, textStatus, jqXHR) {  
17:                    validateLoginSession(data, textStatus, jqXHR, deferredAjax.resolve);  
18:                }).fail(deferredAjax.reject); //AJAX  
19:        }).fail(function () {  
20:            deferredAjax.rejectWith(this, arguments); // on token failure pass the token AJAX and args  
21:        });  
22:        return deferredAjax.promise();  
23:    }  
24:    webapi.safeAjax = safeAjax;  
25:  })(window.webapi = window.webapi || {}, jQuery)  

If you run into issues for permissions check your Power Pages Web Roles table and make sure the user has the correct permissions for the contact table.

 Recently I had a requirement for a client to convert their existing site over to Power Pages.  One of the items I needed to convert was a "Recent Announcements" page.  This is a pretty straightforward page with only a title of "Recent Announcements" and a grid showing the announcements.  The grid only has two columns, 'Created On' and 'Message'.  The problem I had to solve was I used the Rich Text Editor control on the 'Message' field.  This means that raw HTML was stored in the field.  Out of the box Power Pages can't render the raw HTML in the column.  This means in the Power Page would have raw HTML showing instead of a nicely formatted message.  This is easily solved with a small JavaScript function.

The first thing I did was create a custom entity in DataVerse called Announcement.  Here is the layout of the fields:

1. Changed the primary name field from 'Name' to 'Subject'.
2. Added a multi-line text field called 'Message'.
3. Add a two-option set field called 'Show in Portal'.
1. This is used to control whether to show the announcement in the portal or not.  This way they can have draft announcements.  I know there are other ways of doing it with Status and Status Reason.  This was just the approach I took.

Dynamics 365, Microsoft's robust suite of business applications, boasts a myriad of features that can be customized to cater to the specific needs of any business. A vital concept to grasp when working with Dynamics 365 is the difference between managed and unmanaged solutions. This blog post aims to clarify these two types of solutions, providing a comprehensive analysis of the advantages and disadvantages of each.

Unmanaged Solutions

Unmanaged solutions act as a dynamic development environment, enabling direct alterations and additions to system components. They are often employed during the development and testing phase of a customization project but are equally effective when implemented in production instances, particularly for internal organizational operations.

Pros of Unmanaged Solutions:

1. Flexibility: Unmanaged solutions provide a high degree of adaptability, permitting developers to modify system components, introduce new elements, or discard those that are no longer necessary.
2. Streamlined Testing: The process of testing and debugging components becomes significantly simplified with unmanaged solutions, as immediate adjustments can be made, and their effects observed in real time.

Cons of Unmanaged Solutions:

1. Risk of Errors: The enhanced flexibility also carries the risk of potential complications. Unintentional modifications or deletions of components can occur, potentially leading to issues on a system-wide level.
2. Lack of Layering: Unmanaged solutions do not support layering, which can result in conflicts when multiple developers are working simultaneously on a project.

Managed Solutions

A managed solution is a finalized, locked package that can be distributed and installed across various environments. It is essentially an unmodifiable version of an unmanaged solution. Managed solutions are most suitable for the distribution of completed customizations or applications, especially when these solutions are being sold to external clients.

Pros of Managed Solutions:

1. Protection of Intellectual Property: Managed solutions safeguard the intellectual property of the developers or the organization that created them, as they are sealed and cannot be directly modified.
2. Convenient Distribution: Managed solutions can be easily distributed and installed across different environments, making them an excellent choice for delivering final customizations or applications.
3. Supports Layering: Unlike unmanaged solutions, managed solutions support layering, allowing the simultaneous installation of multiple solutions without conflicts.

Cons of Managed Solutions:

1. Limited Flexibility: Managed solutions offer less flexibility due to their sealed nature. Any necessary modifications would require an update from the developer and a subsequent reinstallation.
2. Dependency Concerns: Managed solutions may create dependencies. Components within a managed solution cannot be deleted if they are being referenced by another solution.

In conclusion, the choice between managed and unmanaged solutions in Dynamics 365 largely depends on your specific needs. If you are developing, testing, or implementing internal operational changes, an unmanaged solution provides the flexibility needed for easy modifications and testing. Conversely, if you are distributing or selling a finalized customization or app, a managed solution offers intellectual property protection, convenient distribution, and supports layering. Understanding these differences and selecting the appropriate solution type is crucial for optimal use of Dynamics 365.

Microsoft Dynamics 365 is a powerful suite of business applications that provides organizations with tools for managing customer relationships, sales, and operations. One of the essential aspects of developing custom plugins for Dynamics 365 is proper logging to ensure smooth functionality and easy debugging.

In this blog post, we'll discuss best practices for logging in Microsoft Dynamics 365 plugins and provide examples to help you implement effective logging in your custom solutions.

Understanding the Plugin Trace Log

Microsoft Dynamics 365 provides a built-in logging mechanism called the Plugin Trace Log. The Plugin Trace Log can be used to record custom messages, exceptions, and other information for debugging purposes. To enable the Plugin Trace Log, follow these steps:

• Navigate to Settings > Administration > System Settings.
• Under the Customization tab, locate the "Plugin and Custom Workflow Activity Tracing" section.
• Set the option to "All" or "Exception" based on your requirements.

With the Plugin Trace Log enabled, you can use the ITracingService to log messages within your plugin code.

Using the ITracingService

`ITracingService` is an interface provided by the Microsoft Dynamics 365 SDK. It offers a simple and powerful way to log messages and exceptions in your plugins. To use the `ITracingService`, you need to instantiate it from the `IServiceProvider` passed to your plugin's Execute method.

Example:

 public class MyPlugin : IPlugin  
 {  
   public void Execute(IServiceProvider serviceProvider)  
   {  
     // Obtain the tracing service  
     ITracingService tracingService = (ITracingService)serviceProvider.GetService(typeof(ITracingService));  
     // Log a simple message  
     tracingService.Trace("MyPlugin started execution.");  
   }  
 }  

Logging Exceptions

When an exception occurs in your plugin, it's crucial to log the error details for troubleshooting purposes. With the `ITracingService`, you can log the exception message and the stack trace.

Example:

 public class MyPlugin : IPlugin  
 {  
   public void Execute(IServiceProvider serviceProvider)  
   {  
     // Obtain the tracing service  
     ITracingService tracingService = (ITracingService)serviceProvider.GetService(typeof(ITracingService));  
     try  
     {  
       // Your plugin logic here  
     }  
     catch (Exception ex)  
     {  
       tracingService.Trace("An exception occurred in MyPlugin: {0}", ex.ToString());  
       throw new InvalidPluginExecutionException($"An error occurred in MyPlugin: {ex.Message}", ex);  
     }  
   }  
 }  

Welcome to the wonderful world of Microsoft's Power Platform! As the digital landscape keeps evolving, so do the ways we can create and manage applications for our businesses. If you're looking to power up your business, you've come to the right place! We'll dive into the whimsical world of Power Apps, Model-Driven Apps, and Power Portals, helping you pick the right tool for the job. So, grab a cup of coffee, get comfy, and let's get started! 😃

 Hey there, code wranglers! Are you ready to dive deep into the fascinating world of Microsoft Dynamics 365? Today, we're going to explore the differences between Early Binding and Late Binding, two popular programming techniques that you can use to make the most out of this powerful platform. We'll compare examples, performance metrics, and development times, and we'll even sprinkle in some references for those of you hungry for more information. So let's saddle up and get started!

Early Binding - A Swift Ride:

Early Binding is like a well-trained horse that knows exactly where it's going. With Early Binding, you'll be working with strongly-typed classes generated from the CRM metadata. This means you'll have access to IntelliSense, making it easy to spot errors during development and reducing the time it takes to write code.

Let's take a look at an example of Early Binding in action:

 using Microsoft.Xrm.Sdk;  
 using Microsoft.Xrm.Sdk.Client;  
 using Microsoft.Crm.Sdk.Messages;  
 using System.ServiceModel;  
 // Connect to the Organization Service  
 IOrganizationService service = GetOrgService();  
 // Create a new account  
 Account newAccount = new Account  
 {  
   Name = "Contoso Ltd.",  
   Address1_City = "Seattle",  
   Address1_StateOrProvince = "WA"  
 };  
 Guid accountId = service.Create(newAccount);  

In this example, we've created an Account entity using the strongly-typed Account class. Not only does this code look clean and easy to read, but it also allows for better error-checking during development.

Late Binding - A Wild Adventure:

Late Binding, on the other hand, is like riding a wild stallion: it offers more freedom, but it's also a bit more challenging to handle. Late Binding uses the Entity class, allowing you to create and manipulate records in a more dynamic way. Here's an example of Late Binding:

 using Microsoft.Xrm.Sdk;  
 using Microsoft.Xrm.Sdk.Client;  
 using Microsoft.Crm.Sdk.Messages;  
 using System.ServiceModel;  
 // Connect to the Organization Service  
 IOrganizationService service = GetOrgService();  
 // Create a new account  
 Entity newAccount = new Entity("account");  
 newAccount["name"] = "Contoso Ltd.";  
 newAccount["address1_city"] = "Seattle";  
 newAccount["address1_stateorprovince"] = "WA";  
 Guid accountId = service.Create(newAccount);  

In this case, we've used the generic Entity class and specified the entity type with a string. While this approach is more flexible, it lacks the benefits of IntelliSense, making it more error-prone and increasing development time.

Performance Metrics and Development Time:

Early Binding tends to have better performance due to its strongly-typed nature. However, the difference in performance between the two approaches is often negligible, particularly for smaller-scale projects. When it comes to development time, Early Binding is generally faster, thanks to IntelliSense and better error-checking.

Conclusion:

Whether you choose Early Binding or Late Binding, Microsoft Dynamics 365 has the power and flexibility to help you create amazing applications. Just remember, like any good wrangler, you need to choose the right technique for the job. Don't be afraid to mix and match both approaches based on your project's specific needs and your own coding style.

Recommendations on when to use each:

1. Early Binding:
• When you need better compile-time error checking and type safety.
• If you prefer working with IntelliSense for a more streamlined development experience.
• When your project requires a more structured and organized coding style.
• If your team is already familiar with the Dynamics 365 SDK and its generated types.
2. Late Binding:
• When you need more flexibility and adaptability in your code.
• If you're working with a dynamic system where the schema or entity types may change frequently.
• When your project is smaller in scale and doesn't require the full advantages of Early Binding.
• If you're building a generic or reusable solution that needs to work with multiple Dynamics 365 environments or versions.

Now that you know the differences between Early and Late Binding and have some recommendations on when to use each, you're ready to ride off into the sunset and create some fantastic solutions for your organization. Remember, practice makes perfect, so don't shy away from experimenting with both techniques to see which one works best for you. The more you learn and adapt, the better your coding skills will become. So grab your hat, your coding boots, and your trusty steed, and embark on your own coding adventure with Microsoft Dynamics 365!

Happy coding, partner!

Embarking on the Microsoft Dynamics 365 customization journey offers numerous opportunities to enhance your business processes. However, deciding between the available options, such as Plugins and Azure Functions, can be challenging. This engaging post will serve as your trusty guide, helping you choose the best option for your Dynamics 365 customization needs!

The Two Customization Pathfinders: Plugin and Azure Function

The Agile Plugin 🏃‍♂️

Reference: Microsoft Docs - Write a plug-in

Plugins are like the swift trail runners of the Dynamics 365 customization world. They're the go-to choice for quick, real-time (synchronous), or background (asynchronous) operations that occur within the platform. They can intercept events and modify data before it's saved or displayed to the user.

Choose Plugins when:

• You need real-time processing (synchronous) or background processing (asynchronous).
• You want to ensure data integrity.
• You need tight integration with Dynamics 365.

Plugins might not be the best choice for long-running processes, as they could slow down the overall performance of your system if synchronous or consume system resources if asynchronous.

The Powerful Azure Function 🚀

Reference: Microsoft Docs - Azure Functions Documentation

Azure Functions, like the high-powered rocket ships of the customization world, bring power and scalability to your Dynamics 365 customizations. They're perfect for more complex or compute-intensive tasks that require the full power of the Azure platform. Azure Functions can be triggered by various events and can interact with other Azure services, opening up a world of possibilities.

Choose Azure Functions when:

• You need advanced processing capabilities or complex logic.
• You require integration with other Azure services.
• You want to leverage the power and scalability of Azure.

Azure Functions could be overkill for simple, real-time operations, so consider Plugins if your customization needs are more straightforward.

To integrate Azure Functions with Dynamics 365, you can create a custom connector in Power Apps, which can also be applied to Dynamics 365. This approach allows you to call your Azure Function from within your Dynamics 365 solution.

Conclusion

To recap, choose Plugins for real-time (synchronous) or background (asynchronous) operations with tight integration to Dynamics 365, and Azure Functions for advanced processing capabilities and integration with other Azure services. With this guide, you're now equipped to navigate the Dynamics 365 customization landscape and select the perfect customization pathfinder for your needs! 🌄

Hey there, tech enthusiasts! Today, we're diving into the magical realm of Microsoft business solutions, where two powerful forces come together to save the day. That's right; we're talking about Microsoft Dynamics 365 and DataVerse. You might be wondering, "What's the difference between these two superhero-esque solutions?" Well, buckle up, because we're about to take a fantastic voyage to find out!

Section 1: Microsoft Dynamics 365 - The Multifaceted Hero

Microsoft Dynamics 365 is like the Swiss Army knife of business applications. It's a suite of intelligent, interconnected, cloud-based apps that cover various aspects of your business - from sales and marketing to finance and operations. These apps are designed to work together seamlessly, helping you manage every aspect of your business more efficiently. Some of the most popular apps include:

• Dynamics 365 Sales - Your secret weapon for building better customer relationships! [1]
• Dynamics 365 Marketing - The ultimate marketing companion for creating irresistible campaigns! [2]
• Dynamics 365 Finance - The financial wizard that keeps your money matters in check! [3]

These apps, and many more, form a powerful alliance to help you streamline your business processes and make data-driven decisions.

Section 2: DataVerse - The Mighty Data Protector

DataVerse, formerly known as Common Data Service, is the backbone of the Dynamics 365 ecosystem. It's the data management platform that securely stores and manages data used by the Dynamics 365 apps, as well as other custom apps built on the Power Platform. [4]

Think of DataVerse as a mighty guardian, ensuring that your data is organized, secure, and easily accessible for your apps. Its superpowers include:

• Structured data storage: DataVerse organizes your data into neat tables, making it easier for your apps to find and utilize the information they need. [5]
• Data security and compliance: DataVerse is committed to keeping your data safe, ensuring it complies with industry standards and regulations. [6]
• Easy app integration: DataVerse's robust API allows for seamless integration with both Dynamics 365 apps and custom-built apps, creating a powerful and unified data ecosystem. [7]

Section 3: Dynamics 365 and DataVerse - A Dynamic Duo!

While Microsoft Dynamics 365 and DataVerse might seem like two separate entities, they actually work together in perfect harmony. Dynamics 365 apps rely on DataVerse to store and manage the data they need to function, while DataVerse benefits from the functionality and versatility of Dynamics 365 apps.

In essence, Dynamics 365 is the star-studded lineup of apps that power your business operations, and DataVerse is the steadfast guardian that keeps your data secure, organized, and accessible. Together, they form an unstoppable force that helps you run your business like a well-oiled machine.

Conclusion:

Now that we've unraveled the mysteries of Microsoft Dynamics 365 and DataVerse, you can see how they complement each other to create a powerful and comprehensive business solution. This dynamic duo will not only help you streamline your processes but also empower you to make better, data-driven decisions.

So, whether you're in need of a superhero to boost your sales or protect your precious data, look no further than the formidable team of Microsoft Dynamics 365 and DataVerse. With their powers combined, they've got your back, and they're ready to take your business to new heights!

Happy adventuring in the exciting world of Microsoft business solutions!

References:

[1] Dynamics 365 Sales - https://dynamics.microsoft.com/en-us/sales/overview/

[2] Dynamics 365 Marketing - https://dynamics.microsoft.com/en-us/marketing/overview/

[3] Dynamics 365 Finance - https://dynamics.microsoft.com/en-us/finance/overview/

[4] DataVerse - https://docs.microsoft.com/en-us/powerapps/maker/data-platform/data-platform-intro

[5] DataVerse Tables - https://docs.microsoft.com/en-us/powerapps/maker/data-platform/create-edit-tables

[6] DataVerse Security - https://docs.microsoft.com/en-us/powerapps/maker/data-platform/data-platform-security

[7] DataVerse API - https://docs.microsoft.com/en-us/powerapps/developer/data-platform/webapi/overview

Once again, we hope this light-hearted and engaging exploration has given you a better understanding of the differences and synergies between Microsoft Dynamics 365 and DataVerse. With their combined powers, they can truly transform your business, making it more efficient, secure, and data-driven.

Now go forth, armed with the knowledge of this dynamic duo, and conquer your business goals! Adventure awaits in the world of Microsoft business solutions

 FINALLY, Microsoft has pushed an update to the Report Authoring Extension for Dynamics 365 to allow for use of Visual Studio 2019.  This update went live on 12/18/2020 and can be found here.  Installing won't be straight forward into Visual Studio 2019, even if you install everything when you first installed it.  This is because SSDT (SQL Server Data Tools) is installed but, SSAS, SSIS and SSRS are all separate modules for SSDT that you have to install separately.  While you should be fine with just installing SSRS to make this work, I would recommend just installing all 3 parts.  

All of these can be found in Microsoft documentation.  In the "Install SSDT with Visual Studio 2019" section, you will see a link to the marketplace where you can download the extensions and install them.  Once that is done, download the Report Authoring Extension and run the installer.  That is it, you can now work on SSRS within Visual Studio 2019 for Microsoft Dynamics.

 Recently for a client I was given the requirement that they needed to update a custom field on activity records whether it was a completed record or not.  The problem when a record is completed, it is in read only status and users can't update the record easily, with minimal clicks.  To solve this business requirement, I wrote two JavaScript libraries.

1) UnlockFieldsOnLoad - This is the function you should list any field that you want to unlock if the record is in complete (read only status).  This function should run on load of the form and will unlock the fields so they can be updated.

2) OnChangeUnlockedFields - This function is what will do the save when the field(s) are updated.  What it does it check to see if the record is in a read only status.  If if it is, it will make the record active again.  After it makes the record activate again, it will write the change to the database, change the status back to the original status and save that change.

 function UnlockFieldsOnLoad(executionContext)  
 {  
   var formContext = executionContext.getFormContext();   
   formContext.getControl("fieldname").setDisabled(false);  
 }  
 //Saves field value if form is read only.  
 function OnChangeUnlockedFields(executionContext)  
 {  
   var formContext = executionContext.getFormContext();  
   var stateCodeValue = formContext.getAttribute("statecode").getValue()  
   //We only want this JS to run if the record is in read only mode. 1=Completed, 2=Canceled  
   if(stateCodeValue === 1 || stateCodeValue === 2)  
   {  
     //Reactivate the record  
     formContext.getAttribute("statecode").setValue(0);   
     formContext.data.save(6).then(function ()  
     {  
       //Complete Record again  
       formContext.getAttribute("statecode").setValue(stateCodeValue);   
       formContext.data.save();  
     });  
   }  
 }  

 declare @TableName sysname = 'TABLE_NAME'  
 declare @Result varchar(max) = 'public class ' + @TableName + '  
 {'  
 select @Result = @Result + '  
   public ' + (CASE WHEN ColumnName = 'RowVersion' THEN 'byte[]' ELSE ColumnType END) + NullableSign + ' ' + ColumnName + ' { get; set; }'  
 from  
 (  
   select   
     replace(col.name, ' ', '_') ColumnName,  
     column_id ColumnId,  
     case typ.name   
       when 'bigint' then 'long'  
       when 'binary' then 'byte[]'  
       when 'bit' then 'bool'  
       when 'char' then 'string'  
       when 'date' then 'DateTime'  
       when 'datetime' then 'DateTime'  
       when 'datetime2' then 'DateTime'  
       when 'datetimeoffset' then 'DateTimeOffset'  
       when 'decimal' then 'decimal'  
       when 'float' then 'float'  
       when 'image' then 'byte[]'  
       when 'int' then 'int'  
       when 'money' then 'decimal'  
       when 'nchar' then 'string'  
       when 'ntext' then 'string'  
       when 'numeric' then 'decimal'  
       when 'nvarchar' then 'string'  
       when 'real' then 'double'  
       when 'smalldatetime' then 'DateTime'  
       when 'smallint' then 'short'  
       when 'smallmoney' then 'decimal'  
       when 'text' then 'string'  
       when 'time' then 'TimeSpan'  
       when 'timestamp' then 'timestamp'  
       when 'rowversion' then 'byte[]'  
       when 'tinyint' then 'byte'  
       when 'uniqueidentifier' then 'Guid'  
       when 'varbinary' then 'byte[]'  
       when 'varchar' then 'string'  
       else 'UNKNOWN_' + typ.name  
     end ColumnType,  
     case   
       when col.is_nullable = 1 and typ.name in ('bigint', 'bit', 'date', 'datetime', 'datetime2', 'datetimeoffset', 'decimal', 'float', 'int', 'money', 'numeric', 'real', 'smalldatetime', 'smallint', 'smallmoney', 'time', 'tinyint', 'uniqueidentifier')   
       then '?'   
       else ''   
     end NullableSign  
   from sys.columns col  
     join sys.types typ on  
       col.system_type_id = typ.system_type_id AND col.user_type_id = typ.user_type_id  
   where object_id = object_id(@TableName)  
 ) t  
 order by ColumnId  
 set @Result = @Result + '  
 }'  
 print @Result  

 declare @Table sysname = '<INSERT TABLE NAME HERE>';  
 declare @Schema sysname = 'INSERT SCHEMA NAME HERE';  
 declare @Result varchar(max) = 'public enum ' + @Table + 'Columns' + '  
 {'  
 select @Result = CONCAT(@Result, '  
      ',ColName, ' = ', SUM(ColNum), ',')  
 from  
 (  
      select COLUMN_NAME as ColName, SUM(ORDINAL_POSITION - 1) as ColNum  
      from INFORMATION_SCHEMA.COLUMNS  
      where TABLE_NAME = @Table AND TABLE_SCHEMA = @Schema  
      group by COLUMN_NAME  
 ) t  
 group by ColName, ColNum  
 order by ColNum  
 set @Result = @Result + '  
 }'  
 print @Result  

1. Create a user in the Office 365 admin center.  Be sure to assign a Dynamics 365 (online) license to the account.
2. Go to Dynamics 365 (online).
3. Go to Settings > Security.
4. Choose Users > Enabled Users, and then click a user’s full name.
5. In the user form, scroll down under Administration to the Client Access License (CAL) Information section and select Non-interactive for Access Mode.  You then need to remove the Dynamics 365 (online) license from the account.
6. Go to the Office 365 admin center.
7. Click Users > Active Users.
8. Choose the non-interactive user account and under Product licenses, click Edit.
9. Turn off the Dynamics 365 (online) license, and then click Save > Close multiple times.
10. Go back to Dynamics 365 (online) and confirm that the non-interactive user account Access Mode is still set for Non-interactive.
11. In CRM assign a role to the user account.

 $UserEMail = "<Replace with e-mail>"  
   
 Connect-AzureAD  
   
 Get-AzureADUser -ObjectId $UserEMail | Select-Object UserprincipalName,@{  
   N="PasswordNeverExpires";E={$_.PasswordPolicies -contains "DisablePasswordExpiration"}  
  }  
   
  Set-AzureADUser -ObjectId $UserEMail -PasswordPolicies DisablePasswordExpiration  
   
  Get-AzureADUser -ObjectId $UserEMail | Select-Object UserprincipalName,@{  
   N="PasswordNeverExpires";E={$_.PasswordPolicies -contains "DisablePasswordExpiration"}  
  }  

1. Check's the plugin context to see if we are trying to update the emailaddress1 or emailaddress2.  
2. If we are trying to update either email address.  Than we check to see if context value is null, "" or string.empty.  We also double check to make sure that the field is in the context, since my first if is an OR statement.
3. If there is a value, then we move on.  But, if we are trying to blank out the email address, I simply remove the attribute from the context.

 using Microsoft.Xrm.Sdk;  
 using System;  
 namespace ContactEmailValidation  
 {  
   public class ValidateEmail : IPlugin  
   {  
     public void Execute(IServiceProvider serviceProvider)  
     {  
       ITracingService tracer = (ITracingService)serviceProvider.GetService(typeof(ITracingService));  
       IPluginExecutionContext context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));  
       IOrganizationServiceFactory factory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));  
       IOrganizationService service = factory.CreateOrganizationService(context.UserId);  
       //Convert context to entity to make it easier to work with.  
       Entity PreValidationData = (Entity)context.InputParameters["Target"];  
       //Check if email fields are in the context. If they are then we are trying to update them.  
       if(PreValidationData.Contains(ContactConstants.PrimaryEmail) || PreValidationData.Contains(ContactConstants.SecondaryEmail))  
       {  
         //Get current database contact data  
         using (OrganizationServiceContext context = new OrganizationServiceContext(service))  
         {  
           CurrentDatabaseData = (from c in context.CreateQuery("contact")  
                       where (Guid)c[contactid] == id  
                       select c).SingleOrDefault();  
         }  
         tracer.Trace($"Execution context does have either primary email or secondary email in it.");  
         //If primary email is trying to update to null, remove it from the context so we don't clear out the email.  
         if (PreValidationData.Contains(emailaddress1) && (PreValidationData[emailaddress1] == null || PreValidationData[emailaddress1].ToString() == "" || PreValidationData[emailaddress1].ToString() == string.Empty))  
         {  
           tracer.Trace($"Trying to update primary email to null. Removing from context...");  
           PreValidationData.Attributes.Remove("emailaddress1");  
         }  
         //If secondary email is trying to update to null, remove it from the context so we don't clear out the email.  
         if (PreValidationData.Contains(emailaddress2) && (PreValidationData[emailaddress2] == null || PreValidationData[emailaddress2].ToString() == "" || PreValidationData[emailaddress2].ToString() == string.Empty))  
         {  
           tracer.Trace($"Trying to update secondary email to null. Removing from context...");  
           PreValidationData.Attributes.Remove("emailaddress2");  
         }  
         //Update the plugin context that will be saved to the database.  
         tracer.Trace($"Setting target to new context values.");  
         context.InputParameters["Target"] = PreValidationData;  
       }  
     }  
   }  
 }  

 function ShowHide(executionContext)  
 {  
   //Create the form context  
   var formContext = executionContext.getFormContext();  
   var contactStatus = formContext.getAttribute("Field Name").getValue();  
   var tabObj = formContext.ui.tabs.get("Tab Name");  
   var sectionObj = tabObj.sections.get("Section Name");  
   if (contactStatus === 1)  
   {  
     sectionObj.setVisible(true);  
     formContext.getAttribute("fieldName").setRequiredLevel("required");  
   }  
 }  

 public List<Entity> GetRelatedRecords(Guid parentID, IOrganizationService service)  
 {  
      OrganizationServiceContext context = new OrganizationServiceContext(service);  
      List<Entity> oProducts = (from r in context.CreateQuery(RELATIONSHIP_NAME)  
                                     join eOne in context.CreateQuery(ENTITY_ONE_LOGICALNAME) on r[ENTITY_ONE_UNIQUEID_LOGICALNAME] equals eOne[ENTITY_ONE_UNIQUEID_LOGICALNAME]  
                                     join eTwo in context.CreateQuery(ENTITY_TWO_LOGICALNAME) on r[ENTITY_TWO_UNIQUEID_LOGICALNAME] equals eTwo[ENTITY_TWO_UNIQUEID_LOGICALNAME]  
                                     where (Guid)eOne[ENTITY_ONE_UNIQUEID_LOGICALNAME] == parentID  
                                     select eTwo).ToList();  
      return oProducts;  
 }  

 ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12  

     public string SendRequest(string username, string password, string url, string method)  
     {  
       WebResponseFactory factory = new WebResponseFactory();  
       ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;  
       HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);  
       request.Method = method;  
       request.Headers.Add("Authorization", "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username}:{password}")));  
       request.ContentType = ParameterContentTypeSettings.applicationjson;  
       request.ContentLength = 0;  
       HttpWebResponse response = (HttpWebResponse)request.GetResponse();  
       return factory.ProcessResponse(response);  
     }  

        public string SendRequest(string username, string password, string url, string method, string contentBody)  
     {  
       ASCIIEncoding encoding = new ASCIIEncoding();  
       byte[] encodedData = encoding.GetBytes(contentBody);  
       WebResponseFactory factory = new WebResponseFactory();  
       HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);  
       request.Method = method;  
       request.Headers.Add("Authorization", "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username}:{password}")));  
       request.ContentType = ParameterContentTypeSettings.applicationjson;  
       request.ContentLength = encodedData.Length;  
       var requestStream = request.GetRequestStream();  
       requestStream.Write(encodedData, 0, encodedData.Length);  
       requestStream.Close();  
       HttpWebResponse response = (HttpWebResponse)request.GetResponse();  
       return factory.ProcessResponse(response);  
     }  

• WaelHamze. (n.d.). BDD/TDD for Dynamics 365 CE. Retrieved from https://github.com/WaelHamze/dyn365-ce-bdd
• TechTalk SpecFlow Team. (n.d.). SpecFlow for Visual Studio 2017. Retrieved from https://marketplace.visualstudio.com/items?itemName=TechTalkSpecFlowTeam.SpecFlowforVisualStudio2017
• Microsoft. (2018, February 27). Microsoft/EasyRepro. Retrieved from https://github.com/Microsoft/EasyRepro
• Dynamics Value. (n.d.). Retrieved from https://dynamicsvalue.com/home
• Jordimontana82/fake-xrm-easy. (n.d.). Retrieved from https://github.com/jordimontana82/fake-xrm-easy
• Agile Alliance. (n.d.). Behavior Driven Development. Retrieved from https://www.agilealliance.org/glossary/bdd/#q=~(filters~(postType~(~'page~'post~'aa_book~'aa_event_session~'aa_experience_report~'aa_glossary~'aa_research_paper~'aa_video)~tags~(~'bdd))~searchTerm~'~sort~false~sortDirection~'asc~page~1)
• UI Automation for Dynamics 365 CE – EasyRepro (Part 2). (2018, January 10). Retrieved from https://waelhamze.wordpress.com/2018/01/04/ui-automation-for-dynamics-365-ce-easyrepro-part-2/
• SpecFlow. (n.d.). SpecFlow Getting Started. Retrieved from http://specflow.org/getting-started/#InstallSetup
• Seleniumhq. (n.d.). Retrieved from https://www.seleniumhq.org/

• Performance - There does appear to be improvement to how well the platform functions in Chrome (Chrome is my primary browser).  Previously, I did have some performance issues in Chrome and on larger map's I would have to dump my cache or exit chrome and re-launch to speed it back up again (not always the case, but did need done from time to rime).  This appears to be eliminated for me.  I can clearly see marked improvements when it comes to lag and performance. *See bullet point 4 under Platform which is under Enhancements.

• Agent Request Logs - Users now have the ability to request the logs from the agent without logging into the server where the agent is installed to get them.  Simple go to the agent in Scribe Online and click on the gear that will appear on the right side of the agent table.  Click on "Request Logs".  This will download a zip file with the logs for you to review. *See Agents section. 

• Revision History - At the bottom of each mapping you will see a "Revision Comment" box.  While working on a mapping you can insert a comment into this box to log what you are updating on the map.  Every time you click "Apply" of "Ok" to save the map, a revision is stored.  This way if you need to go back and restore a previous revision you can.  To view the revision history go to the map in your solution and click on the gear to the right of your map and look for "Revisions"  I will do a more detailed blog post on this one in the future. * See Maps Section.
• Debugging - This was a bug that I ran into previously.  In previous release when debugging sometimes the block wouldn't enter where the error happens.  This could cause confusion as to what the problem was.  Also the error when this happened wouldn't appear.  This bug has been squashed.  Debugging is working like a charm and errors are properly appearing and making it really easy to figure out what is happening when debugging a map. * See Debug Section

• Visual Studio - IDE for writing the connector code
• GitLab Account - This is where you will upload connector code that needs to be validated by Scribe.
• GitLab Extension for Visual Studio - This will make uploading the code to Scribe a lot easier.
• Scribe Online Sandbox Instance - These instances are only for creating and testing connectors that you are developing and not for production use.
• Connector Development Kit (CDK) - This will include the Fast Connector Framework for both Integration and Messaging along with references we need when creating a connector from scratch.
• Scribe Developer Portal - This is where you can find all the information you will want to reference when creating your connector.

1. If Product To Add - This is the null handler.  If the field where the products are listed in the source is null, then we skip adding any products in the target system.
2. Lookup uom - This is target specific related record and not important for what we are working on.
3. Upsert Counter - Here is where we declare our counter in the the Scribe Labs - Variable connector.  For this I choose NumVarible and set the name to "counter" and the val to 1.
4. Loop - Now we enter our loop.
5. Get Counter - Here we do a lookup to get the val of the counter.  Yes, we just created the counter, but remember we are in a loop and need this lookup, since we will be updating the value in the loop.
6. Lookup Product - Here is where we lookup the product in the target system.  For the lookup I am doing a like match against the product id field in the target system.  To do this I need to use the parse function in Scribe. Here is how the parse is setup: CONCATENATE("%", STRIP(PARSE(Source Field, Counter_NumVariableLookup.val, ";"),"AN")).  What we will focus on in this function is the Parse() piece.  Within the Parse we have to tell Scribe the field that we want to get the data from.  Then we tell it where specifically in that string we want to look.  Then how the string is delimited.  To make this dynamic, we are using our counter variable.  This means on first run our counter variable is set to one.  So, in a string of "ProductA;ProductB;ProductC" our parse is going to pull out "ProductA" because it is the first sub-string.  When the loop runs again, the counter will be two and "ProductB" will be returned.
7. If Product Found - This if statement is to make sure we don't create any empty line items if the product doesn't exist in the target system.
8. Create opportunityproduct - If we do find 1 product, then we create the record in the target system.
9. Increase Counter - Here is where we increase the val of the counter by 1.
10. If No More to Process - Now that we increased our counter, we need to check our string ("ProductA;ProductB;ProductC") to see if we need to run the loop again.  When you use Parse with a counter like this to get a specific sub-string.  If that we reach the end of the string, in our example that would be 4.  The Parse will return null.  So for our If statement we want to use the ISNULLOREMPTY() to check and see if we reached the end of the string.  We would setup the condition to be ISNULLOREMPTY( PARSE(Source Field, Counter_NumVariableUpsert2.val, ";") ) equals True.
11. Loop Exit - If we have reached the end of our string, then we exit our loop.

1. In Step One, choose if you want a report on notes, emails or both.
2. In Step Two, choose "Report Only".
3. Step Three, click on "Run".

• Current Version: 2018.2.2.7
• Purpose: Download Attachments and E-Mail attachments
• GitHub Link.
• GitHub Wiki Link.
• Nuget Package Link.

 if (window.jQuery) {  
   (function ($) {  
     if (typeof (entityFormClientValidate) != 'undefined') {  
       var originalValidationFunction = entityFormClientValidate;  
       if (originalValidationFunction && typeof (originalValidationFunction) == "function") {  
         entityFormClientValidate = function ()   
          {  
           //DO VALIDATION HERE. RETURN TRUE IF PASSED AND FALSE IF FAIL  
         };  
       }  
     }  
   }(window.jQuery));  
 }  

 if (window.jQuery) {  
   (function ($) {  
     if (typeof (webFormClientValidate) != 'undefined') {  
       var originalValidationFunction = webFormClientValidate;  
       if (originalValidationFunction && typeof (originalValidationFunction) == "function") {  
         webFormClientValidate = function ()  
         {  
          //DO VALIDATION HERE. RETURN TRUE IF PASSED AND FALSE IF FAIL   
         };  
       }  
     }  
   }(window.jQuery));  
 }  

 $('.notifications').append($("<div class='notification alert alert-danger' role='alert'>PUT ERROR MESSAGE TEXT HERE</div>"));  

1. In you team, choose the channel you want to add the tab too.
2. Click the "+" in the channel you have chosen and you will get a pop-up
3. Click on "Website"
4. There will be a pop-up asking to input the tab name and URL.  At this point you need to decide if you are going to have the website launch to the default landing page for  Dynamics 365 or to a specific record in  Dynamics 365.
5. Leave the "Post to the channel about this tab" checked.  This will create a thread in the "Conversations" tab.  This way any communication around the  Dynamics 365 record can be kept in one place.
6. Click "Save".

1. I performed all my look ups first to get the associated account and contact from CRM.
2. I created the opportunity with the closed status of won or lost (see links below for website to get the standard values for reference).
3. This makes the opportunity as read only (which I expected to have happen.  But, the actual close date was set for the day the record was created.  Even though I provided a date in the actual close date field.

• SSIS has been around for a long time and SQL developers are familiar with it.
• Has starter packs that can be used to speed up development of mappings.
• Easy integration with source control since development is done in Visual Studio.

• Since its built on SSIS you need to know the disadvantages of SSIS as well.
• Can be intimidating is the user is not a developer, since you have to develop within Visual Studio or SQL Server Management Studio (SSMS).
• Limited connections

• User interface is easy to understand and clean.
• Runs in the cloud and uses a small tool (agent) to access on-premise data.  If all systems are in the cloud already then a cloud agent can be used so there is no need for an on-premise system.
• Multiple connectors.  Makes it easy to connect to other systems and migrate the data into CRM.
• API - They provide an API so you can access your instance programmatically.
• Fast Connector Framework (FCF) \ Connector Development Kit (CDK) - If a connector doesn't exist you can use the FCF or CDK to create one.
• Provide starter kits to speed up you data mapping. 
• They offer a Dynamics 365 app, so you can monitor status from within CRM.

•  Sometimes there are caching issues and you have to clear browser cache to fix them.
• To get mappings into source control it is a manual process, since you have to export them and copy them into a local folder.

• Built within Dynamics 365.
• Mappings saved in CRM for later use.
• Great for small non-complex mappings.
• Can be used with the CRM SDK / Developer Guide.

•  There is a limit to the file size you can use for importing data.  This means you will need to split up your data into multiple files, which can increase the possibility of data duplication.
• If there is relationships to other entities in your mapping, it can be difficult to set all these and have them work consistently.
• Tool is vary inconsistent when importing data.

• Allows for user created functions without having to change code.
• Provides all the SCRIBE functions on the Stream Deck.
• Provides buttons to launch SCRIBE Online, SCRIBE Forums, and SCRIBE Help.
• Provides buttons for cut, copy, paste.

• Back - Ends the program and launches the stock Stream Deck Application. (Only on home screen. Other screens it will take you back one level.)
• Open XML - Opens the XML that contains the SCRIBE and user defined functions.
• Cut - Same as CTRL+X.
• Copy - Same as CTRL+C.
• Paste - Same as CTRL+V.
• SCRIBE Online - Launches the SCRIBE Online web application.
• SCRIBE Forums - Launches the SCRIBE Forums web site.
• SCRIBE Help - Launches the SCRIBE Help web site.
• Conversion - Folder containing the conversion functions.
• Date - Folder containing the date functions.
• Logical - Folder containing logical functions.
• Math - Folder containing math functions.
• Text - Folder containing text functions.
• Miscellaneous - Folder containing miscellaneous functions.
• User Defined - Folder containing user created functions.

1. In SCRIBE Online open the formula editor and click where you want to insert the function.
2. Navigate to the function you want on the Stream Deck. 
3. Press the function button and release it. Upon releasing, the function will be placed at the cursor location in the formula editor.

1. JavaScript runs OnLoad of contact form.  This works because of how IFrames are loaded in v8.  You can also run it on either a tab change (hide / show) or OnReadyStateComplete event of the IFrame.  Depending on your setup you will need to choose which is best for you.  For me in this case it was the OnLoad event.
2. Here is the JavaScript:

 function OnLoad()  
 {  
      //Get memberid  
      var value = Xrm.Page.data.entity.attributes.get("new_memberid").getValue();  
      //Get the default URL for the IFRAME, which includes the   
      // query string parameters  
      var IFrame = Xrm.Page.ui.controls.get("IFRAME_NAMEofIFRAME");  
      var Url = IFrame.getSrc();  
      //Append the parameters to the new page URL  
      newTarget = Url + "history?member=" + value;  
      // Use the setSrc method so that the IFRAME uses the  
      // new page with the existing parameters  
      IFrame.setSrc(newTarget);  
 }  

1. JavaScript runs on OnReadyStateComplete event of the IFrame.  I had to add extra code to prevent constant refresh of the IFrame.  This is because on this event every time we update the URL if causes the OnReadyStateComplete event to fire.  To prevent this we have to use an If/Else so we only update the URL if it hasn't been updated yet.
2. Here is the JavaScript:

 function OnReadyStateComplete(executionContext)  
 {  
      var formContext = executionContext.getFormContext();  
      var value = formContext.getAttribute("new_memberid").getValue();  
      //Get the default URL for the IFRAME, which includes the   
      // query string parameters  
      var IFrame = formContext.ui.controls.get("IFRAME_NAMEofIFRAME");  
      var Url = IFrame.getSrc();  
      var newTarget = "";  
      //Append the parameters to the new page URL  
      if(Url.includes(value))  
      {  
           newTarget = Url;  
      }  
      else  
      {  
           newTarget = Url + "history?member=" + value;  
           // Use the setSrc method so that the IFRAME uses the  
           // new page with the existing parameters  
           IFrame.setSrc(newTarget);  
      }  
 }  

• IF(ISNULLOREMPTY(),,)
• IF(AND(),,)
• IF(OR(),,)
• CONCATENATE()
• FORMAT("yyyy-MM-dd",)

• LOOKUPTABLEVALUE1() - Looks in column 2 for the value we pass it and returns the value in column 1 in the same row.
• LOOKUPTABLEVALUE1_DEFAULT() -Looks in column 2 for the value we pass it and returns the value in column 1 in the same row. If nothing is found in the table it returns the default value we pass it.
• LOOKUPTABLEVALUE2() - Looks in column 1 for the value we pass it and returns the value in column 2 in the same row.
• LOOKUPTABLEVALUE2_DEFAULT() - If nothing is found in the table it returns the default value we pass it. If nothing is found in the table it returns the default value we pass it.

     /// <summary>  
     /// Method to get local option set label  
     /// </summary>  
     /// <param name="entityLogicalName">Schema name of entity</param>  
     /// <param name="optionSetName">schema name of the optionset</param>  
     /// <param name="value">value of the option set option</param>  
     /// <param name="service">CRM Organizational Service</param>  
     /// <returns>String Label of the optionset value provided</returns>  
     public string GetLocalOptionSetLabel(string entityLogicalName, string optionSetName, int value, IOrganizationService service)  
     {  
       XrmServiceContext crmContext = new XrmServiceContext(service);  
       RetrieveEntityRequest retrieveDetails = new RetrieveEntityRequest  
       {  
         EntityFilters = EntityFilters.All,  
         LogicalName = entityLogicalName  
       };  
       RetrieveEntityResponse retrieveEntityResponseObj = (RetrieveEntityResponse)service.Execute(retrieveDetails);  
       EntityMetadata metadata = retrieveEntityResponseObj.EntityMetadata;  
       PicklistAttributeMetadata picklistMetadata = metadata.Attributes.FirstOrDefault(attribute => string.Equals(attribute.LogicalName, optionSetName, StringComparison.OrdinalIgnoreCase)) as PicklistAttributeMetadata;  
       OptionSetMetadata options = picklistMetadata.OptionSet;  
       IList<OptionMetadata> OptionsList = (from o in options.Options  
                          where o.Value.Value == value  
                          select o).ToList();  
       string optionsetLabel = (OptionsList.First()).Label.UserLocalizedLabel.Label;  
       return optionsetLabel;  
     } 

     /// <summary>  
     /// Method to get local option set value  
     /// </summary>  
     /// <param name="entityLogicalName">Schema Name of entity</param>  
     /// <param name="optionSetName">Schema Name of option set.</param>  
     /// <param name="label">text label</param>  
     /// <param name="service">CRM Org Service</param>  
     /// <returns>Int option set value</returns>  
     public int GetLocalOptionSetValue(string entityLogicalName, string optionSetName, string label, IOrganizationService service)  
     {  
       XrmServiceContext crmContext = new XrmServiceContext(service);  
       RetrieveEntityRequest retrieveDetails = new RetrieveEntityRequest  
       {  
         EntityFilters = EntityFilters.All,  
         LogicalName = entityLogicalName  
       };  
       RetrieveEntityResponse retrieveEntityResponseObj = (RetrieveEntityResponse)service.Execute(retrieveDetails);  
       EntityMetadata metadata = retrieveEntityResponseObj.EntityMetadata;  
       PicklistAttributeMetadata picklistMetadata = metadata.Attributes.FirstOrDefault(attribute => string.Equals(attribute.LogicalName, optionSetName, StringComparison.OrdinalIgnoreCase)) as PicklistAttributeMetadata;  
       OptionSetMetadata options = picklistMetadata.OptionSet;  
       IList<OptionMetadata> OptionsList = (from o in options.Options  
                          where o.Label.UserLocalizedLabel.Label == label  
                          select o).ToList();  
       int optionsetValue = (OptionsList.First()).Value.Value;  
       return optionsetValue;  
     }  

         /// <summary>  
     /// Method to get global option set label  
     /// </summary>  
     /// <param name="optionSetName">Schema name of option set</param>  
     /// <param name="value">Int value of option set value</param>  
     /// <param name="service">CRM Org service</param>  
     /// <returns>String option set label</returns>  
     public string GetGlobalOptionSetLabel(string optionSetName, int value, IOrganizationService service)  
     {  
       XrmServiceContext crmContext = new XrmServiceContext(service);  
       string optionSetLabel = "";  
       RetrieveOptionSetRequest retrieveOptionSetRequest = new RetrieveOptionSetRequest { Name = optionSetName };  
       RetrieveOptionSetResponse retrieveOptionSetResponse = (RetrieveOptionSetResponse)crmContext.Execute(retrieveOptionSetRequest);  
       OptionSetMetadata retrievedOptionSetMetadata = (OptionSetMetadata)retrieveOptionSetResponse.OptionSetMetadata;  
       OptionMetadata[] optionArray = retrievedOptionSetMetadata.Options.ToArray();  
       foreach (var option in optionArray)  
       {  
         if(option.Value.Value == value)  
         {  
           optionSetLabel = option.Label.LocalizedLabels[0].Label;  
         }  
       }  
       return optionSetLabel;  
     }  

     /// <summary>  
     /// Method to get the option set value for a global optionset  
     /// </summary>  
     /// <param name="optionSetName">Schema name of the optionset</param>  
     /// <param name="label">text label</param>  
     /// <param name="service">CRM Org Service</param>  
     /// <returns>Int option set value</returns>  
     public int GetGlobalOptionSetValue(string optionSetName, string label, IOrganizationService service)  
     {  
       XrmServiceContext crmContext = new XrmServiceContext(service);  
       int optionSetValue = 0;  
       RetrieveOptionSetRequest retrieveOptionSetRequest = new RetrieveOptionSetRequest { Name = optionSetName };  
       RetrieveOptionSetResponse retrieveOptionSetResponse = (RetrieveOptionSetResponse)crmContext.Execute(retrieveOptionSetRequest);  
       OptionSetMetadata retrievedOptionSetMetadata = (OptionSetMetadata)retrieveOptionSetResponse.OptionSetMetadata;  
       OptionMetadata[] optionArray = retrievedOptionSetMetadata.Options.ToArray();  
       foreach (var option in optionArray)  
       {  
         if (option.Label.LocalizedLabels[0].Label == label)  
         {  
           optionSetValue = option.Value.Value;  
         }  
       }  
       return optionSetValue;  
     }  

1. Crystal vs Classic UI - A Comparison.  This is a comparison of the classic UI to the Crystal UI.  I recommend this if you are familiar with the classic UI, but haven't worked in the Crystal UI yet.  If you are completely new to SCRIBE Online, you can skip this video.
2. Introduction to Scribe Online.  As the title states this is an intro to SCRIBE Online platform and is good for people just getting into SCRIBE.
3. Scribe Online Agent and its Setup.  This video goes over the agents, what they do and how to install them.
4. Scribe Online Replication Service (RS).  Video that reviews Scribe's replication service.  Includes building solutions for creating and scheduling replications.
5. Scribe Online Integration Service (IS). Video that reviews Scribe's integration service.  Includes building solutions and mappings for integrations.
6. Scribe Online Event Maps.  Video that reviews Event driven mappings.  Also goes over how to set these mappings up.

• Agents
• API
• Connectors
• Event Solutions
• User Interface
• Sandbox

• Org Details - This contains info about your org.
• Solution Details - Details about the solution.
• All tabs after the first 2 are the individual mappings in the solution.
• The top section of each mapping tab will contain the high level map info.
• After that section we start with the beginning of the mapping.  each block is highlighted, so it is easy to navigate between them.  under each block is the information contained in that block and the attributes used with what they are linked to or the conversion code we have written.

• CRM 4.0
• CRM 2011
• CRM 2013
• CRM 2015
• Dynamics 365 Version 8

1. Create a user in the Office 365 admin center.  Be sure to assign a Dynamics 365 (online) license to the account.
2. Go to Dynamics 365 (online).
3. Go to Settings > Security.
4. Choose Users > Enabled Users, and then click a user’s full name.
5. In the user form, scroll down under Administration to the Client Access License (CAL) Information section and select Non-interactive for Access Mode.  You then need to remove the Dynamics 365 (online) license from the account.
6. Go to the Office 365 admin center.
7. Click Users > Active Users.
8. Choose the non-interactive user account and under Product licenses, click Edit.
9. Turn off the Dynamics 365 (online) license, and then click Save > Close multiple times.
10. Go back to Dynamics 365 (online) and confirm that the non-interactive user account Access Mode is still set for Non-interactive.
11. In CRM assign a role to the user account.

1:  new PropertyDefinition  
2:  {
3:        Description = "Use TOLIST() to pass in a list of entity id's.",  
4:        FullName = "Entity IDs",  
5:        IsPrimaryKey = false,  
6:        MaxOccurs = 1,  
7:        MinOccurs = 0,  
8:        Name = "PublishTo",  
9:        Nullable = true,  
10:       NumericPrecision = 0,  
11:       NumericScale = 0,  
12:       PresentationType = "string",  
13:       PropertyType = typeof(string).Name,  
14:       UsedInActionInput = true,  
15:       UsedInActionOutput = true,  
16:       UsedInLookupCondition = true,  
17:       UsedInQueryConstraint = true,  
18:       UsedInQuerySelect = true,  
19:       UsedInQuerySequence = true  
20   }  

 TOLIST("ABC123, DEF456, GHI789", ",", "string", "a", true, true)  

 "EntityIDs":   
 [  
   "ABC123",  
   "DEF456",  
   "GIH789"  
 ]  

1:  net stop "Scribe Online Agent"  
2:  Exit /b 0  

1:  copy /Y "$(TargetDir)$(ProjectName).dll" "C:\Program Files (x86)\Scribe Software\AGENTNAME\Connectors\CONNECTORNAME\$(ProjectName).dll"  
2:  net start "Scribe Online Agent"  

1:  $(document).on('change', '#CHECKBOX ID', function () { SetSessionValue("#CHECKBOX ID") });  
2:  $(document).on('change keyup paste', '#TEXTBOX ID', function () { SetSessionValue("#TEXTBOX ID) });  

1:  function SetSessionValue(fieldname) {  
2:    if ($(fieldname).hasClass('boolean-radio')) {  
3:      if ($(fieldname + "_1").is(':checked')) {  
4:        sessionStorage.setItem(fieldname, true);  
5:      }  
6:      else {  
7:        sessionStorage.setItem(fieldname, false);  
8:      }  
9:    }  
10:    else {  
11:      var fieldValue = null;  
12:      if ($(fieldname).hasClass('picklist')) {  
13:        fieldValue = $(fieldname).find(":selected").val();  
14:      }  
15:      else {  
16:        fieldValue = $(fieldname).val();  
17:      }  
18:      sessionStorage.setItem(fieldname, fieldValue);  
19:    }  
20:  }  

1:  function GetSessionValue(fieldname) {  
2:    var sessionValue = sessionStorage.getItem(fieldname);  
3:    return sessionValue;  
4:  }  

1:      $(document).ready(function ()  
2:      {  
3:        var dpcontrol = $('div.control')[2];  
4:        $(dpcontrol).on("dp.change", function (e)   
5:        {  
6:           alert("On change Event Triggered");  
7:           alert(e.date);  
8:        });  
9:      });