Sitecore Commerce ERP integration, an approach – Part 1 – Integrating orders and customers

Pingback: Sitecore Commerce ERP integration, an approach – Part 2 – Modifying the business tools views – Dynamics AX + Sitecore = Commerce

2018-09-04T14:29:27+00:00

This is a great article. Thanks for sharing! I have a related question and was hoping you could lead me in the correct direction:
Is there a way to simply update the released orders to pending individually based in the internal status in the order entity (as set via the API)? It seems that simply setting the status in on the order via the API is not sufficient to move the order to the corresponding list (e.g. setting a pending order to released does not move the order to the released list.)

Running the Pending orders minion via the API as you suggest above seems to move all orders regardless of the internally recorded status, which is problematic if you are required to micro manage orders via the API.

In any case, any advice you can offer would be appreciated!

LikeLike

Reply

2018-09-04T21:01:55+00:00

Hey man, yeah, just changing the status won’t move the order to the correct list. You need to execute the correct code in order to achieve that. For example, you need to execute the RemoveListEntitiesPipeline to remove entities and the AddListEntitiesPipeline pipeline to add them (Commerce core assembly reference). The best thing to do is reflect the orders plugin and look at the minion code there. All the minions basically loop through a list then move the entity somewhere else so all the code you need will be in there.

LikeLike

Reply

	namespace Sitecore.Commerce.Connectors.MYERP.Plugin.Policies
	{
	using Sitecore.Commerce.Core;

	/// <summary>
	/// The policy.
	/// </summary>
	public class ErpPolicy : Policy
	{
	/// <summary>
	/// Initializes a new instance of the <see cref="ErpPolicy"/> class.
	/// </summary>
	public ErpPolicy()
	{
	this.AosUrl = string.Empty;
	this.ActiveDirectoryTenant = string.Empty;
	this.ApplicationId = string.Empty;
	this.ApplicationKey = string.Empty;
	this.RetailServerUrl = string.Empty;
	}

	/// <summary>
	/// Gets or sets the application object server url.
	/// </summary>
	public string AosUrl { get; set; }

	/// <summary>
	/// Gets or sets the retail server url.
	/// </summary>
	public string RetailServerUrl { get; set; }

	/// <summary>
	/// Gets or sets the application id.
	/// </summary>
	public string ApplicationId { get; set; }

	/// <summary>
	/// Gets or sets the application key.
	/// </summary>
	public string ApplicationKey { get; set; }

	/// <summary>
	/// Gets or sets the active directory tenant.
	/// </summary>
	public string ActiveDirectoryTenant { get; set; }
	}
	}

	{
	"$type": "Sitecore.Commerce.Connectors.MYERP.Plugin.Policies.ErpPolicy, Sitecore.Commerce.Connectors.MYERP.Plugin",
	"ActiveDirectoryTenant": "https://login.windows.net/MYAD-0b55-4c91-81c1-c0377a0d2cac",
	"AosUrl": "https://MYAOS.cloudax.dynamics.com",
	"ApplicationId": "MYAPPID-4722-4641-86da-d96b5c5281c3",
	"ApplicationKey": "MYKEY8j9nSQNJEeuVjAvZ8AojyQIotaZlMILeo=",
	"RetailServerUrl": "https://MYRETAILSERVER.cloudax.dynamics.com"
	}

	SELECT TOP 5 [Id]
	,[EnvironmentId]
	,[Version]
	,[Entity]
	FROM [SitecoreCommerce_Global].[dbo].[CommerceEntities]
	where entity like '%MYERP%'

	namespace Sitecore.Commerce.Connectors.MYERP.Plugin.Components
	{
	using System;

	using Sitecore.Commerce.Core;

	/// <summary>
	/// The customer status component base.
	/// </summary>
	public abstract class ErpStatusComponentBase : Component
	{
	/// <summary>
	/// Gets or sets a value indicating whether integrated.
	/// </summary>
	public bool Integrated { get; set; }

	/// <summary>
	/// Gets or sets the status message.
	/// </summary>
	public string StatusMessage { get; set; }

	/// <summary>
	/// Gets or sets the application url.
	/// </summary>
	public string ErpUrl { get; set; }

	/// <summary>
	/// Gets or sets the date sent.
	/// </summary>
	public DateTime StatusDate { get; set; }
	}
	}

	namespace Sitecore.Commerce.Connectors.MYERP.Plugin.Components
	{
	/// <summary>
	/// The order status component.
	/// </summary>
	public class ErpOrderStatusComponent : ErpStatusComponentBase
	{
	/// <summary>
	/// Gets or sets the destination order number.
	/// </summary>
	public string ErpOrderNumber { get; set; }
	}
	}

Dynamics + Sitecore = Commerce

Technical content for Dynamics 365 , Sitecore and eCommerce

Sitecore Commerce ERP integration, an approach – Part 1 – Integrating orders and customers

Introduction

What is a minion and in particular, what is the “Released orders minion” and how do we customize it?

How do we get an order to the “Released” state?

So, how do we run these minions?

On a schedule

Manually

Modifying the Sitecore Commerce engine to send orders to an ERP

Open the SDK example solution and create a new plugin project

Creating a new component to store the integration status of the order and the customer

Add the new component classes

Creating an integration helper class that contains the reusable logic to create the order and the customer in the ERP

Add the integration helper class

Creating a new pipeline block to send the order to the ERP and update the status

Adding a new pipeline block

Register the new pipeline block to execute during the “Released order Minion pipeline”

Running and debugging the example

Verify your solution, should look like this…

Environment setup

Verify that your new plugin is loaded

Create a test order and run the modified minion pipeline

Conclusion

3 thoughts on “Sitecore Commerce ERP integration, an approach – Part 1 – Integrating orders and customers”

Leave a Reply to SM Cancel reply

	namespace Sitecore.Commerce.Connectors.MYERP.Plugin.Components
	{
	/// <summary>
	/// The customer status component.
	/// </summary>
	public class ErpCustomerStatusComponent : ErpStatusComponentBase
	{
	/// <summary>
	/// Gets or sets the destination order number.
	/// </summary>
	public string ErpCustomerNo { get; set; }
	}
	}

	namespace Sitecore.Commerce.Connectors.MYERP.Plugin.Erp
	{
	using System;
	using System.Threading.Tasks;

	using Sitecore.Commerce.Connectors.MYERP.Plugin.Components;
	using Sitecore.Commerce.Connectors.MYERP.Plugin.Policies;
	using Sitecore.Commerce.Core;
	using Sitecore.Commerce.Plugin.Customers;
	using Sitecore.Commerce.Plugin.Orders;

	/// <summary>
	/// The integration helper.
	/// </summary>
	public class IntegrationHelper
	{
	/// <summary>
	/// The persistEntityPipeline.
	/// </summary>
	private readonly IPersistEntityPipeline persistEntityPipeline;

	/// <summary>
	/// The get customer pipeline.
	/// </summary>
	private readonly IFindEntityPipeline findEntityPipeline;

	private readonly IServiceProvider serviceProvider;

	private readonly IGetCustomerPipeline getCustomerPipeline;

	/// <summary>
	/// Initializes a new instance of the <see cref="IntegrationHelper"/> class.
	/// </summary>
	/// <param name="persistEntityPipeline">
	/// The persist entity pipeline.
	/// </param>
	/// <param name="findEntityPipeline1">
	/// The get customer pipeline 1.
	/// </param>
	/// <param name="serviceProvider"></param>
	/// <param name="getCustomerPipeline"></param>
	public IntegrationHelper(IPersistEntityPipeline persistEntityPipeline, IFindEntityPipeline findEntityPipeline1, IServiceProvider serviceProvider, IGetCustomerPipeline getCustomerPipeline)
	{
	this.persistEntityPipeline = persistEntityPipeline;
	this.findEntityPipeline = findEntityPipeline1;
	this.serviceProvider = serviceProvider;
	this.getCustomerPipeline = getCustomerPipeline;
	}

	/// <summary>
	/// The translate order and send.
	/// </summary>
	/// <param name="order">
	/// The order.
	/// </param>
	/// <param name="context">
	/// The context.
	/// </param>
	/// <returns>
	/// The <see cref="Task"/>.
	/// </returns>
	public async Task<Order> TranslateOrderAndSendToErp(Order order, CommercePipelineExecutionContext context)
	{
	try
	{
	var customer = await this.UpdateCreateCustomer(order, context);

	var persistOrderArgument = await this.UpdateCreateOrder(order, context, customer);

	return persistOrderArgument.Entity as Order;
	}
	catch (Exception e)
	{
	throw e;
	}
	}

	private async Task<PersistEntityArgument> UpdateCreateOrder(
	Order order,
	CommercePipelineExecutionContext context,
	Customer customer)
	{
	// Get the policy for the ERP connection
	var erpPolicy = context.GetPolicy<ErpPolicy>();

	// Create order >>
	var orderId = order.OrderConfirmationId;

	//!!!!!REPLACE THIS WITH YOUR CALL TO THE ERP use erpPolicy to get connection details!!!!
	var orderIntegrated = true;

	order.GetComponent<ErpOrderStatusComponent>().StatusDate = DateTime.Now;
	order.GetComponent<ErpOrderStatusComponent>().Integrated = orderIntegrated;

	// Update the order status on success
	if (orderIntegrated)
	{
	order.Status = "Completed – Sent to ERP";
	order.GetComponent<ErpOrderStatusComponent>().ErpUrl = erpPolicy.AosUrl;
	order.GetComponent<ErpOrderStatusComponent>().StatusMessage = "Success";
	if (customer == null)
	{
	order.GetComponent<ErpOrderStatusComponent>().StatusMessage =
	order.GetComponent<ErpOrderStatusComponent>().StatusMessage + " – anonymous customer";
	}
	//!!!!!REPLACE THIS WITH YOUR ERPs ORDER NUMBER!!!!!!
	order.GetComponent<ErpOrderStatusComponent>().ErpOrderNumber = "Ord-" + order.OrderConfirmationId;
	}
	else
	{
	order.Status = "Problem – Not sent to ERP";
	order.GetComponent<ErpOrderStatusComponent>().ErpUrl = erpPolicy.AosUrl;
	order.GetComponent<ErpOrderStatusComponent>().StatusMessage = "There was an error while sending the data to ERP";
	}

	// Update the order
	var persistOrderArgument = await this.persistEntityPipeline.Run(new PersistEntityArgument(order), context);
	return persistOrderArgument;
	}

	private async Task<Customer> UpdateCreateCustomer(Order order, CommercePipelineExecutionContext context)
	{
	// Get the policy for the D365 connection
	var erpPolicy = context.GetPolicy<ErpPolicy>();

	// *** Create customer >>
	var contactComponent = order.GetComponent<ContactComponent>();

	var getCustomerCommand = new GetCustomerCommand(this.getCustomerPipeline, this.serviceProvider);
	var customerId = $"{CommerceEntity.IdPrefix<Customer>()}{contactComponent.CustomerId}";
	var customer = await getCustomerCommand.Process(context.CommerceContext, customerId);

	// The order will be created against a default "Anonymous customer" if its not found
	if (customer != null)
	{
	//!!!!REPLACE THIS WITH YOU CALL TO YOUR ERP, use the erpPolicy variable to retreive the connection details!!!!!
	var customerIntegrated = true;

	customer.GetComponent<ErpCustomerStatusComponent>().StatusDate = DateTime.Now;
	customer.GetComponent<ErpCustomerStatusComponent>().Integrated = customerIntegrated;

	// Update the order status on success
	if (customerIntegrated)
	{
	customer.GetComponent<ErpCustomerStatusComponent>().ErpUrl = erpPolicy.AosUrl;
	customer.GetComponent<ErpCustomerStatusComponent>().StatusMessage = "Success";
	//!!!!REPLACE THIS WITH THE CUSTOMER ID OF YOUR ERP!!!!!!!
	customer.GetComponent<ErpCustomerStatusComponent>().ErpCustomerNo = "Cust-" + contactComponent.CustomerId;
	}
	else
	{
	customer.GetComponent<ErpCustomerStatusComponent>().ErpUrl = erpPolicy.AosUrl;
	customer.GetComponent<ErpCustomerStatusComponent>().StatusMessage =
	"There was an error while sending the data to ERP";
	}

	// Update the customer
	var persistCustomerResult = await this.persistEntityPipeline.Run(new PersistEntityArgument(customer), context);
	}

	// *** Create customer <<
	return customer;
	}
	}
	}

	namespace Sitecore.Commerce.Connectors.MYERP.Plugin
	{
	using System.Reflection;
	using Microsoft.Extensions.DependencyInjection;

	using Sitecore.Commerce.Connectors.MYERP.Plugin.Pipelines.Blocks;
	using Sitecore.Commerce.Core;
	using Sitecore.Commerce.Plugin.Orders;
	using Sitecore.Framework.Configuration;
	using Sitecore.Framework.Pipelines.Definitions.Extensions;

	/// <summary>
	/// The configure site core.
	/// </summary>
	public class ConfigureSitecore : IConfigureSitecore
	{
	/// <summary>
	/// The configure services.
	/// </summary>
	/// <param name="services">
	/// The services.
	/// </param>
	public void ConfigureServices(IServiceCollection services)
	{
	var assembly = Assembly.GetExecutingAssembly();
	services.RegisterAllPipelineBlocks(assembly);

	services.Sitecore()
	.Pipelines(
	pipeLineConfig =>
	pipeLineConfig.ConfigurePipeline<IReleasedOrdersMinionPipeline>(
	config => config.Add<SendOrderToErpMinionBlock>()
	.After<MoveReleasedOrderBlock>()));

	services.RegisterAllCommands(assembly);
	}
	}
	}