💳 Automating Invoice Payment in Dataverse with Azure Durable Functions

 

In enterprise solutions, payment workflows often involve complex steps, third-party interactions, and the need for robust orchestration. In a recent article, Temmy Raharjo illustrates how Azure Durable Functions can streamline a Dataverse-integrated payment process, using a well-structured invoice payment scenario.

🎯 Problem Statement

When dealing with external systems (like payment gateways), we often rely on plugins or Power Automate flows within Dynamics 365 or Dataverse. However, these come with limitations:

  • Plugin timeouts (maximum 2 minutes)

  • Complex retry and exception handling

  • Limited orchestration capabilities

✅ The Solution: Azure Durable Functions

Durable Functions are an extension of Azure Functions that enable stateful orchestrations. Temmy breaks down how this model can be used to coordinate a multistep invoice payment process triggered from Dataverse.

👇 Key Steps Involved:

  1. User clicks "Send Payment" in Dynamics (Dataverse model-driven app)

  2. Custom API is triggered to send a message to Azure Service Bus Queue

  3. A listener picks up the message and triggers the Durable Orchestration

  4. The orchestration performs:

    • Payment Initiation via HTTP call

    • Waits for external callback (WaitForExternalEvent)

    • Updates payment status in Dataverse

🧩 Technical Flow Summary:

  • Custom API (Dataverse) sends invoiceid and sessionid to Service Bus

  • Azure Function (Queue Trigger) listens for the Service Bus message

  • Orchestrator Function is invoked, which:

    • Calls an activity to initiate payment

    • Uses context.WaitForExternalEvent("PaymentCallback")

    • Proceeds after receiving a webhook callback with the session ID

    • Updates the payment status accordingly

🧠 Why Session ID Matters
The Session ID is a unique identifier passed through the process to correlate the initial orchestration with the external callback. It ensures the correct Durable Function instance is resumed when the external payment gateway calls back with the result.

📌 Key Benefits of This Approach:

  • Handles long-running external interactions safely

  • Eliminates plugin timeout issues

  • Enables better exception handling and retries

  • Decouples systems using messaging patterns (Service Bus)

📷 Visual Diagram

The solution includes a helpful flowchart showing the process from user action to final payment update (attached above ☝️).




🛡 Retry Mechanism with Durable Functions

Real-world integrations, especially with external systems like payment gateways or APIs, are prone to temporary failures—timeouts, transient network issues, or throttling. Azure Durable Functions make it easy to introduce robust retry logic without complicating your orchestration code.

🔁 How Retry Works in Durable Functions

Durable Functions allow you to wrap your Activity Functions with a built-in retry policy using the RetryOptions class. This means if an external API call or payment request fails, the orchestration can automatically retry the operation a specified number of times with a defined delay.

✅ Example: Retrying Payment Initiation

Let’s say you're calling an external payment API from an Activity Function:

csharp

var retryOptions = new RetryOptions(
    firstRetryInterval: TimeSpan.FromSeconds(10),
    maxNumberOfAttempts: 3)
{
    Handle = ex => ex is TimeoutException || ex is HttpRequestException
};

var result = await context.CallActivityWithRetryAsync<string>(
    "InitiatePaymentActivity", retryOptions, inputPayload);

  • firstRetryInterval – wait 10 seconds before the first retry

  • maxNumberOfAttempts – retry up to 3 times

  • Handle – conditionally retry only for specific exception types

This ensures resilience without writing complex retry loops or state-tracking code.

✅ Where to Apply Retry in Our Scenario

In both of the blogs discussed:

  1. Invoice Payment (Blog 1)

    • Use retry on: HTTP call to the external payment API

    • Benefit: Ensures the payment process isn't marked failed due to temporary connectivity issues

  2. Service Bus Integration (Blog 2)

    • Use retry on: Activity that updates Dataverse or calls external systems

    • Benefit: Reliable end-to-end message processing even if Dataverse API fails momentarily

⏱ Best Practices

  • Don’t retry on known business logic errors (e.g., payment declined)

  • Log all retry attempts for audit and diagnostics

  • Use exponential backoff for high-traffic systems

Comments

Post a Comment

Popular posts from this blog

🤖 Copilot vs Microsoft Copilot vs Copilot Studio: What’s the Difference?

Microsoft’s AI-powered tools are transforming the way we work, create, and collaborate. But with all the buzz around “Copilot,” “Microsoft Copilot,” and “Copilot Studio,” it’s easy to get confused. Let’s break down what each of these really means—and when to use them. 🚀 What Is “Copilot”? “ Copilot ” is Microsoft’s umbrella term for AI assistants built into its tools. Whether you’re in Word, Excel, or Teams, Copilot helps you do things faster —like generating text, summarizing information, analyzing data, or writing emails. Think of it like an intelligent assistant sitting next to you, helping with routine and creative tasks. 🔍 Example Copilots: Copilot in Word – Drafts documents, rewrites text, summarizes long reports. Copilot in Excel – Generates formulas, explains complex data, creates dashboards. Copilot in Teams – Summarizes meetings, drafts responses, manages tasks. 👉 It’s not a separate product—it’s a built-in experience across Microsoft tools. 🧠 What Is Micro...
Read more

Automating Unique Number Generation in Dynamics 365 Using Plugins

Introduction When working with Dynamics 365, generating unique and sequential numbers for records such as invoices, quotes, or orders is a common requirement. Instead of manually assigning these numbers, we can use an Auto-Numbering Plugin to automate the process. In this blog, we’ll break down a C# plugin that implements this functionality in an easy-to-understand way. Why Do We Need Auto-Numbering? Manual numbering is prone to errors, duplication, and inefficiency. Automating this ensures: Unique numbering for each record Improved data consistency A structured format (e.g., INV-1001, INV-1002 ) How Does the Plugin Work? The plugin follows a structured approach to generate and assign unique numbers: Retrieve the Auto-Number Configuration Record Lock the record to prevent conflicts Increment the current number and update it Assign the new number to the created entity Let’s break down the code into simple steps. Understanding the Code Complete C# Code for Auto-Numbering Plugin...
Read more

In-Process vs Isolated Process Azure Functions: What’s the Difference?

 When building Azure Functions using .NET, one of the most important architectural choices you’ll face is deciding between In-Process and Isolated Process (Out-of-Process) hosting models. This decision impacts everything from startup time to dependency control and middleware capabilities. So let’s break it down. What is In-Process (InProc) Hosting? In the In-Process model: Your function code runs inside the same process as the Azure Functions runtime. It uses the same AppDomain and host environment . Benefits: Better performance (lower cold start time). Full access to features in the Microsoft.Azure.WebJobs SDK (like bindings, triggers, and logging). Easier to use existing .NET libraries and tools. Limitations: Tightly coupled to the Azure Functions runtime version. Less flexibility in middleware and custom startup configuration. Potential for dependency conflicts if runtime and your code use different versions of libraries. What is ...
Read more