Blog

Technical debt is one of the most misunderstood risks facing businesses today. It quietly accumulates in the background — in the software systems, integrations, and processes that organizations depend on every single day. Left unaddressed, it does not stay quiet for long.

What Is Technical Debt, and Why Should Business Owners Care?

Technical debt is the accumulated cost of shortcuts, workarounds, and deferred maintenance in a technology system. It is the result of choosing the fast path over the right path — again and again — until the shortcuts become the system itself.

For business owners, the impact is felt long before the IT team raises the alarm. Development takes longer. Projects cost more than expected. Simple changes require weeks of testing. New tools get purchased to manage problems that are really symptoms of something deeper. The system becomes harder to explain, harder to maintain, and harder to trust.

Think of it like a house. A small crack in the foundation gets patched. Then another crack appears. Another patch. Over time, the walls have been patched so many times that nobody remembers where the original crack was — or how bad it actually was. The house looks fine from the outside. But underneath, the foundation is still crumbling.

The Band-Aid Trap

The most dangerous pattern in a technically indebted system is not the debt itself — it is the Band-Aid approach used to manage it. When a system breaks or behaves unexpectedly, the instinct is to fix the visible symptom as quickly as possible and move on. A workaround gets written. A new tool gets purchased. A manual process gets added to compensate for something the system should be doing automatically.

Each Band-Aid adds a new layer. Each new layer makes the original problem harder to find. Eventually, the organization has accumulated so many patches and workarounds that the underlying issue is buried entirely — and the team is spending the majority of its time maintaining the workarounds instead of delivering value.

One of the clearest signs that a business has reached this stage is tool sprawl. When teams are juggling multiple systems to track work, log time, manage tasks, or share information — and those systems do not communicate cleanly with each other — it is rarely a problem of choosing the wrong tools. It is a symptom of the chaos beneath. New tools are purchased to impose structure on a system that was never properly structured in the first place.

The result? A development process that is slower, more expensive, and more fragile than it needs to be.

The Real Cost of Kicking the Can

Every quarter that passes without addressing the foundation makes the remediation more expensive. This is not an opinion — it is the math of compounding complexity. A system that required 40 hours to properly fix two years ago may now require 200 hours because of everything that has been built on top of it.

Beyond the direct cost, there are significant business risks:

Velocity loss — Development teams that spend their time working around technical debt instead of delivering features fall further behind competitors who invested in a clean foundation.

Knowledge loss — As team members leave, the institutional knowledge of why each workaround exists leaves with them. What was a documented shortcut becomes an undocumented mystery.

Risk accumulation — Aging systems, undocumented integrations, and untested workarounds create compounding security and reliability risks that can surface at the worst possible time.

Morale and talent costs — Skilled developers do not want to spend their careers maintaining poorly structured systems. Turnover in environments with heavy technical debt tends to be high, adding recruitment and onboarding costs to an already expensive problem.

The Path Forward: Fixing the Foundation Without Stopping the Business

The most common objection to addressing technical debt is a practical one: "We can't stop everything to rewrite the system from scratch." In most cases, that is absolutely correct — and it is also not what a sound remediation strategy requires.

A phased, prioritized approach allows organizations to begin reducing debt while continuing to deliver. The key steps include:

1. Conduct an honest assessment. Before any work begins, the current state of the system needs to be documented clearly — including the workarounds, the undocumented dependencies, the tool sprawl, and the processes that exist to compensate for system gaps. This is often an uncomfortable exercise, but it is the only way to build a prioritized remediation plan.

2. Separate symptoms from causes. The tools, the manual processes, and the Band-Aids are symptoms. The underlying system issues are the causes. Remediation efforts that target only symptoms will generate new Band-Aids on a slightly different spot. The root causes must be identified and sequenced for resolution.

3. Prioritize by business impact. Not all technical debt carries equal risk. Remediation should be prioritized based on where the debt is creating the most drag on the business — whether that is slowing development, creating integration failures, or introducing compliance risk.

4. Build remediation into the development cycle. The "big bang rewrite" is rarely the answer. Instead, technical debt reduction should be treated as a standing investment — a defined percentage of each development cycle dedicated to improving the foundation, not just delivering new features.

5. Consolidate the toolset. Once the foundation begins to stabilize, the tools and systems used to manage work should be evaluated and consolidated. Tool sprawl that was introduced as a workaround often becomes unnecessary when the underlying system is functioning correctly.

Where Studer Consulting Group Fits In

At Studer Consulting Group, technical debt assessments and remediation planning are a core part of the work done with clients across Microsoft Dynamics 365, Power Platform, and HubSpot implementations. The pattern described above — Band-Aid accumulation, tool sprawl, a development process that has become more expensive and unpredictable over time — is not unique. It is encountered regularly, and there is a clear, structured path out of it.

The organizations that fare best are the ones that stop treating technical debt as a future problem and start treating it as a present cost. Because it is already costing them — in developer hours, in delayed projects, in tools that were purchased to manage problems that should have been fixed.

If any of this sounds familiar, it may be time to have a direct conversation about what the foundation actually looks like — and what it will take to fix it before the next crack appears.

UPDATE: This is only an issue in the "Old Designer". If you moved to the "New Designer" the actions still appear. I would recommend moving over to the new designer, since Microsoft is depreciating the old designer.

A recent change to the Microsoft Dataverse connector in Power Automate has left many flows broken or incomplete. The familiar Get a row by ID and List rows actions appear to have been removed from the connector's action picker in multiple environments — and the issue is reproducible across different browsers and machines, ruling out a caching problem. In their place, a new Search rows (preview) action has been introduced. This post documents the behavior and a working workaround for restoring Get a row by ID functionality using the Power Automate Tools Chrome extension.

What Changed

When adding a new Dataverse action to a Power Automate flow, the expected actions — Get a row by ID, List rows, and others — are no longer available from the action picker. The connector now surfaces a new Search rows (preview) action instead. Existing flows that already contain Get a row by ID are unaffected — those steps continue to function and can still be configured and interacted with normally. The limitation is specifically that the action can no longer be added as a new step to any flow.

The replacement Search rows (preview) action maps to two distinct underlying operations depending on how it is configured:

• GetItem — retrieves a single record by its GUID (equivalent to the former Get a row by ID)
• GetRelevantRows — performs a relevance search across one or more tables (a true search operation)

The Power Automate designer currently only exposes the GetRelevantRows search behavior through the UI, making it impossible to replicate a simple row-by-ID lookup without a workaround.

The Workaround

Two workarounds are available for adding a Get a row by ID step to a flow:

Option 1: Copy an existing action

If the flow (or another flow in the same environment) already contains a Get a row by ID step, use Power Automate's built-in Copy to my clipboard action menu option to copy that step, then paste it into the target location. The pasted action retains the original operationId and can be reconfigured as needed. This is the fastest path when an existing step is available to copy from.

Option 2: Edit the flow JSON using Power Automate Tools

When no existing Get a row by ID action is available to copy, the Power Automate Tools Chrome extension provides direct access to the underlying JSON definition of a flow. By adding a Search rows (preview) action through the designer and then editing the JSON to swap the operation and parameters, a proper GetItem call can be constructed and saved successfully.

Follow these steps for the JSON approach:

1. Add a Search rows (preview) action to the flow in the Power Automate designer.
2. Configure a placeholder — set the Table name and a Search term variable. The exact values do not matter at this stage.
3. Open the Power Automate Tools extension in Chrome and navigate to the flow's JSON editor.
4. Locate the Search_rows_(preview) block in the JSON.
5. Modify the operationId and parameters as described below.
6. Save the changes via the extension. The flow will update and display the action as expected.

JSON: Before (Search rows — GetRelevantRows)

When added through the designer, the Search rows (preview) action produces a definition similar to this — note the GetRelevantRows operationId and the SearchRequest/search and SearchRequest/entities parameters:

"Search_rows_(preview)": {
  "runAfter": {},
  "metadata": {
    "operationMetadataId": "5e0d20a1-ef74-4cb3-8408-743350c36691"
  },
  "type": "OpenApiConnection",
  "inputs": {
    "host": {
      "apiId": "/providers/Microsoft.PowerApps/apis/shared_commondataserviceforapps",
      "connectionName": "shared_commondataserviceforapps",
      "operationId": "GetRelevantRows"
    },
    "parameters": {
      "SearchRequest/search": "@variables('RecipientUserID')",
      "SearchRequest/entities": [
        "systemusers"
      ]
    },
    "authentication": "@parameters('$authentication')"
  }
}

JSON: After (Modified to GetItem — Get a row by ID)

Replace the operationId with GetItem and swap the parameters block to use entityName (the logical table name) and recordId (the GUID of the record to retrieve). The metadata, type, host connection details, and authentication remain unchanged:

"Search_rows_(preview)": {
  "runAfter": {},
  "metadata": {
    "operationMetadataId": "fb50c17a-8fb3-4281-a7cc-d5366bcf7182"
  },
  "type": "OpenApiConnection",
  "inputs": {
    "host": {
      "apiId": "/providers/Microsoft.PowerApps/apis/shared_commondataserviceforapps",
      "connectionName": "shared_commondataserviceforapps",
      "operationId": "GetItem"
    },
    "parameters": {
      "entityName": "systemusers",
      "recordId": "@variables('RecipientUserID')"
    },
    "authentication": "@parameters('$authentication')"
  }
}

After saving, the step label in the designer will still read Search rows (preview), but the underlying operation will execute as a Get a row by ID call. Outputs from this action can be referenced downstream in the same way as the original action.

Key Differences at a Glance

Bug, Glitch, or Intentional Change?

At this point it is not clear whether this is a temporary glitch, an unintentional oversight during a connector update, or the beginning of a deliberate shift toward consolidating row retrieval under the Search rows action. The evidence cuts both ways. The fact that existing Get a row by ID steps remain fully functional and editable suggests this may not be an intentional deprecation — a planned removal would more likely affect all uses of the operation, not just the ability to add new ones. On the other hand, the simultaneous disappearance of multiple actions across unrelated environments points to a deliberate connector metadata change rather than a one-off rendering issue.

Until Microsoft publishes official guidance, the workarounds above provide a reliable path forward. Monitor the Power Automate blog and the Power Platform admin center for any communication regarding changes to the Dataverse connector.

Software development is, at its core, a discipline that demands sustained, uninterrupted concentration. Unlike many other professional roles, writing and reviewing code requires developers to hold large amounts of context in working memory simultaneously — the logic of a function, the state of a variable, the downstream effects of a change. When that concentration is broken, the cost is not simply the time lost to the interruption itself. It is the time required to reconstruct that mental context from scratch.

Research from the University of California, Irvine found that information workers spend an average of just 11 minutes in a focused working context before being interrupted or switching tasks — and that it takes an average of 25 minutes to return to the same task afterward. For software developers, where deep concentration is not optional but essential, those numbers carry serious implications for productivity, quality, and team morale.

The Hidden Cost of Fragmented Developer Time

The concept of "flow" — the state of deep focus in which a developer is fully immersed in a problem — is not a luxury. It is the condition under which complex software actually gets built. A developer debugging a race condition, designing a data model, or tracing an integration failure cannot do so effectively in three-minute increments. Yet research confirms that three minutes is, on average, how long a modern information worker goes before their attention is pulled elsewhere.

What makes this particularly damaging in software development is the cognitive complexity of the work itself. A developer interrupted mid-thought does not simply pause and resume. They lose their place in a multi-layered mental model that may have taken 20 or 30 minutes to construct. The bug they were tracing, the edge case they were reasoning through, the architecture decision they were evaluating — all of it must be rebuilt from scratch. This is not inefficiency. It is waste, compounding invisibly across every sprint, every release cycle, every quarter.

How Instant Messaging Has Made Things Worse

Tools like Slack and Microsoft Teams were designed to improve team communication. In practice, they have introduced a persistent, always-on interruption layer directly into the developer's working environment. The problem is not the tools themselves — it is the culture of immediacy that has grown up around them.

When a message arrives in a Slack channel or a Teams chat, the implicit expectation in most organizations is that it will be read and responded to quickly. Notifications appear. Status indicators signal availability. The social pressure to respond is constant. For a developer in the middle of a complex task, this is not a minor distraction — it is a forced context switch, carrying all of the cognitive recovery costs described above.

Research has shown that an interruption as brief as 2.8 seconds is sufficient to double the rate of errors in a task. Even a glance at a notification, even the mental acknowledgment of "I'll respond to that later," is enough to fracture concentration. Multiply that across dozens of messages per day in an active Slack workspace, and the cumulative impact on a development team becomes significant.

Email, by contrast, carries a fundamentally different set of expectations. An email is asynchronous by nature. It does not demand an immediate response. It does not produce a persistent notification badge that lingers in peripheral vision. It allows the recipient to respond thoughtfully, at a time of their choosing, without interrupting active work. For non-urgent communication — status updates, clarifying questions, design discussions — email remains a more respectful and ultimately more productive channel than an instant message that lands in the middle of a focused work session.

This does not mean instant messaging has no place in software development. Urgent, time-sensitive issues — a production outage, a blocker that is stopping deployment, a critical security finding — are exactly the kind of situations where real-time communication tools serve their intended purpose. The problem arises when every question, every comment, and every "quick thought" gets routed through the same channel, stripping the tool of the urgency signaling that makes it useful.

A healthier approach is to establish clear norms around communication channels: instant messages for genuinely urgent items, email or task comments for everything else, and an explicit expectation that developers working in focused blocks are not required to monitor chat in real time.

The Meeting Problem

If constant notifications represent the slow erosion of developer focus, meetings represent its blunt-force destruction. The damage is not limited to the meeting itself. A 30-minute meeting scheduled in the middle of the afternoon does not cost 30 minutes. It costs everything on either side of it, because developers cannot enter a deep working state when they know it will be interrupted in an hour.

Last-minute meetings compound this problem significantly. A developer who has organized their day around a block of focused work, only to receive a calendar invite 20 minutes before it starts, does not simply lose the meeting time. They lose the context they were building, the momentum they had established, and often the motivation to restart a complex task knowing it may be interrupted again.

The research is consistent on this point: interrupted workers compensate by working faster, but at the cost of significantly higher stress, frustration, and mental workload. In a field where mistakes carry real consequences — security vulnerabilities, data integrity issues, broken integrations — trading quality for speed under stress is not a trade worth making.

Meetings that aggregate status updates are particularly costly. A 45-minute standup or status review meeting that exists primarily to answer the question "where does this ticket stand?" is replacing information that could have been written down asynchronously in a fraction of the time, without interrupting anyone's concentration.

A Better Approach: Documentation Over Disruption

The most effective teams treat their work management tools — whether Azure DevOps, Jira, GitHub Issues, or any other platform — as the authoritative record of what is being built, why it was built that way, and what decisions were made along the way. When discussions about a feature, a bug, or an architectural decision happen in the comments of the relevant ticket or task, something valuable happens: the conversation becomes part of the permanent record of the work.

This matters more than it might initially appear. Six months after a feature ships, when a question arises about why a particular approach was chosen, the answer is in the ticket. When a new developer joins the team and needs to understand the history of a component, it is documented. When a regression surfaces and the team needs to understand what changed and why, the trail is there. None of that institutional knowledge exists in a Slack thread that scrolled off the screen three weeks ago.

Tracking status updates, design discussions, and decision rationale directly on tasks and tickets also reduces the need for synchronous status meetings. If the current state of every work item is visible in the project board, a standing status meeting becomes largely redundant. Time that was previously consumed by meetings can be returned to the developers as focused work time — which is, ultimately, the only time during which software actually gets built.

Fewer, more intentional meetings — scheduled in advance, with clear agendas, grouped at the edges of the day to protect large blocks of uninterrupted time — serve development teams far better than a calendar filled with ad hoc check-ins and last-minute additions. When meetings are necessary, making them shorter, better prepared, and outcome-focused respects the cost they impose on everyone in the room.

Protecting Developer Focus as a Business Decision

The culture of constant availability has become so normalized in many technology organizations that pushing back against it can feel counterintuitive. Responding quickly to messages feels productive. Attending every meeting feels collaborative. But the evidence consistently shows that the interruption-driven workday imposes a measurable cost on the quality and velocity of software development work.

Protecting developer focus is not about making developers less accessible or less collaborative. It is about recognizing that deep, sustained concentration is the raw material from which software is made — and that every unnecessary interruption depletes that material without producing anything in return. Organizations that take this seriously, and build communication norms that reflect it, tend to build better software, with less rework, and with teams that stay motivated over the long term.

The tools and processes are secondary. The commitment to protecting focused work time is the thing that matters.

When setting up a Proxmox VE environment it is common to end up with a node named pve, which is the default hostname assigned during installation. This becomes a problem when managing multiple Proxmox servers since every node will show up as pve in the web UI. This post covers the complete process for renaming a Proxmox node to a meaningful name including the FQDN, and how to handle the pmxcfs filesystem quirks that make this more involved than a standard Linux hostname change.

Understanding How Proxmox Uses the Hostname

Proxmox VE derives the node name directly from the short hostname (the part before the first dot). This means a server configured with the FQDN pve-node-1.example.lan will appear in the UI as pve-node-1. It is important to plan the naming convention carefully upfront. A naming scheme like pve-node-1, pve-node-2 works well because the short hostname is already fully unique, without relying on the domain portion to differentiate nodes.

Proxmox stores its configuration in a virtual FUSE filesystem called pmxcfs, which is backed by a SQLite database at /var/lib/pve-cluster/config.db. This filesystem has restrictions that prevent renaming non-empty folders, which is why a Proxmox node rename requires more than just editing /etc/hostname.

Step 1: Update /etc/hostname

Replace the contents of /etc/hostname with the new short hostname:

echo "pve-node-1" > /etc/hostname

Step 2: Update /etc/hosts

The /etc/hosts file must map the new FQDN and short hostname to the server's static IP address. The pmxcfs service will fail to start if it cannot resolve the node name to a non-loopback IP, so this step is critical.

127.0.0.1       localhost
192.168.1.x     pve-node-1.example.lan    pve-node-1

Step 3: Update Postfix

Edit /etc/postfix/main.cf and update the myhostname value to the new FQDN:

myhostname = pve-node-1.example.lan

Step 4: Rename the Node in the pmxcfs Database

This is where Proxmox node renames differ from a standard Linux hostname change. The node name is stored in the SQLite database that backs pmxcfs. The official Proxmox documentation notes that pmxcfs cannot rename non-empty folders, so standard file copy approaches will not work reliably. The cleanest solution is to rename the node directly in the database while the pve-cluster service is stopped.

One important note: pmxcfs reads the node name from /etc/hostname at startup and requires it to be resolvable in /etc/hosts. If the hostname has already been changed but the database still references the old name, pmxcfs will fail to start with the error:

Unable to resolve node name 'pve' to a non-loopback IP address

If this situation occurs, temporarily add the old hostname as an alias in /etc/hosts to get pve-cluster running, then proceed with the database update.

Stop the pve-cluster service:

systemctl stop pve-cluster

Rename the node in the database. The nodes directory in the tree table uses inode as the primary key. First confirm the schema and identify the correct row:

sqlite3 /var/lib/pve-cluster/config.db "SELECT inode, parent, name FROM tree WHERE name IN ('pve', 'nodes');"

Then update the node name directly:

sqlite3 /var/lib/pve-cluster/config.db "UPDATE tree SET name='pve-node-1' WHERE name='pve' AND parent=(SELECT inode FROM tree WHERE name='nodes');"

Verify the change looks correct:

sqlite3 /var/lib/pve-cluster/config.db "SELECT inode, parent, name FROM tree WHERE name IN ('pve', 'pve-node-1', 'nodes');"

The output should show only the new name with no remaining pve entry under nodes. Start pve-cluster back up:

systemctl start pve-cluster

Step 5: Copy RRD Statistics Data

Proxmox stores historical performance data for nodes and storage in RRD files under /var/lib/rrdcached/db/. These are keyed by node name, so they need to be copied to match the new name. If the old directories do not exist this step can be skipped.

cp -r /var/lib/rrdcached/db/pve2-node/pve /var/lib/rrdcached/db/pve2-node/pve-node-1
cp -r /var/lib/rrdcached/db/pve2-storage/pve /var/lib/rrdcached/db/pve2-storage/pve-node-1
rm -r /var/lib/rrdcached/db/pve2-node/pve
rm -r /var/lib/rrdcached/db/pve2-storage/pve

Step 6: Reboot and Verify

reboot

After the server comes back up, confirm the rename was successful:

hostname        # should return: pve-node-1
hostname -f     # should return: pve-node-1.example.lan
ls /etc/pve/nodes/    # should show only pve-node-1

The web UI should reflect the new node name with all VMs and containers listed correctly under the renamed node.

Things to Watch Out For

1) SSL certificates — The self-signed certificate generated by Proxmox is tied to the hostname. It will regenerate automatically on reboot, so expect a new browser warning to accept. If Let's Encrypt is configured through the Proxmox UI it will need to be re-issued after the rename.

2) pmxcfs caches its state in memory — Any direct edits to the SQLite database must be made while pve-cluster is stopped. If pve-cluster is running when edits are made, it will overwrite the database with its in-memory state on the next restart, undoing the changes.

3) The node name is always the short hostname — pmxcfs derives the node name from the hostname, not the FQDN. A server configured with FQDN pve-node-1.example.lan will show as pve-node-1 in the UI. Do not rely on the domain portion to differentiate nodes — ensure the short hostname itself is unique across all servers.

4) Do not attempt this on a clustered node — Renaming a node that is a member of a Proxmox cluster requires additional steps to update the corosync configuration and is outside the scope of this post.

 If you have worked with Power Pages using the Enhanced Data Model, you know the pain of manually adding all the site components to a Dataverse solution.  It's tedious, error-prone, and frankly, there are a lot of components to track down.  You need to add the site record, the site languages, and then every individual component — Web Pages, Web Templates, Content Snippets, Site Settings, Table Permissions, Basic Forms, Advanced Forms, and more.  Miss one and your deployment won't work as expected.

To solve this problem, we built an open source .NET console application called PowerPages.SolutionComponents.Console.  This tool automates the entire process of discovering and adding all Power Pages site components to a Dataverse solution in one shot.

What Does It Do?

The tool connects directly to your Dataverse environment and does the following:

1. Adds the Power Pages Site record to your solution.
2. Finds and adds all related Power Page Site Languages.
3. Finds and adds every Power Page Component associated with the site.  This covers all component types including:
   • Web Pages
   • Web Files
   • Web Templates
   • Content Snippets
   • Page Templates
   • Site Settings
   • Web Roles and Website Access records
   • Basic Forms and Basic Form Metadata
   • Advanced Forms, Steps, and Metadata
   • Table Permissions
   • Column Permission Profiles and Column Permissions
   • Web Link Sets and Web Links
   • Site Markers
   • Redirects
   • Shortcuts
   • Cloud Flows
   • Bot Consumers
   • UX Components and Server Logic
   • And more

Prerequisites

Before running the tool you will need the following:

1. .NET 8.0 SDK or later installed on your machine.
2. Access to your Power Platform environment with System Administrator or equivalent permissions.
3. The Unique Name of the solution you want to add the components to (the internal name, not the display name).
4. The GUID of your Power Pages site.  You can find this in the Power Pages Management app or via the Power Platform CLI.

How to Use It

Using the tool is straightforward.  Clone the repository, build it, and run it.

1. Clone the repository from GitHub.
2. Build the project:

   dotnet build
   

3. Run the application:

   dotnet run --project PowerPages.SolutionComponents.Console
   

4. Follow the interactive prompts.  The tool will ask you for:
   • Environment URL — Your Dataverse environment URL (e.g., https://yourorg.crm.dynamics.com).
   • Solution Unique Name — The internal unique name of your solution.
   • Power Pages Site GUID — The GUID of the site whose components you want to add.
   • Exclude Site Settings — Whether to skip certain site settings based on prefixes (more on this below).

When you first run the tool, the Microsoft.PowerPlatform.Dataverse.Client library will open a browser window for interactive authentication.  Once authenticated, the tool does the rest automatically.

The Exclude Site Settings Feature

A particularly useful feature is the ability to exclude specific site settings from being added to the solution.  This is particularly helpful when you are deploying across environments that have different identity providers.  For example, you probably don't want the Authentication/* settings from a development environment getting pushed into production and overwriting the production identity provider configuration.

By default, the tool excludes any site setting with the Authentication/ prefix when you opt in to the exclusion option.  You can customize this list by editing the ExcludedSiteSettingPrefixes list in PowerPages.SolutionComponents.Console\Constants\ExcludedSettings.cs before building.

One Thing to Be Aware Of

The tool automatically adds the related Dataverse tables to the solution as part of the process.  If your deployment strategy only requires the Power Pages Site, Components, and Languages to be in the solution — and not the full table definitions — you will need to manually remove the table definitions from the solution after the tool finishes running.  This is a known consideration and is called out in the README on the GitHub project.

Get the Code

The project is 100% open source.  You can find the full source code, clone the repository, or contribute at the link below.

https://github.com/JamesStuder/PowerPages.SolutionComponents.Console

If the tool proves useful or any issues are encountered, feel free to open an issue or submit a pull request on GitHub.

If your marketing team lives in HubSpot and your sales team lives in Microsoft Dynamics 365, getting those two platforms to reliably share data is one of the most important integration decisions you'll make. There are two main paths to connect them: a native connector available directly in the HubSpot App Marketplace, or a custom-built integration using Azure Functions. Choosing the wrong one can mean months of frustration. This post walks through both options in detail so you can make the right call for your team.

The Microsoft Dynamics 365 integration is a first-party app built and maintained by HubSpot, available in the HubSpot App Marketplace and Microsoft AppSource. It's powered by HubSpot's Data Sync engine — part of Data Hub (formerly Operations Hub) — and supports bidirectional sync across 12 object types:

• Contacts ↔ Leads / Contacts
• Companies ↔ Accounts
• Deals ↔ Opportunities
• Products ↔ Bundles
• Meetings ↔ Appointments
• Tasks ↔ Tasks
• Notes ↔ Notes
• Invoices ↔ Invoices
• Orders ↔ Sales Orders
• Emails ↔ Emails
• Calls ↔ Phone Calls
• Custom Objects ↔ Custom Entities

Sync runs near real-time — updates typically appear within a few minutes. Setup takes less than an hour: a Super Admin navigates to the HubSpot Marketplace, searches for "Microsoft Dynamics 365," connects using the Dynamics subdomain, and then configures each object sync under Settings > Integrations > Connected Apps. You can connect up to two Dynamics 365 instances per HubSpot account.

Pricing: The base integration is free on all HubSpot plans. Custom field mappings require a paid Data Hub subscription. Automating sales order creation from deal-based workflows requires Sales Hub Professional or Enterprise. The connector only supports cloud-hosted Dynamics 365 — on-premises instances are not supported.

Where the native connector falls short: Dropdown, radio select, multi-select, and checkbox field types cannot sync bidirectionally — they only flow one-way into text fields. Lookup and reference fields in Dynamics 365 do not sync natively. Sync direction is set at the object level, not the field level, so you cannot protect individual sensitive fields without workflow workarounds. Since the integration is a closed system, its logic cannot be modified or extended.

When the native connector hits a wall — complex business logic, custom entities, true real-time sync, or multi-system orchestration — Azure Functions provides a serverless middleware layer between the two platforms. You write the transformation logic; Azure handles the scaling and infrastructure.

Three architectural patterns:

1. Webhook / HTTP Trigger — HubSpot fires webhook notifications to an Azure Function endpoint when CRM events occur (contact created, deal stage updated). The function validates the request using HubSpot's X-HubSpot-Signature-v3 HMAC SHA-256 header, transforms the data, and writes to Dynamics 365 via the Dataverse Web API. Important: HubSpot requires webhook endpoints to respond within 5 seconds. Best practice is to receive the webhook, enqueue the payload to Azure Service Bus, return a 2xx immediately, then process asynchronously via a queue-triggered function.
2. Timer / Scheduled Trigger — CRON-based polling queries both systems for changes using delta queries. HubSpot's hs_lastmodifieddate property and Dataverse's $filter=modifiedon gt {datetime} enable efficient incremental sync. Works well for bulk reconciliation and non-time-critical data.
3. Event-Based with Azure Service Bus — Layers Azure Service Bus as a durable message broker, providing dead-letter queues, retry policies, and at-least-once delivery guarantees. The right pattern for mission-critical integrations.

API foundations and rate limits: HubSpot's CRM API v3 supports full CRUD and batch operations (up to 100 records per request). Rate limits range from 100 requests per 10 seconds on Free/Starter plans to 190 on Professional/Enterprise, with daily caps of 250,000 to 1,000,000 calls. Dynamics 365 uses the Dataverse Web API, an OData v4.0 REST interface. Authentication requires OAuth 2.0 via Microsoft Entra ID using the client credentials flow. Use Azure Managed Identities to eliminate client secrets entirely.

For hosting, use the Flex Consumption or Premium plan over the standard Consumption plan. Cold starts on the Consumption plan can cause HubSpot webhook timeouts. The Premium plan eliminates cold starts and adds VNet connectivity for private Dynamics 365 endpoints.

Data Mapping: Inventory all fields in both systems before mapping anything, noting data types, required fields, and character limits. HubSpot treats all people as Contacts with lifecycle stages; Dynamics 365 distinguishes between Leads and Contacts — this conceptual mismatch requires explicit decisions. Define a single source of truth per field to avoid conflict loops. Date formats, currency scaling, and email address case sensitivity all need normalization rules documented before go-live.

Deduplication: Clean both databases independently before integration begins. HubSpot automatically deduplicates contacts by email and companies by domain. Dynamics 365 supports up to five published duplicate detection rules per entity. For cross-system references, store Dynamics 365 GUIDs as custom HubSpot properties and HubSpot record IDs in Dynamics — this creates reliable cross-reference keys that survive field changes.

Security: HubSpot deprecated API keys in November 2022 — use OAuth 2.0 only. Store all secrets in Azure Key Vault accessed via managed identity. Rotate credentials every 60 days minimum using dual-credential rotation for zero-downtime refreshes. Always validate HubSpot webhook signatures. Apply the principle of least privilege: request only necessary HubSpot API scopes and assign minimal Dataverse security roles to application users.

Monitoring: For the native connector, HubSpot's built-in sync status cards (visible on each record) and the CRM Syncs tab in Connected Apps provide basic visibility. For custom integrations, connect Azure Application Insights for distributed tracing. Track custom metrics: records synced, duplicates detected, sync errors per object type. Schedule quarterly integration health checks to catch silent data drift before it becomes a data quality crisis.

Use Case 1 — The 50-Person Marketing Team (Native Connector): A mid-market B2B software company uses HubSpot for marketing automation and Dynamics 365 for sales pipeline management. Marketing qualifies leads in HubSpot; sales owns deals in Dynamics. They need MQLs to appear in Dynamics as Leads, and won deals closed back in HubSpot. No custom fields beyond standard contacts and companies. The native connector handles this in under an hour at zero cost. This is the right starting point — validate your sync behavior with real data before assuming you need more.

Use Case 2 — The B2B Manufacturer with Complex Routing (Custom Azure Functions): A 600-person industrial manufacturer needs intent-based lead qualification scores from HubSpot to conditionally route opportunities to specialized regional sales teams in Dynamics 365. Product interest (multi-select) must map to Dynamics opportunity categories. Campaign source must populate a custom lookup field. Deal stage transitions need to trigger order creation in their ERP. The native connector fails on every one of these requirements. A webhook-driven Azure Functions architecture with Service Bus queuing is the right call — it is a significant investment, but the alternative is a broken integration that sales will ignore.

Use Case 3 — The Middle Path (Power Automate / iPaaS): A 500-person professional services firm needs a handful of custom field transformations and a lookup field sync that the native connector cannot handle, but does not have the development budget for a full Azure Functions build. The right answer here is neither option: a low-code Power Automate flow extending the native connector, or an iPaaS platform like Skyvia or Rapidi with pre-built HubSpot–Dynamics templates. This middle path resolves roughly 80% of cases where native falls short, at a fraction of custom development cost.

Choose the Native Connector if:

• You only need standard objects: contacts, companies, deals, tasks, notes
• Field types are text, number, or date — not dropdown or multi-select
• No developers available or in budget
• You need to be live in days, not weeks
• Your Dynamics instance is cloud-hosted on dynamics.com
• Sync within a few minutes is acceptable
• You want HubSpot to own maintenance and updates

Choose Custom Azure Functions if:

• You need dropdown, multi-select, or lookup field sync
• Conditional routing or custom business logic is required
• You are running Dynamics 365 on-premises
• Compliance requires full audit trails and data residency control
• You need sub-minute, true real-time sync
• The integration involves more than just HubSpot and Dynamics
• You have engineering resources and a 6–12 week timeline

The native connector and custom Azure Functions are not competing solutions — they sit on a spectrum of integration maturity. Most organizations should start with the native connector to validate their sync requirements with real data, then graduate to custom builds only when they hit concrete limitations.

The often-overlooked middle ground — Power Automate flows extending the native connector, or iPaaS platforms like Skyvia and Rapidi — can resolve the majority of cases where native falls short, at a fraction of custom development cost.

Whatever path you choose, invest in your data mapping decisions, deduplication strategy, and monitoring setup before worrying about the technology. The biggest integration failures are not technical — they are the result of two teams that never agreed on which system owns a given field.

 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:      });