Introduction

This concept provides information about the order submission (micro) service which is used to transfer order information from ICM to Microsoft Dynamics 365. It shows the general data flow as well as gives an overview about the application architecture.

References

• Cookbook - D365 Finance and Operations Order Submission Connector
  
• Jersey
• Guice

Order Submission Workflow

The following diagram shows how the different systems involved with the order submission process interact with each other:

Microservice Architecture

General Structure

The microservice is a RESTful Java web service using Jersey for implementing service resources and client requests. The following diagram shows the basic architecture:

The OrderSubmissionApplication registers itself at the cluster's Eureka instance so that it can be easily found by the ICM. When a request arrives, it is routed via Jersey to the REST resource in OrderSubmissionServiceImpl. The service triggers the order submission process asynchronously via executing an Executable (chain).

To achieve minimum coupling between different classes, Guice is used as a dependency injection tool which allows easy replacement of existing implementations in custom projects.

Executables and Chains

The order submission process is implemented by several Executable implementations. An Executable is a class that is executed in a given context and that returns a result containing information about the processing status:

/**
 * An executable is an entity that processes the data from a given {@link ExecutionContext} and returns an
 * {@link ExecutionResult}.
 * 
 * @param <T>
 *            the type of context this executable can process
 */
public interface Executable<T extends ExecutionContext>
{
    /**
     * Triggers the execution with the given context.
     * 
     * @param context
     *            the context containing the information to process
     * @return a result stating if the execution was successful or not
     */
    ExecutionResult execute(T context);
}

There is currently one Executable for every request that is to be sent from the Microservice to Dynamics 365. The default execution context for the order submission process is OrderSubmissionExecutionContext which primarily holds the order to be submitted.

Multiple Executables can be chained together via special implementations:

• AutoRevertibleExecutableChainImpl allows processing Executables in order and will, upon an error, automatically revert all Executables prior to the one throwing the error in reverse order. Note that an Executable can only be reverted if it implements the RevertibleExecutable interface.

• ContinuingExecutableChainImpl allows processing Executables in order and will ignore execution errors. It will continue with subsequent Executables instead.

Executables and chains are registered via Guice. There are currently two modules containing all bindings:

• OrderSubmissionInnerChainModule contains an AutoRevertibleExecutableChainImpl with all Executables that interact directly with the Dynamics 365 system. If an error occurs here, already submitted data will be reverted automatically.

  OrderSubmissionInnerChainModule

  public class OrderSubmissionInnerChainModule extends PrivateModule
  {
      @Override
      protected void configure()
      {
          MapBinder<Integer, Executable<OrderSubmissionExecutionContext>> executables = MapBinder
                          .newMapBinder(binder(), new TypeLiteral<Integer>() {},
                                          new TypeLiteral<Executable<OrderSubmissionExecutionContext>>() {});
          executables.addBinding(10).to(Key.get(new TypeLiteral<Executable<OrderSubmissionExecutionContext>>() {}, 
                          Names.named("DeleteExistingSalesOrdersExecutable")));
          executables.addBinding(20).to(Key.get(new TypeLiteral<Executable<OrderSubmissionExecutionContext>>() {}, 
                          Names.named("CreateSalesOrderHeaderExecutable")));
          executables.addBinding(30).to(Key.get(new TypeLiteral<Executable<OrderSubmissionExecutionContext>>() {}, 
                          Names.named("CreateSalesOrderLinesExecutable")));
  
          bind(new TypeLiteral<Executable<OrderSubmissionExecutionContext>>() {})
                          .annotatedWith(Names.named("AutoRevertibleExecutableChain"))
                          .to(new TypeLiteral<AutoRevertibleExecutableChainImpl<OrderSubmissionExecutionContext>>() {});
          expose(new TypeLiteral<Executable<OrderSubmissionExecutionContext>>() {})
                          .annotatedWith(Names.named("AutoRevertibleExecutableChain"));
      }
  }

• OrderSubmissionOuterChainModule contains a ContinuingExecutableChainImpl with the chain from the module above as well as an Executable that will report the success status back to the ICM.

  OrderSubmissionOuterChainModule

  public class OrderSubmissionOuterChainModule extends PrivateModule
  {
      @Override
      protected void configure()
      {
          MapBinder<Integer, Executable<OrderSubmissionExecutionContext>> executables = MapBinder
                          .newMapBinder(binder(), new TypeLiteral<Integer>() {},
                                          new TypeLiteral<Executable<OrderSubmissionExecutionContext>>() {});
          executables.addBinding(10).to(Key.get(new TypeLiteral<Executable<OrderSubmissionExecutionContext>>() {}, 
                          Names.named("AutoRevertibleExecutableChain")));
          executables.addBinding(20).to(Key.get(new TypeLiteral<Executable<OrderSubmissionExecutionContext>>() {}, 
                          Names.named("SendAcknowledgeExecutable")));
  
          bind(new TypeLiteral<Executable<OrderSubmissionExecutionContext>>() {})
                          .to(new TypeLiteral<ContinuingExecutableChainImpl<OrderSubmissionExecutionContext>>() {});
          expose(new TypeLiteral<Executable<OrderSubmissionExecutionContext>>() {});
      }
  }

The following diagram shows the default chain structure: