Recently Updated

• Use Bulk Threshold Controls to manage Out of Stock and At Risk Statuses for Inventory and Virtual Positions
• Create Control Groups for Inventory and/or Virtual Catalogs to respectively apply Bulk Threshold Controls
• Configure Bulk Threshold Controls with:
  • Context
  • Threshold
  • Status
  • and Execution Order

Delta Inventory updates are incremental inventory updates used to create relative updates against Inventory positions. These are used to notify the OMS of offline stock movements that have occurred during the day.

The Fluent OMS module is pre-configured with certain standard functions that allow the interface to manage orders, product availability, inventory, and order fulfilment and serve as a starting point for your projects.

The default UX templates are hosted on the platform, so there is no need to create the manifest settings yourself unless you need to customize the existing baseline configuration.

• This component simplifies the addition of networks to locations by providing an easy to use selector of available networks
• The basic principles can be used in other scenarios where complex fields and values may be required

A Job represents a container that can hold multiple batches. A job stays open until midnight (UTC), where the status will change to CLOSED. All jobs are processed concurrently.

• Overview of each endpoint for Job API
• Also provides the common errors and resolutions

• This guide shows you how to seamlessly switch Store Locations within the Fluent Store web app
• This guide is aimed at In-Store users

Modules are the package structure used by Fluent Commerce to ship preconfigured features and functions. They are designed to be self-describing, isolated, but inter-dependent assets that can work together with other modules, or be extended by custom modules, all while remaining upgradeable.

Here we'll look at the different designations of Modules and describe the Module's Package Structure and Project Structure.

• Preprocessing Disabled (Skip Enabled): If preprocessing is disabled (set to skip), all event items are passed as is, regardless of changes.
• Preprocessing Enabled: If preprocessing is enabled, only changed items are passed through as events.
• Event Structure: The batch input includes optional fields, and default values are set if they are not provided.
• Event Name: If you specify a custom event name in the batch input, it will be used in the resulting event. If not, the default event name is

  `"InventoryChanged"`

  .

Rules or controls that determine what inventory is available in a Virtual Catalog

Controls can be used to:

• Exclude SKUs or product categories from a virtual catalog
• Manage buffer or safety stock by SKU, Category and/or Location

• Explanation of Control and Control Groups
• Control Types
• Execution Order field in Control

• It is possible to use the generic SAML configuration to add an external identity provider that follows the SAML standard. 
• Steps to configure an external identity provider via SAML configuration

• Adding the application to PingOne
• Registering application with Microsoft
• Getting the client ID and client secret for the application
• Setting up API permissions
• Adding the identity provider in PingOne
• Adding the Redirect URI to the Microsoft portal
• Do not forget

• The Unified View of Inventory (UVOI) is a powerful feature available out of the box. It offers comprehensive insights and real-time updates across inventory locations and sales channels.
• To configure its full functionality, you need to create several settings that define default filter values and ensure filters are populated with appropriate statuses from workflows.
• This guide will walk you through the configuration steps using examples from a reference solution. Note that the statuses and catalog names of these examples may differ from your specific implementation requirements.

This page covers the various Fluent CLI commands which can be used to configure / install Fulfilment Options module

• Inventory Batch Pre-Processing (BPP) occurs before batch inventory updates reach the workflow engine. If you rely on every incoming inventory item hitting the workflow, ensure you configure the job-level meta value appropriately or disable BPP at the relevant account/retailer level. However, we recommend using the job-level option for greater flexibility. Be sure to read through this article in full—especially the “Managing Batch Pre-Processing” section—before making any changes.
• If enabled at an ACCOUNT level, every retailer under that ACCOUNT will have their batch inventory updates pre-processed
• If enabled at RETAILER levels, it will only pre-process updates for that specific retailer
• The RETAILER context setting overrides the ACCOUNT context setting. This allows you to enable the whole account and disable it for specific retailers. 

This document outlines the functionality of Inventory Batch Pre-Processing, offering insights into how unchanged records are filtered during the inventory ingestion process using Inventory Batches.

• Efficient Processing: Inventory Batch Pre-Processing handles batch inventory updates before they reach the inventory workflows, streamlining the process.
• Change Detection: Identifying inventory records that have changed, ensuring the workflow engine processes only necessary updates.
• Performance Improvement: Reduces workflow engine load by filtering unchanged records, enabling faster and more efficient inventory processing.
• Enhanced Flexibility: Supports additional fields in batch records, allowing for more precise control and management of inventory updates.

In the September 2023 release, we improved our Fulfilment Options response times by up to 50%. These improvements are disabled by default for accounts created before the release. This section will detail how to turn on this setting.

•  Enhance Fulfilment Option speed
• Customise setting for speed

This page describes how Inventory Batch Pre-Processing (BPP) works and what technical aspects need to be considered as part of an implementation.

• Optimize Inventory Updates: Batch Pre-Processing enhances system efficiency by processing only necessary changes, reducing unnecessary load on the workflow engine.
• Structured Batch Updates: Properly structuring your batch updates with the correct use of fields like

  `ref`

  ,

  `type`

  , and

  `status`

  is essential for accurate change detection and effective use of Batch Pre-Processing.
• Essential Knowledge: Even if you don't delve into all the details, remember that precise batch update structures are crucial. Pay special attention to how the

  `ref`

  field is constructed and the default behaviors when certain fields are not specified.
• New Fields and Defaults: Be aware of the new fields introduced by this feature and understand the default transient types and statuses. This knowledge will help you implement Batch Pre-Processing correctly and avoid potential pitfalls.

Direct Inventory Updates are one of the two reference ways to send last-on-hand inventory updates into your inventory workflows. Direct Inventory Updates are best used when you have a small volume of inventory updates (maximum of 1000 updates).

Inventory Batch Events offer insights into the processing status of Inventory Batches, helping to determine whether the corresponding records within a batch were successfully submitted for processing.

• Batch

  `CREATE`

  and

  `BATCH_COMPLETE`

  events provide insights into the processing status of Inventory Batches
• The events can be used to measure the duration of Inventory Batch processing
• Inventory Batch Events are currently not operational for inventory batches going through batch pre-processing

• Create your Master-Retailer Inventory Catalog
• Create your Sub-Retailer(s) Virtual Catalog(s)
• Configure your Inventory Catalog Workflow for Cross-Retailer events sending

This guide explains how to leverage the

`attributes`

`attributes`

`expectedOn`

`storageAreaRef`

`condition`

• Flexible Attribute Structure: The

  `attributes`

  object supports any combination of key-value pairs, including complex JSON structures and arrays. This flexibility allows you to customize the data sent in your inventory payloads to meet specific business needs.
• Recommended Attributes: Certain key attributes, such as

  `expectedOn`

  ,

  `storageAreaRef`

  , and

  `condition`

  , are automatically integrated into our platform’s workflows. These fields will be directly updated in the inventory quantity associated with the incoming record, facilitating seamless integration with existing fields.
• Custom Attribute Availability: Any custom attributes that you include in the

  `attributes`

  object will be available in workflows via

  `inventoryPosition.inventoryQuantity.attributes.<fieldname>`

  . This enables you to incorporate custom data into rule-based processes or other logic tailored to your business requirements.
• ISO 8601 Date Format: For any date-related attributes, it is recommended to use the ISO 8601 format (e.g.,

  `YYYY-MM-DDTHH:MM:SSZ`

  ) to ensure consistency and proper handling within the system.
• Integration with Workflows: The system is designed to handle both recommended and custom attributes, making them accessible within the workflow context. This ensures that you can leverage these attributes in custom rules and other logic, depending on the specific needs of your implementation.
• Extensibility: While the table of recommended attributes provides a useful starting point, you are encouraged to extend the

  `attributes`

  object with any additional fields relevant to your business processes. The flexibility of this structure allows for robust customization.

The Inventory Batch is designed to send large volumes of inventory data, primarily to update the Last On Hand inventory quantities for inventory positions. While its primary purpose is to handle large-scale inventory updates and ensure the OMS reflects the latest inventory levels after a few days of operations, it is flexible enough to support other inventory types as needed, providing adaptability for diverse inventory management scenarios.

• Create new Inventory Batches using the Job API 
• Sample Inventory batch payload 
• Inventory batch details

APIs use authorization to ensure that client requests access data securely. This can involve authenticating the sender of a request and verifying that they have permission to access or manipulate the relevant data. The below request will return a bearer token. This token can then be used in the header of subsequent API calls to confirm authentication.

• Overview
• Operations
• Models

Some common types and conventions are used across many component definitions. These items are not directly configurable in the manifest but will often be referenced in other component definitions that use them.

• The Mystique manifest configures icons, cards, and template strings. Icons come from React Icons. 
• Cards have common fields, and template strings allow dynamic values. Dynamic attributes (standard, image, component) offer flexibility based on conditions. 
• Additional options like TextOptions and ImageOptions provide styling choices.

The Fluent platform provides a comprehensive user role management system, allowing for the assignment of diverse permissions via roles to regulate platform access and functionalities. Custom roles can be created and fine-tuned, ensuring users only have access to appropriate functionality and data. The system provides flexibility to specify the scope for a role at different context levels, such as Accounts, Retailers, and Locations.

• A role can be assigned to multiple users, and a user can be assigned multiple roles.
• Permissions are granular access controls and protect every GraphQL or REST API operations. GraphQL permissions follow specific naming conventions.
• Context plays a pivotal role in access levels, allowing users to have role-based access to data for specific Accounts, Retailers, or Locations.

The Interface mapping document should clearly define what data will be exchanged between OMS and the external systems (e.g. middleware or eCom).

• The aim of the Interface Mapping document should keep it as simple as possible;

• A step-by-step guide to enable phone camera scanning for product picking.
• Configuration
• 
  

This section covers the basics of Fluent Account setup and walkthrough of the LaunchPadV1

• Access to Fluent Training Account
• Basic understanding of Postman Tool

This section covers the scope of the Setup and Configuration course and the required prerequisites 

• Access to Fluent training account
• Basic understanding of Postman tool

In this module, you will learn about Unit Testing and creating a Mocked Unit test for a custom Rule.  You will also learn how to perform testing on the TestExecutor and finally deploy your plugin into your sandbox environment

• Unit Testing
• PowerMock
• TestExecutor
• Testing on Sandbox

In this lesson, you will learn how to deploy and run a custom rule.

•  Access to Fluent Training account is required

This section covers the Exception handling, Debugging and Logging in a Custom Rule

• Custom Rule should be ready along with the Unit Test Cases
• Effect of Exceptions on Event processing
• IDE Debugging
• Log Action

In this scenario we will implement a Fraud Check step in the Order Workflow

• Prerequisites setup
• Basics of Rule writing

Workflow Framework Rules are written using Java and contain a specific structure and metadata for describing and validating the Rule. In this lesson, you will learn how to write Rules by adding customised business logic. 

In this module, you will learn about a Plugin Project structure and JS GraphQL within the Plugin Project.  You will also learn how to modify and run a JS GraphQL query.

• Installed SDK
• GQL Basics

In this lesson, you will learn about Rules SDK, the Software Development Kit for Fluent Order Management, and the key features of the SDK.

• Prerequisites software installation

The software required to install and run Rules SDK, also known as the Fluent SDK.

• JDK8.
• Maven 3.6.
• IntelliJ IDE
• GraphQL Plugin
• Postman

This module provides an introduction to the Fluent OMX UX Framework (Mystique) and its role in building user interfaces for the Fluent Platform. We'll explore the core concepts behind the framework, how it functions, and the basic structure of a Fluent Web App. This foundational knowledge will prepare you for more advanced topics in later modules.

• UX Framework Purpose: Understand the role of the UX Framework in building UIs for the Fluent Platform.
• Framework Functionality: Learn how the UX Framework enables UIs to respond to workflow changes.
• Web App Structure: Grasp the basic structure of a Fluent Web App.

This series of lessons guides you through building a feature to manage storage areas within the Fluent Store web app. We'll cover creating a new Manifest fragment, adding it to account settings, and referencing it in the main Manifest. We'll then add a List component to display storage areas, configure a data source for the list using a page query, and create a details page for individual storage areas. Finally, we'll explore working with dynamic values, including date formatting, array access, image rendering, and configuring i18n language translation.

• Manifest Fragment Creation: Learn to create and configure a new Manifest fragment for managing storage areas.
• Account Settings Integration: Integrate the new fragment into account settings and reference it in the main Manifest.
• List Component Integration: Use the List Component to display storage area data.
• Data Source Configuration: Use the

  `activeLocation`

  context to configure a page query as a data source for the List Component.
• Details Page Creation: Create a details page for individual storage areas with a dedicated page query.
• Dynamic Value Handling: Learn to work with dynamic values using formatters (e.g.,

  `dateStringFormatter`

  ), array access, attribute retrieval by name, and image rendering.
• i18n Configuration: Configure i18n language translation keys for the web app.

This lesson details the structure of Manifest documents, covering both main web application manifests and fragment manifests. We'll explore the required fields and optional configurations for the main manifest, including context, routes (section, page, and reference), and plugin integration. We'll also examine the simpler structure of fragment manifests and how they contribute to managing complex UI configurations.

• Manifest Types: There are two types of Manifests: main and fragment.
• Main Manifest Structure: Required fields include manifestVersion, name, title, context, and routes. Optional fields include homePath.
• Context Configuration: Defines whether the app operates at a LOCATION or RETAILER level and allows role-based access control.
• Routes (Section, Page, Reference): Routes define the navigation menu. Section routes group menu items, Page routes link to specific pages, and Reference routes include fragment manifests.
• Fragment Manifests: Fragment manifests contain only manifestVersion and routes, allowing for modular management of large Manifest configurations.
• Plugin Integration: The Manifest can include references to custom component plugins hosted externally.

This lesson introduces the Manifest document, a crucial component in defining the structure and layout of Fluent Web Apps. We'll cover how to set up your development environment with a pre-configured VS Code workspace, understand the key elements of a Manifest document, and learn how to create a new web app by defining an account-level setting. We'll also explore the different types of routes used in Manifests and walk through creating a simple page route. This setup and introduction will prepare you for more advanced Manifest configurations in later lessons.

• VS Code Setup: Use the provided VS Code workspace for Manifest editing.
• Manifest Definition: The Manifest defines a Fluent Web App's structure, layout, navigation, and data.
• Account Setting: Manifests are stored as account-level settings.
• Web App Access: Web apps are accessed via URLs based on the Manifest's appName.
• Key Elements (Name, Title, Context, Routes): Manifests define these core elements.
• Route Types: Page, Section, and Reference routes define navigation within the app.

This lesson introduces the OMX Component Library, a collection of pre-built, configurable UI components designed for use in Fluent Web Apps. Unlike standard UI components, these components are specifically built to interact natively with the Fluent Platform. We'll explore the various categories of components within the library, including Foundation, Content, Layout, Interaction, and Field Components, and understand their distinct roles in building user interfaces.

• Fluent Platform Integration: OMX Components seamlessly integrate with the Fluent Platform.
• Component Categories: The library includes Foundation, Content, Layout, Interaction, and Field Components, each with distinct roles.
• Component Hierarchy: Content and Layout components are typically children of Foundation Components.
• Mobile Responsiveness: Components should be designed with mobile responsiveness in mind.
• Interaction Components: These enable user interaction with the application.
• Field Components: Automatically rendered form elements, essential for complex workflow input, are not configured via the manifest.

This lesson covers the process of unit testing custom components using the tools provided within the Component SDK: Jest and React's test renderer. We'll walk through the steps of creating mock objects for dependencies (authentication, data, attributes), arranging the test environment, acting by rendering the component with the mocks, and asserting the output using snapshot testing. This process ensures the reliability and correctness of your custom components.

• Testing Framework: The SDK includes Jest and React's test renderer for unit testing.
• Mock Objects: Mock objects are created for external dependencies like authentication (

  `useAuth`

  ), data from the page query, and dynamic attributes from the manifest.
• Arrange, Act, Assert: The testing process follows the standard Arrange, Act, Assert pattern.
  • Arrange: Mocks are set up and configured.
  • Act: The component is rendered with the mock data.
  • Assert: The rendered output is compared against a snapshot.
• Snapshot Testing: Jest's snapshot feature is used to compare the component's output to a previously saved snapshot, ensuring consistency.
• Testable Components: Unit tests help ensure the reliability and maintainability of custom components.

This lesson focuses on fetching data within a custom form field using the

`useQuery`

`useQuery`

`useAuth`

• Data Independence: Components should fetch their own data using the

  `useQuery`

  hook, rather than relying on potentially unavailable page query data.
• GraphQL Query: A GraphQL query (

  `searchVirtualInventory`

  ) is used to retrieve nearby locations with stock.
• Data Structures: Interfaces (SVINode, SVIResult) are defined to structure the query results.

• `useQuery`

  Hook: The

  `useQuery`

  hook is used to execute the GraphQL query with dynamic parameters.
• Dynamic Parameters: Query parameters (

  `productRef`

  ,

  `locationRef`

  ,

  `lat`

  ,

  `lng`

  ) are derived from the form's entity context (product) and the user's context (location) using the

  `useAuth`

  hook.
• Loading State: A loading state is implemented while the query progresses.
• Result Rendering: The query results are initially logged to the console and then rendered as a list of selectable locations using radio buttons.
• User Selection: A state variable and event handler are used to track the user's selected location.

This lesson details how to enhance custom form fields by adding structure, styling, and interactive controls. We'll focus on improving the user experience and data capture capabilities of our custom field component. This involves using Material-UI for styling, organizing the field's layout, and integrating pre-built form controls from the component library, such as the

`QuantitySelector`

`useEffect`

• Structure and Layout: Learn how to structure and organize the elements within your custom form field for optimal presentation.
• Styling with Material-UI: Use Material-UI's styling capabilities (e.g., makeStyles) to style your custom field and maintain design consistency.
• Form Control Integration: Integrate pre-built form controls, like the QuantitySelector, to efficiently capture specific data types (e.g., integers for quantity).
• Component Registry Retrieval: Learn how to retrieve and use existing components from the component registry (e.g., the QuantitySelector using its alias "number").
• State Management: Manage the state of form inputs using React's state mechanisms.
• Debugging with

  `useEffect`

  : Use the

  `useEffect`

  hook to debug and verify the behavior and output of your custom field.

This lesson focuses on adding interactivity to the map pins. Building on the previous styling enhancements, we'll use React's

`useState`

• React

  `useState`

  Hook: Learn how to use the

  `useState`

  hook to manage the interactive state of components, such as tracking pin clicks.
• Pin Click Actions: This lesson demonstrates how to implement actions that occur when a pin is clicked, enabling interactive map functionality.
• Interactive Components: This provides a practical example of making components interactive, a core concept in front-end development.

This lesson focuses on enhancing the visual representation of our map pins through styling. We'll explore how to add color to the map pins, improving their visual appeal and potentially conveying additional information. This styling process will demonstrate how to customize the look and feel of custom components.

• Pin Styling: Learn how to style map pins, including adding color, to improve their visual presentation.
• Visual Enhancement: Styling enhances the user experience by making the map more visually appealing and informative.
• Custom Component Styling: This lesson provides a practical example of styling custom components, a key aspect of UI development.

This lesson focuses on retrieving data for our map visualization. We'll explore how to access data from the page query defined in the manifest document, rather than making GraphQL queries directly within the component. This approach promotes reusability and configurability. We'll specifically target retrieving a list of locations that stock a given product, a crucial step in displaying product availability on the map.

• Data Fetching Strategy: Learn why accessing data from the page query is preferred over making direct GraphQL queries within the component.
• Manifest-Driven Data: Understand how to define and configure data queries in the manifest, making data accessible to components.
• Data Access: This lesson demonstrates how to retrieve the list of locations stocking the product from the page query data.
• Product Availability: The retrieved data will be used to populate the map with markers indicating store locations and product availability.

This lesson combines adding map pins with the concept of nested components. Building on the Google Map integration, we'll show how to dynamically add pins (child components) to the map (parent component). This is crucial for visualizing location data and illustrates building complex, modular UIs using nested components. You'll learn how to place markers representing locations and how this parent-child relationship contributes to organized, reusable UI elements.

• Nested Component Structure: This lesson emphasizes the use of nested components to create more organized and reusable UI elements.
• Parent-Child Relationship: We'll explore how parent components can manage and interact with their child components, such as adding pins (child) to a map (parent).
• Dynamic Pin Placement: This lesson focuses on adding pins to the map, enabling you to visually represent data points or locations.
• Data Visualization: Adding pins to the map allows for the visualization of location-based data, a key aspect of many applications, including the product availability map we are building.

This lesson demonstrates how to integrate a third-party component, specifically a Google Maps React component, into your custom map card. We'll cover the installation process using Yarn and discuss best practices for selecting third-party components for use in Fluent Web Apps. We'll also explore the option of using the map in development mode without an API key.

• Third-Party Component Integration: This lesson focuses on incorporating external libraries into your custom components, showcasing the use of a Google Maps React component for map display.
• Best Practices: When choosing third-party components, prioritize React-based libraries and those compatible with Material UI to ensure seamless integration with the Fluent framework.
• Installation with Yarn: We'll walk through the steps of installing the chosen map component using Yarn.
• Development Mode: The lesson also covers using the map component in development mode without providing a Google Maps API key, allowing for testing and development before deploying to production.

This lesson explores the

`useAuth`

• `useAuth`

  Hook Purpose: The useAuth hook provides a convenient way to access details about the authenticated user, including their roles, permissions, and current context.
• Contextual Information: The hook provides access to the user's current location or retailer context, which is vital for location-based applications.
• Location Coordinates: For location-context apps, useAuth allows retrieval of the selected store's coordinates (longitude and latitude), enabling map integration and location-based functionality.
• Fluent Store Application: In the context of Fluent Store, this hook will be used to get the coordinates of the currently viewed store, providing the data needed to display the store's location on the map.

This lesson focuses on configuring custom components using the Manifest file. We'll demonstrate how to define an interface for your component's properties, allowing it to receive data from the Manifest. Specifically, we'll show how to declare a

`MapCardProps`

`title`

`width`

• Component Properties Interface: Defining an interface (e.g.,

  `MapCardProps`

  ) allows you to specify the data a component can receive, ensuring type safety and clarity.
• Manifest Configuration: The Manifest file is used to configure the properties of custom components. This allows developers to control how components are displayed and function without modifying the component's code directly.
• Dynamic Control: By configuring properties in the Manifest, you can easily change a component's behavior or appearance without recompiling or redeploying the component. This provides flexibility and simplifies updates.

This lesson demonstrates the process of creating and registering a custom component using the Component SDK. We'll walk through the steps of building a simple React Function Component, leveraging a utility component (Card) provided by the SDK. We'll then register this custom component with the Component Registry, making it available for use within our web application. Finally, we'll show how to integrate the registered component into a page by updating the application's manifest.

• React Function Components (FCs): Fluent components are built as React Function Components, providing a familiar and efficient development model.
• Utility Components: The Component SDK provides utility components (like a

  `Card`

  ) that can be used as building blocks for custom components, simplifying development and ensuring consistency.
• Component Registry: Custom components must be registered with the Component Registry before being used in a web app. This makes them discoverable and configurable.
• Manifest Integration: Once registered, custom components are added to web app pages by referencing them in the application's manifest file, allowing developers to control the UI dynamically.

This lesson dives into the practical application of the Component SDK, focusing on how to build custom components for OMX Web Apps. We'll explore the different types of custom components you can create, the powerful hooks available for interacting with the Fluent platform, and the utility components that streamline development and ensure consistency. We'll also touch on the crucial concept of component registries.

• Types of Custom Components: The Component SDK enables the creation of custom view components (for page content) and custom field components (for workflow user actions), allowing developers to tailor interfaces to specific needs.
• Hooks for OMX Integration: Fluent-specific React hooks (e.g.,

  `useAuth`

  ,

  `useI18n`

  ,

  `useQuery`

  ) provide easy access to platform functionalities like authentication, localization, and API interaction, simplifying complex tasks.
• Utility Components for Consistency: The SDK offers utility components (e.g., Card, Loading, Drawers) that serve as building blocks for custom components, ensuring a consistent look and feel, theme responsiveness, and mobile compatibility.
• Component Registries: Custom components must be registered with the appropriate registry (Component, Field, or Template) before they can be used in OMX Web Apps, making them discoverable and usable within the framework.

This lesson introduces the Component SDK, a powerful toolkit for extending the UX Framework Component Library. We'll explore the core concepts behind the SDK, covering its purpose, capabilities, and benefits. By the end of this lesson, you'll understand how the Component SDK empowers developers to create custom, OMX-ready components for Fluent Web Apps, streamlining development and ensuring consistent user experiences.

• What is the Component SDK? A development kit for building custom components for the UX Framework Component Library using modern, developer-friendly tools like React and TypeScript.
• What can be extended? Developers can create a wide range of components, including content, layout/page, interaction, form field components, and template helpers, significantly expanding the functionality of the standard library.
• Why use the Component SDK? The SDK simplifies custom component creation by handling complex tasks like manifest configuration, authorization, data access, localization, and workflow interaction, allowing developers to focus on component logic and design. It also leverages the Fluent OMX Design System (based on Material-UI) for consistent and high-quality UX.

This lesson provides a step-by-step guide to downloading, installing, and setting up a new Component SDK project. You'll learn how to prepare your development environment, install necessary dependencies, and run the project locally. We'll also cover the crucial step of referencing your local plugin within your Fluent Web Apps manifest, enabling you to integrate your custom components into your applications.

• Download and Extract: Download the Component SDK zip file and extract it to a suitable development location on your computer.
• Yarn Installation: Navigate to the

  `omx-component-sdk`

  folder in your terminal and run yarn install to download all project dependencies.
• Visual Studio Code Setup: Open the project in Visual Studio Code and verify that the sample components (e.g.,

  `Hello.tsx`

  ) are error-free.
• Local Development Server: Start the development server using yarn start. This allows you to run your plugin locally and test it within your Fluent Web Apps.
• Manifest Configuration: Add a reference to your local plugin project (running on localhost:3001) within your Fluent Store main manifest (

  `fc.mystique.manifest.store`

  ) using a "type": "url" and "src" entry, linking your development environment to your application.

This lesson covers the deployment process for custom component plugins. Unlike server-side plugins, component plugins are frontend JavaScript bundles that can be hosted on any web server. We'll explore the key steps involved in preparing your plugin for production, including versioning, bundling, and deployment, and how to reference the deployed plugin in the manifest document.

• Frontend Deployment: Custom component plugins are deployed as frontend JavaScript bundles, simplifying the deployment process compared to server-side plugins.
• Versioning: Versioning the bundle.js file (e.g., using Webpack's contenthash) is crucial for cache busting and ensuring updates are immediately reflected.
• Bundling with Yarn: The yarn run bundle command is used to create the production-ready bundle, which is placed in the dist folder.
• Web Hosting: The contents of the dist folder can be deployed to any web host.
• Manifest Reference: The deployed plugin is referenced in the manifest document via its URL.
• Multiple Plugins: Multiple plugins for a single project can be deployed to a single folder, with the folder path used in the manifest.

This lesson explores the creation and registration of custom template helpers within the Component SDK. Template helpers are powerful utilities that can be used within Manifest documents for tasks like styling, formatting, and calculations. We'll demonstrate how to create a custom template helper, in this case, one that bolds entity references, showcasing how to leverage the

`TemplateRegistry`

• Template Helpers: Template helpers are reusable functions that can be called within Manifest documents to perform various operations.
• Use Cases: Template helpers can be used for styling, formatting, calculations, and other data transformations.

• `TemplateRegistry`

  : The

  `TemplateRegistry`

  is used to register custom template helpers, making them available for use in Manifests.
• HTML Formatting: The lesson demonstrates creating a template helper that bolds entity references using

  `TemplateRegistry`

  utility methods for formatted HTML generation.
• Customizability: Custom template helpers extend the functionality of Manifests, allowing for greater flexibility and control over data presentation.

This lesson completes the custom form field component by implementing the crucial step of outputting the captured data to the form's submitted payload. We'll learn how to use the

`onChange`

`FormFieldProps`

`locationRef`

`quantity`

• Outputting Data: Custom form fields must output their captured data to be included in the form's submitted payload.

• `onChange`

  Event: The onChange event of FormFieldProps is used to pass the data back to the form.

• `StockReservationPayload`

  : The output data is structured according to the StockReservationPayload interface, containing

  `locationRef`

  and

  `quantity`

  .
• Conditional

  `onChange`

  Call: The

  `onChange`

  event is called only when a valid location is selected.
• Verification: The lesson demonstrates how to use browser developer tools (Network tab) to inspect the posted event data and verify that the custom field's output is correctly included in the

  `reservationDetails`

  attribute.

This lesson walks through the implementation of a custom form field component for a Stock Reservation user action. We'll build a field that captures

`locationRef`

`quantity`

`FormFieldProps`

• User Action Configuration: Enabling user actions in the manifest is a prerequisite for testing the custom field.

• `StockReservation`

  Data Structure: The custom field will capture data in a specific JSON format: { "locationRef": "F_NSYD", "quantity": 1 }.
• React Function Component: The custom field is implemented as a React Function Component (FC).

• `FormFieldProps`

  Interface: The component uses the

  `FormFieldProps`

  interface from the UX Framework, typed with the output payload structure.

• `onChange`

  Handler: The

  `onChange`

  property of

  `FormFieldProps`

  is used to capture user input.
• Field Registration: The custom field is registered with the

  `FieldRegistry`

  using a specific name.
• Workflow Update: The workflow user action definition is updated to use the new custom field type.
• Testing: The lesson includes steps to verify that the custom field is correctly rendered in the user action form.

This lesson introduces the concept of custom form fields within the UX Framework. While standard form fields are automatically generated based on data types, developers can create custom field components to handle more complex data structures or enhance the user experience for specific scenarios, such as workflow user actions, GraphQL mutations, and list filters. In our client scenario, we'll focus on building a custom form field to capture stock reservation details, which requires a JSON object containing

`locationRef`

`quantity`

• Form Field Generation: The UX Framework automatically generates forms based on expected data types.
• Custom Field Components: Developers can create custom field components to handle complex data types or improve UX.
• Extending Scenarios: Custom field components can be used with workflow user actions, GraphQL mutations, and list filters.
• JSON Data Capture: This lesson's focus is on creating a custom field component to capture a JSON object for stock reservation details, containing locationRef and quantity fields.
• Client Scenario: The need for a custom form field arises from the client's requirement to capture stock reservations, which involves a specific JSON structure.

This lesson explores the use of Dynamic Attributes within components, a powerful mechanism for making component content configurable. We'll demonstrate how to create a component, in this case an

`InfoBox`

• Dynamic Content: Learn how Dynamic Attributes enable you to configure the information displayed within a component without modifying its code.
• Manifest-Driven Configuration: Understand how to define and configure Dynamic Attributes within the Manifest, controlling the content of components.
• InfoBox Example: This lesson uses an InfoBox component that appears on pin click as a practical example of using Dynamic Attributes.
• Flexibility and Reusability: Dynamic Attributes make components more flexible and reusable, as their content can be easily adapted through Manifest configuration.

This lesson addresses the best practice of avoiding hardcoded values, specifically API keys, within components. We'll explore how to use the

`useSettings`

• Avoiding Hardcoding: Learn why hardcoding API keys or other configuration values directly in components is not recommended.

• `useSettings`

  Hook: Understand how to use the

  `useSettings`

  hook to access and utilize platform settings within your components.
• Centralized Configuration: This lesson demonstrates how storing configuration values as platform settings allows for centralized management and easy updates.
• Reusability and Configurability: By using settings, components become more reusable and adaptable to different clients and environments.

Token authentication is mandatory for all Fluent integrations.

• An authentication token is required for every request. 
• You can reuse the same token until it expires.
• When a token is close to expiry, a new one can be requested using the refresh token from the authentication response.

Fluent supports various fulfillment options like Click and Collect, Ship-from-Store, and Ship-from-Warehouse. The process involves checking inventory, reserving stock, and notifying relevant parties at each stage. Orders are managed through the Fluent platform, allowing customers to collect from stores or receive deliveries at home, with real-time updates on order status.

• Click and Collect: Customers order online, collect from selected stores.
• Inventory Check: Verifies stock availability before fulfillment.
• Store Fulfillment: Store staff pick, pack, and notify customers for collection.
• Ship-from-Store: Orders shipped from stores with integrated courier booking.
• Warehouse Fulfillment: Uses webhook communication for real-time updates.
• Order Status Updates: Real-time tracking through Fluent workflows.

Order management in Fluent includes handling cancellations, revisions, and returns. Cancellations can be for entire or partial orders. Order revisions allow modifications to in-progress orders before dispatch, and returns handle customer issues with delivered items. Depending on the business' needs, these processes can be managed manually by customer service or automated within workflows.

• Order Cancellation: Cancels entire or partial orders, resetting inventory.
• Cancellation Timing: Configurable to specific workflow statuses.
• Order Revision: Allows changes to in-flight orders before dispatch.
• Return Workflow: Manages customer-initiated returns for various reasons.
• Action Modes: Supports both automated and manual (self-service and customer service) actions.
• Refund Handling: Automatic refunds are processed if payment is taken.

Fluent workflows use webhooks for real-time communication with external systems, triggered at specific workflow points. Webhooks provide timely updates for order status, shipping, payments, and inventory movements. The standard SendWebhook rule simplifies outbound communication by sending basic data, allowing external systems to retrieve additional information as needed.

• Real-time Communication: Outbound communication from workflows.
• Reusable Rule:  

  `sendWebhook`

  rule can be used across multiple workflows.
• Order Status Updates: Triggers for status changes (e.g., order completion).
• Payment Processing: Webhooks manage payment processes post-dispatch.
• Inventory Tracking: Tracks stock changes via webhooks to external systems.

Split fulfilment allows retailers to complete an Order from multiple locations if a single location can't fulfill the whole Order. Rejection occurs when orders can't be fully met due to various constraints, leading to escalated statuses where customer notification and resolution actions are taken. In-flight revisions enable modifications to order items, allowing flexibility in managing customer orders.

• Split Fulfillment: Orders can be fulfilled from multiple locations if needed.
• Rejection Criteria: Orders are rejected if fulfillment criteria aren't met.
• Escalated Status: Notifies and manages unfulfilled orders.
• Customer Communication: Notify customers of rejected orders.
• In-Flight Revisions: Add or remove items from existing orders.

Sourcing determines the best fulfillment location for an order based on various business rules and priorities. It aims to optimize delivery speed, cost, and inventory management while enhancing customer experience. Retailers can quickly adapt sourcing strategies to market changes and manage fulfillment efficiently, ensuring maximum flexibility and revenue.

• Optimized Fulfillment: Chooses the best location for delivery based on speed and cost.
• Inventory Management: Clears old stock and protects key store inventory.
• Customer Prioritization: Prioritizes VIP customers for better service.
• Flexibility: Easily adapts sourcing rules to market changes.
• Split Management: Controls order splitting to reduce costs and complexity.

This article focuses on understanding the Order Domain within Fluent, highlighting orchestrated and non-orchestrated domains. The Order is the central entity that has relationships to sub-entities like Fulfillment, Article, Consignment, and Return Order. These relationships determine the order processing flow, including picking, packing, delivery, and optional returns.

• Order: Central entity in the Order Management domain.
• Fulfillments: One Order can have multiple Fulfillments.
• Article Packing: Fulfillments involve multiple Articles.
• Consignment Delivery: Articles are delivered through Consignments.
• Returns: Optional Return Order linked to original Order.
• Customer Relationship: Orders tied to a Customer for billing purposes.

The 'Order Orchestration' module is integral to Fluent Order Management. It handles the end-to-end management of orders from creation to fulfillment. It optimizes the fulfillment process, allowing flexibility and control over sourcing and fulfillment strategies.

• Dynamic Sourcing: Selects the best location based on inventory and business rules.
• Split Fulfillment: Supports fulfilling orders from multiple locations.
• Custom Workflows: Allows tailoring workflows for Home Delivery, Click & Collect, and more.
• Fulfillment Management: Tracks multiple fulfillments and manages SLAs and exceptions.
• Retailer Benefits: Reduces costs, optimizes sourcing, and ensures operational flexibility.

This article covers how Store arrivals are handled in Fluent OMS.

• When the article arrives at the store, a notification appears in the menu to alert the store associate.
• When the article is marked as arrived, the article status is updated subsequently. 

This article covers how articles are marked as Collected in the Fluent Store app. 

•  Fluent Store covers customer and carrier collections. When the OMS user needs to take action, a notification will pop up in the Store app menu. 
• Upon taking action, the article status will be updated. Subsequently, depending on how the order workflow is set up, the fulfillment and order status entities might also be updated. 

One of the main capabilities provided by Fluent Store is the capability to manage Wave creation, Pick, Pack and Dispatch operations. This article covers these notions, and provides multiple use cases in which they are used.

• Wave creation allows the grouping of a set of fulfillments so that they can be batch-processed for Pick, Pack, and Dispatch.
• The Pick step allows you to pick or reject items and provides a picklist that summarizes the output of the process. 
• The Pack step links the articles and the fulfillments and provides a packing slip as a summary. 

This course covers the basics of the Store module, helping you get acquainted with essential terminology and offering an overview of its high-level implementation in Fluent OMS.

• Fluent Store is a Fluent web app responsible for managing all store operations.
• Fluent Store's reference features include pick/pack/dispatch, managing arrivals, and customer collection operations.
• In addition to the reference features, Fluent Store can be customized via Software Development Kits.

In this lesson, we'll talk about Connector Contracts, and the out-of-the-box connectors that are provided with the Fluent OMS.

• Intro to Connectors
• Out-of-the-box connectors 
  • Salesforce Service Cloud 
  • Salesforce Commerce Cloud 
  • Adobe Commerce Cloud
  • CommerceTools

In this lesson, we'll talk about Batches, and the data that can be loaded using Batches.

• Intro/Recap on what Batches are
• Loading Inventory data via Batch

In this lesson, we'll look at what Webhooks are, their structure, features and some recommended practices around using Webhooks.

• Introduction/Recap on what Webhooks are
• Webhook Structure
• Webhook Features
• Types of integrations for Webhooks
• Webhook best practices

In this lesson, we'll look at Event APIs, learn more about Event Contracts and the role of Events in the Workflow Framework, as well as look at some common integrations that use the Events API.

• Intro / Recap on what Event is
• Events API
• Event Structure
• Event Contracts & relationship to Workflow
• Types of common integrations that use Events
• Events best practices

In this lesson, we'll look at the benefits of using GraphQL, as well as explore the differences between GraphQL and REST based APIs. We will also look at some examples of a GraphQL query and a GraphQL mutation. 

• Introduction to GraphQL
• Differences to REST
• Benefits of using GraphQL
• Basic structure of a query
• A GraphQL mutation
• Types of common integrations that use GraphQL

Welcome! This course talks about the various Integrations and Connections of the Fluent Platform.

• Some common interfaces, and the information shared between these interfaces and the Fluent Platform
• GraphQL, and understand its benefits over REST APIs.
• Events API, Inventory Batches, Webhooks, and Connectors
• Some recommended practices around the use of these methods.

The support process at Fluent Commerce relies on integration partners to handle initial investigations for issues related to custom implementations. If platform-related problems are identified, partners must escalate them via a JIRA support ticket. Additionally, Fluent Commerce offers Expert Services for guidance during the design, implementation, and support phases.

• Partner Responsibility: Handle initial investigations of custom rules and configurations.
• Platform Issues: Escalate confirmed platform-related problems via JIRA with detailed logs.
• Fluent Expert Services: Consultants assist with complex issues during implementation and support.
• First-Time Partners: Fluent Expert Services provides additional support for new implementation partners.
• Customer Success Manager: Partners can seek guidance on using Expert Services.

This lesson covers key operational activities in Fluent Commerce, including Plugin Management, Workflow Versioning, and Audit Events. You’ll learn how to manage Fluent plugins, version workflows, and utilize audit events to debug and analyze processes within the Fluent platform.

• Plugin Management: Upload, activate, and manage plugin versions via Plugin API.
• Workflow Versions: Submit, view, and retrieve versions for effective workflow management.
• Event Categories: Includes snapshots, rulesets, rules, actions, and exceptions.
• Event Viewing: Access audit data via Event API, Event Search, or Fluent OMS Activity tab.

Fluent OMS and Postman are key tools for managing and troubleshooting the Fluent Commerce platform. Fluent OMS provides a web-based interface for managing orders, inventory, and workflows, while Postman facilitates advanced debugging and custom queries using GraphQL. Together, they help identify and resolve issues like stuck orders or workflow interruptions.

• OMS Application: Manage orders, inventory, and workflows in one place.
• OMS Dashboard:  Monitor entity statuses (orders, fulfillment, etc.).
• Postman Queries: Use GraphQL to query or correct data.
• Issue Investigation: Identify stuck orders using order states and filters.
• Workflow Re-triggering: Reset and restart workflows using the Events API.

This training introduces the tools and activities used in Fluent Commerce Support and Operations processes. You’ll learn how to use Fluent OMS and Postman for troubleshooting, identify common issues like stuck orders, and learn to resolve them effectively.

• Fluent OMS: Navigate and use built-in tools for issue resolution.
• Postman Queries: Run custom API queries for debugging.
• Stuck Orders: Learn to identify orders that are not processing.

Walkthrough of an example scenario that demonstrates the advantages of following recommended practices in workflow design.

• Smaller, granular rules offer better flexibility and adaptability, allowing for easier updates when requirements change.
• Composing logic within the workflow gives clients and partners more control over business processes, reducing the need for expensive and time-consuming development changes.
• Workflow-based logic enhances transparency and makes the process details more accessible, avoiding the "black box" effect of code-based logic.
• Granularity in workflows leads to richer audit events, which improves triage and problem identification, resulting in faster issue resolution.

An overview of workflow process flows, explaining how processes are executed by the workflow framework and offering best practices for workflow design.

• Workflow processes execute business logic through rulesets within an execution context.
• Processes can be initiated at the Root Entity level or Sub-Entity level.
• Processes may flow across the same entity, down to a sub-entity, or back up to the parent entity.
• Recommended practices include executing rulesets inline, making business logic visible, and avoiding cyclic flows.

An introduction to the concept of Logical Gates and examples of how to use these in a workflow.

• Logical Gates are a common workflow design pattern, and are used to control workflow execution flow. 
• A logical gate can evaluate a simple condition that resolves to either TRUE or FALSE, or a condition with multiple possible paths such as evaluating an ENUM value.
• A Logical Gate ruleset should only ever produce a single outcome, typically an inline event to process the following ruleset.

In this section you will learn all about rules, including:

• Typical functions of a rule
• How to use them in workflow
• Rule design best practices and recommendations

• Rules are the building blocks of Rulesets.  They should be small, isolated, single-purpose, reusable, and composable.
• Rulesets are composed of multiple rules to perform specific tasks.
• Each rule within a Ruleset is executed in sequence.
• A rule consists of a condition and an outcome (action).
• Meaningful, descriptive names for Rulesets enhance workflow understanding and ease of troubleshooting.
• Rulesets can perform functions like logical gates, state management, and notifying other domains.

In this section you will learn all about Rulesets and how they can be configured using the Workflow Builder.

• Rulesets define the rules that are executed when an Event matching the ruleset trigger criteria is received by the Workflow Engine.
• Rulesets can be added and edited via the Workflow Builder.
• Each Ruleset has a name, applicable trigger statuses, and list of rules or user actions.
• Triggers define when a Ruleset is valid to be executed for a given entity.
• It's possible to configure User Actions to appear in the Fluent Web Apps, which trigger business logic as defined in the corresponding Ruleset configuration.

You will learn about key Workflow concepts and the Workflow Builder 

• Workflows are accessible via the Workflow Builder and the Fluent API
• The Workflow Builder can be used for:
  • Adding and configuring rules, rulesets, triggers, user actions for UI integration
  • Configuring entity states and transitions to match the client's business process
• Each entity type has its own workflow, such as Home Delivery orders (ORDER:HD) and Click & Collect orders (ORDER:CC)

This article will provide an introduction to the fundamental concepts of the Workflow Framework, including:

• Explanation of Events, Rules, Rulesets, and Triggers 
• Description of Statuses representing the condition and state of entities in a workflow
• Details about Actions as outcomes of Rules
• Explanation of User Actions, which are UI interactions integrated with workflows

• Events within the Fluent Commerce platform trigger the execution of rulesets, which are defined in a workflow.
• Rulesets are collections of rules that form steps within a process, executing specific tasks based on configured criteria.
• Rules are single-purpose building blocks of business logic that produce actions such as changing entity states or sending notifications.
• Triggers define conditions under which rulesets are executed when a matching event is received.
• Statuses represent the current state of an entity within its lifecycle.

You'll acquire new knowledge of the Workflow Framework, its fundamental concepts and terminologies, and also learn about best practice workflow design concepts.  

After covering the theory, you will get ‘hands-on’ by completing a Lab where you'll have a go at composing business logic (code free) via the Workflow Builder.

• The Workflow Framework is a component of the Order Management Experience (OMX) platform and drives the business logic orchestration aspects of the Fluent Order Management.
• The Workflow Framework enables flexible workflow customization via low-code configuration, high-performance and scalable processing, and seamless UI user action integration.
• The Workflow Framework comprises the Workflow Engine, Workflow Builder, Rule Library, and Rules SDK.

API, Integration, and Connectors

This lesson covers the various integrations and connections with the Fluent platform.

• Fluent is designed to integrate flexibly with other API's and connectors
• Fluent provides connectivity via Rest and GraphQL API's
• Webhooks provide outbound connectivity from Fluent

The Security Domain represents the Users, Roles, and Permissions across the Fluent platform.  

• User can have multiple roles 
• Roles are collection of permissions
• Users and roles are associated to contexts which can be Account, Retailer and/or Location

The Foundation Domain contains the core foundational entities to support the Order Management capabilities. 

• The foundation domain is made up of:
  • Accounts
  • Retailers
  • Locations
  • Networks

In this section the reader will learn about the Fluent domain model and the various entities that make it up. 

• Fluent provides a flexible domain model to represent data and processes critical for running any business. There are nine Domains:
  • Order Management Domain
  • Billing Management Domain
  • Global Inventory Domain
  • Foundation Domain
  • Store Fulfilment Domain
  • Security Domain
  • Shipping Domain
  • Payment Domain
  • Product Availability Domain

This topic describes an example "Ship from Store" Customer Journey

• Items purchased online
• Most appropriate stock to ship to customer is located in a store, based on business rules such as closest to customer address thus reducing shipping costs
•  Items are shipped from store to customers home address

This topic describes the cloud native nature of the Fluent platform

• Scalable
• Secure
• Versionless software
• Zero downtime

This section outlines how the webapps interact with the modules

• Webapps Include:
  • Fluent OMS
  • Fluent Store
  • Custom Web apps
  • Headless/Third party applications

Following the completion of this section readers should gain an understanding of the different modules and the segregation between them. They should understand some of the key features of the modules and how they could be used to benefit both the customer and the company providing products and services.

• Availability module - provides detailed and accurate stock information & order fulfillment options
• Order Orchestration module - allows retailers to track all of the statuses of an order through its lifecycle
• Inventory module - allows retailers to get a unified version of inventory across all locations and inventory management systems
• Store module -  provides order management and fulfillment capabilities in-store by guiding store colleagues through the day-to-day processes
• Service module - provides all the capabilities to enable flexible customer support

What is Fluent Order Management?

'Fluent Order Management', also referred to as the 'Fluent Platform', is the core product of 'Fluent Commerce'.

• The main components that comprise the platform architecture are:
  • Webapps
  • Order management
  • Experience (OMX)
  • Orchestration Engine and Cloud Infrastructure
• Together, they enable faster implementation, decrease development costs, and adapt quickly to ongoing changes.

In this article, you will explore a real-life business scenario and learn how the Product Availability call helps address it.

• As a customer, you would browse an e-commerce site and be shown the available quantity for sale.
• Product Listing Pages (PLP) and Product Details Pages (PDP) use different methods to retrieve the ATS quantity and can showcase different levels of granularity regarding the data of the queried SKUs.

This article provides some key guidelines for working with Fluent Commerce on implementation projects, including platform and application support responsibilities.

• The first point of contact during project implementation phase is your assigned Expert Services consultant
• Fluent Commerce provide platform support along with service desk tooling and support process documentation
• Application support is typically the responsibility of the Implementation Partner, and there must be an application support agreement in place prior to go live.

 This article will cover the typical Fluent Commerce account structure, the provisioning of accounts, and some key points covering performance testing.

• A typical setup of a Fluent ecosystem for a project will include a production and 2 non-production (or sandbox) accounts
• Accounts are provisioning via the Fluent Commerce Expert Services team at the relevant project milestones
• Performance testing should be planned in advance and needs to take place against a dedicated performance test account

In this course you will learn how Controls and Control Groups are used to define the ATS quantity. 

•  Control Groups are "containers" for Controls
• There are multiple types of Controls, some of which are QUANTITY_BUFFER and EXCLUSION. They allow you to limit the number of items Available to Sell

In this course, you will understand how the Virtual Catalog enables the calculation of the ATS quantity.

• A Virtual Catalog contains Virtual Positions which typically represent the ATS quantity of a product in a location, or a product across all locations in a network.
• A Virtual Catalog calculates the ATS quantity by combining inputs from the Inventory Catalog and the Control Groups. The ATS quantity is the inventory on hand quantity with buffer values applied.

This article covers the typical approaches used to estimate projects.

• Project effort estimation 
• Requirement prioritisation

This course covers how the Inventory Position On Hand quantity is calculated from the different Inventory Quantity types.

• The Inventory Position On Hand quantity is the sum of the LAST_ON_HAND quantity and any active RESERVED, SALE, CORRECTED and DELTA quantities.
• Inventory Positions are deactivated and not considered during availability calls or order sourcing if the location or the product is inactive. 
• The Inventory Catalog workflow considers both external events (resulting from third-party systems) and internal events (resulting from workflow updates) to calculate the On Hand quantities. 

The Ready for Launch (RFL) process includes a number of tasks and activities involved in reviewing a client's configuration, inventory management, workflows, custom plugins and integration designs during the project lifecycle.  

• Typical tasks and activities involved in Ready for Launch
  • Configuration Analysis
  • Inventory Management Analysis
  • Workflow Analysis
  • Custom Plugin Analysis
  • Integration Analysis

In this lesson, you will learn how delta inventory updates can be sent to Fluent OMS.

•  An inventory update can be done either via Batch API for bulk updates, or the Event API for smaller delta updates.
• While a Batch update creates or updates a LAST_ON_HAND inventory quantity, a Delta update creates or updates a DELTA inventory quantity

Discovery is the critical first phase of any project where all parties develop a shared understanding and mutually devise strategies to solve the various problems from an OMS perspective.   It gives the opportunity to align the client, project team, business, IT stakeholders, and other vendors but also ensures the project is steered in the right direction with a strong foundation.  Discovery topics refer to the main areas we suggest should be covered during a discovery session.

• Recommended topics to cover in discovery workshops:
  • Ecosystem and integrations
  • Omnichannel experiences (apps and orchestration configuration)
  • Business operations, project and change management.

In this course you will learn how inventory is uploaded into Fluent OMS and how the Inventory Catalog enables the maintenance of stock-on-hand records across all locations.

• An inventory stock-on-hand record represents the QUANTITY of a SKU at a LOCATION. 
• The on-hand quantity is a combination of the last received on-hand stock and inventory updates resulting from order workflow events.
• Inventory can be sent into Fluent via Full Loads or Inventory Position Change updates.

Fluent Expert Services (ES) are our subject-matter experts who are responsible for ensuring that project implementations leverage the full extent of the software features and capabilities of Fluent OMS, and that best practices are followed.  This article will cover the different service packages that are on offer to help facilitate the project, keep it moving forward and involve all parties (Expert Services, Partner, and/or the Client) working collaboratively to validate choices, monitor progress, and review developments.

• Some of the packages provided by the Expert Services Team:
  • Discovery and Solution Design
  • Order Management Experience
  • Go-live readiness

This course covers how product master data is handled in Fluent.

• Standard and Variant Products are handled via a parent-child hierarchy in Product catalogs
• Products can be grouped in a category, which are used when business logic is applied to a group of products.
• Group products can be used to model bundle products. 

This course covers the basics of the inventory module. You will become acquainted with key terms and concepts and understand the core data objects and flows.

• The inventory module covers everything related to inventory management in Fluent OMS.  Base capabilities are configurable via workflows for product catalog, inventory catalog, control group, and virtual catalog entities.
• The inventory module allows for configuring the inventory availability flow, from uploading inventory data to calculating on-hand and Available to Sell (ATS) values.  Different configurations, e.g., safety stock buffers, virtual catalogs, and inventory reservation triggers, allow for the adjustment of this flow. 
• The Fluent Rules SDKs can be used to extend inventory module capabilities and the base functionality.

Learn about the typical phases in delivering Fluent OMS projects from Discovery to 'Go Live'.

• Comprehensive Discovery: Ensure thorough gathering of business requirements and precise backlog generation to set a solid foundation for the project.
• Robust Testing: Conduct System Integration Testing (SIT), Performance Testing, and User Acceptance Testing (UAT) to validate all aspects of the solution.
• Client Involvement: Engage clients early, especially before UAT, to familiarize them with the user interfaces and gather their feedback.
• Successful Launch: Execute a meticulous production deployment, including data staging and validation testing, to ensure a smooth 'go live' transition.

This course introduces the fundamentals of the availability module, helping you familiarize yourself with key terms and providing an overview of its high-level implementation in Fluent OMS.

• Determines availability based on product, customer location, delivery method.
• To set up Availability in Fluent OMS, you must set up master data, Inventory Catalog workflow, and Virtual Catalog workflow. 

This article will cover the typical team setups involved in Fluent OMS projects, and the various roles and associated tasks in delivering a successful project.

• Project team setups typically include clients, implementation partners and Fluent's Expert Services team.
• Project representatives from Fluent Commerce, the Client and/or the Partner are separated into distinct areas of project responsibility.  See below for the typical roles and responsibilities for both discovery phase and project implementation phase.
• Projects are usually partner-led; however client-led in-house projects are also possible.  

In this lesson, we'll discuss Fluent OMX, which stands for Order Management Experience. We'll be introducing concepts such as Fluent workflow and UI configuration and customization.

• Workflow - defines the logical flow or lifecycle of a top-level entity within a domain
• The UX, Workflows, and Integration can be enhanced to suit business needs via configuration or extension
• Fluent provides tools that empower both technical and non-technical users 

This page sets out the:

• Platform usage limits;
• Platform data limits; and
• Acceptable Use Policy and other enforcement rights

relating to the Fluent Order Management Cloud Platform (Platform)

• Usage of the Platform and all related Products are subject to the Platform limits, data limits and acceptable use policy set out or referred to in this document.
•  Read this together with your Agreement/Order Form relating to the Platform. 
• Platform limits (for each type of Account) apply in aggregate across all applicable Accounts referred to in your Order Form.  

This page sets out the:

• Platform usage limits;
• Platform data limits; and
• Acceptable Use Policy and other enforcement rights

relating to the Fluent Order Management Cloud Platform (Platform)

• Usage of the Platform and all related Products are subject to the Platform limits, data limits and acceptable use policy set out or referred to in this document.
•  Read this together with your Agreement/Order Form relating to the Platform. 
• Platform limits (for each type of Account) apply in aggregate across all applicable Accounts referred to in your Order Form.  

A batch contains a series of records that will have the same operation applied to it. All batches are run asynchronously as such the client will be required to request a status update for entered batches. A batch can include a maximum of 5000 records.

To create a Batch, the user must first create a Job. A job is required to store a series of batches. For more information please refer to the Job API.

• Overview
• Inventory Batch Properties
• What you can do with Inventory Batch
• Response on Failures

This guide helps to select the correct IDP configuration and plan SSO implementation.

• Single sign-on (SSO) is exclusive to the OMX framework, and API users are managed in Fluent IdP, not Corporate IdP, with creation possible through API.
• SSO, enabled for each Fluent account, involves creating a corresponding SSO Ping Identity environment managed by the SRE team, covering admin user setup, password policy configuration, branding, and application enablement.
• SSO Environment Admin Users, Fluent IdP Configuration, Password Policy, and other guides provide comprehensive details for SSO enablement, Corporate IdP integration, user management, authentication policies, multi-factor authentication, and configurations with Azure AD and Okta.

• After following this guide a user will be able to create a new Inventory Feed
• The output from this feed can be used to supply inventory availability data to any system
• Additional steps will outline optional configuration that can be applied to Inventory Feeds

Learn about managing state in a workflow and the recommended best practices to follow.

• Do not change the status of an entity until all conditions of that state have been confirmed.
• Avoid duplicating logic within the workflow to maintain simplicity and readability.
• Always use the SetState rule to change the state of an entity.
• Handle all state change logic within a single execution thread where possible.
• Utilize ruleset triggers to guard against illegal actions on states.

In this module you'll learn about how events are executed on the Fluent platform.

• A workflow represents the journey of a root entity, and related sub-entities, through various stages in its lifecycle.  These stages are represented by statuses.
• Rulesets are collections of rules forming tasks within a process, dictating movement from one state to another based on business logic.
• When an orchestration event is received, the Workflow Engine loads the associated workflow and searches for a matching ruleset based on event name, entity type, subtype, and status.  Matched rulesets are executed, and may produce additional events to trigger further rulesets in sequence.

• The UX Framework in the Fluent platform automatically checks for configured manifests in Account settings. If none exist, the Fluent web app defaults to loading using baseline manifests within the platform, ensuring a seamless and standardized user experience.
• To customize the main web app manifest or specific fragments, users should follow the naming convention, with the setting name for the main web app manifest file.
• It is recommended to override the main manifest only when adding or removing fragments; otherwise, users can efficiently modify specific fragments by overriding them individually.

• Example createOrder mutation payload for MULTI order type

In this article, you will understand how fulfillment options provide the Available to Sell quantities.

•  Fulfillment Options generate Fulfillment Plans based on the requested items. If necessary, the response payload can be personalized to include additional information, such as the Expected Time of Arrival (ETA). 
• Typically, the Product Listing Page (PLP) would rely on cache inventory on Ecom to provide the ATS quantities, and the Product Display Page (PDP) will use Fulfillment options to provide real-time ATS quantities.

This page describes how Inventory Batch Pre-Processing (BPP) works, the opportunities available for configuration, and the implementation improvements enabled by using Inventory Batch Pre-Processing.

• Inventory Batch Pre-Processing optimises the performance of inventory ingestion using Inventory Batches
• This optimization can reduce the processing time for Inventory Batches, depending on the volume and data redundancy ratio.
• Inventory Batch Pre-Processing can be enabled per Account and Retailer as needed

• Create new Inventory Batches using the Job API 
• Sample Inventory batch payload 
• Inventory batch details

The Unified View of Inventory (UVOI) consolidates data from multiple locations and channels into a single, real-time interface. It provides centralized inventory search, advanced filtering, and customizable views. It enables you to monitor, analyze, and act on inventory data.

• Centralized Inventory Management: The Unified View of Inventory (UVOI) consolidates data from multiple locations and channels into a single, real-time interface, simplifying inventory management and improving decision-making.
• Advanced Filtering Capabilities: UVOI offers flexible filters for refining search results, including catalog, stock status, on-hand quantities, and product or location-specific criteria.
• Comprehensive and Customizable Views: The Inventory Search page provides a detailed overview of inventory, with drill-down capabilities for stock levels, available-to-sell quantities, and update histories. Users can navigate to location-specific or product-specific views and customize filters and criteria to tailor the experience to their operational needs.

The Fluent Big Inventory Web App is a powerful tool for managing products, inventory, feeds, and sources. Key features include:

• Feeds: View inventory feed details.
• Sources: Track inventory update integrations.
• Products: Manage catalogs and product data.
• Unifies View of Inventory: Gain real-time inventory insights across locations and channels for optimal stock management.
• Inventory: Monitor allocation, SOH, real-time updates, and buffers.
• Stores: Oversee individual and network locations.
• Insights: Track system events.
• Admin: Configure user access and settings.

• The Fluent Big Inventory Web App offers a comprehensive suite of functionality.
• With dedicated sections for Sources, Products, Inventory, Stores, Insights, and Admin, the web-based interface provides users with a holistic toolset, allowing them to observe and track integrated sources, manage product catalogues, exercise precise control over inventory, oversee individual and networked store locations, monitor system events comprehensively, and efficiently administer the entire inventory availability system for a seamless and valuable user experience.

The Fluent CLI provides command line tooling for interacting with Fluent Accounts and Modules.

Usage

The Fluent CLI is activated by typing the keyword

`fluent`

`fluent <command> <subcommand> <argument> [options]`

• The

  `<command>`

  will refer to a noun (or “a thing”).
• The

  `<subcommand>`

  will refer to a verb (or action).
• The

  `<argument>`

  is the primary required name of the “thing” identified by the

  `<command>`

  .
• The

  `[options]`

  may include required or optional additional parameters to be used by the

  `<command>`

  and

  `<subcommand>`

  .

The Fluent Big Inventory Web App simplifies inventory management with key features like the Feeds Dashboard, Products, and Inventory sections. Gain real-time insights into feeds, efficiently manage products, and ensure robust inventory control. Whether tracking sources, managing stores, or accessing comprehensive insights, this app delivers a seamless user experience for optimal business value.

This guide helps to select correct IDP configuration and plan SSO implementation.

• SSO is only supported by the OMX framework
• All API users will be stored in Fluent IdP and cannot be stored in Corporate IdP as it’s not an individual user and has a separate machine-to-machine authentication flowSSO/Ping Identity Environment

The values on the packing list.

• List of values on the packing list 

This guide provides solutions to common issues encountered in eLearning environments, including troubleshooting steps for login errors, exam resets, and password recovery.

The  Orchestration Engine powers the execution of workflows, business logic, and business processes. It enables real-time sync for orchestrated availability calls, high-volume batch processing for inventory loads and updates, event tracking which logs all activities, responds to events triggering execution, and triggers activity in external systems.

• Orchestration Engine
  • Powers the execution of workflows, business logic, and business processes.
  • Enables real-time sync for orchestrated availability calls, high-volume batch processing for inventory loads and updates, event tracking which logs all activities
  • Responds to events triggering execution, and triggers activity in external systems.

• A step-by-step guide how to convert workflow statuses list into CSV / Excel table format

A batch contains a series of records that will have the same operation applied to it. All Batches are run asynchronously so to confirm success or failure the client must request a status update for submitted batches via the GET API at a later stage. Most Batches are limited to 5,000 records.

To create a Batch, the user must first create a Job. A Job is required to store a series of batches. For more information please refer to the Job API.

• Batch Properties
• Category Batch
• Inventory Batch
• Location Batch
• Response on Failures

• Fluent Order Management enables the management of payments throughout the lifecycle of an Order.
• Build custom payment logic into the Order workflow using the OMX Workflow Framework and provided entities.
• This document provides an overview of the Payment Data Model and GraphQL API capabilities and does not include any reference Rules, Workflows, or UX Components.

• Pre-requistes
• Data Model
• Entities
• Explanation of the Entity Relationships through an Example
• Relationship details
• GraphQL queries required for Payments

The

`payment`

• The page provides GQL example of how to use

  `payment`

  :
  • Create
  • Update
  • Query

This guide teaches you how to manage large monetary values accurately in Fluent OMS using

`scale`

`unscaledValue`

`amount`

• Avoid floating-point inaccuracies by using

  `scale`

  and

  `unscaledValue`

  for large amounts.
• Treat

  `unscaledValue`

  and

  `scale`

  as the source of truth for exact monetary values.
• Adjust

  `scale`

  to handle very large amounts while maintaining precision.
• For display and reporting, always reconstruct amounts from

  `unscaledValue`

  and

  `scale`

  .

The Comment GraphQL API allows customers to manage Comments across various Entities.

Multiple Comments can be added against the same Entity, with each Comment automatically capturing:

• The timestamp
• The User who created it

This feature allows Users to record specific business actions and events, providing a comprehensive history of interactions and updates.

• Add Comments to any Entity Type, enabling detailed documentation of business actions
• Specific Permissions are required for Comment operations
• Use the

  `createComment`

  and

  `updateComment`

  Mutations to manage Comments
• Use the

  `commentById`

  and  

  `comments`

  Queries to retrieve Comments

A Retailer Batch is used to create new Retailers within a Fluent Account. This can be used when a new retail operation is being onboarded to an existing Fluent Account or during the initial setup of the Fluent Account to create the required Retailers.

• Create new Retailers using the Job API
• Sample Retailer batch payload
• Retailer batch details

To accelerate carrier integration between the Shippit and Fluent Order Management platforms, Shippit and Fluent Commerce provide a connector that enables seamless pick, pack and dispatch processes inside the Fluent Store App.  

• The client must have a direct account with Shippit about their shipping agreement.  The Shippit Connector helps to speed up the integration timeline between Fluent and Shippit. 
• Before obtaining the Shippit Connector, a Fluent commercial agreement must be in place prior to using the connector; please get in touch with your Fluent Customer Success Manager.
• The Shippit Connector will be integrated with the Fluent Store App, where the pick, pack, and dispatch processes will be integrated with the Shippit integration.
• The Shippit Connector can support the following features:
  • Creating labels and shipping manifests at the wave level that streamline the Store User process;
  • The Store User can select one or more articles for a manifest within the same location;

An Article can be created when a fulfillment is fulfilled, or when a dispatch occurs. The Article represents the physical parcel that contains the customer order items. The Article is the entity received by the customer.

• Article Entity Relationship
• Article Properties
• What you can do with Article

• An easy step-by-step guide on how to add a new ruleset to update fulfilmentChoice status.
• This example can be used on the MULTI order type (mixed basket) workflow.

A detailed explanation of Fluent OMS entities and how they can be used throughout the order journey.

• Entities in Fluent OMS are data objects that store and process information throughout the order journey, such as orders, fulfilments, and financial transactions.
• Entities are managed via GraphQL, with mutations and queries used to create, update, and retrieve entity data.
• Entities should not be deleted but controlled using status fields, although some "remove" mutations can disconnect entities.
• Orchestrated Entities trigger a CREATE event upon successful creation, enabling workflow automation.
• Entities in Fluent OMS serve unique purposes to enable an end-end digital commerce journey and their statuses determine at what stage they sit.

Rewarding way for customers to share their achievements.

• How to engage in the Reference Program? 
• What can I get when Im completing a marketing activity?
• How can I use my points ? 

Authentication policies dictate how the user's identity will be verified. For Corporate IdP all users are managed by corporate IdP and authentication policy needs to be configured to make sure that all users are authenticated via internal IdP.

• The authentication policy needs to be configured to make sure that all users are authenticated via internal IdP.
• API users and Fluent IdP users will be managed via separate authentication policies.

• This guide covers setting up an SSO connection between PingOne and Google Workspace using SAML.
• Ensure you have admin access in PingOne and a Google Workspace account with an active subscription.
• You need to register the application in Google Workspace to configure it as an external identity provider.

Description of the technical and organisational measures implemented by the Fluent Commerce (including any relevant certifications) to ensure an appropriate level of security, taking into account the nature, scope, context and purpose of the processing, and the risks for the rights and freedoms of natural persons.

• Data Encryption: Both in-transit and at-rest data are secured using advanced encryption methods, including TLS 1.2+ for data in transit and AES-256 for data at rest.
• System Resilience: Infrastructure across multiple AWS zones with auto-scaling and real-time monitoring ensures high availability and resilience.
• Access Control: Access to data is strictly controlled through least privilege access principles, strong password policies, and Multi-Factor Authentication.
• Incident Response: Fluent Commerce has measures in place for rapid data restoration and system recovery in the event of a physical or technical incident.

The Fluent Big Inventory Web App is pre-configured with standard functions that provide the interface for managing products, inventory, feeds, and sources and serve as a starting point for your projects.

The default UX templates are hosted on the platform, so you don't have to create the manifest settings unless you need to customize the existing baseline configuration.

• The Fluent Big Inventory Web App comes with pre-configured standard functions, offering a user-friendly interface for effective management of products, inventory, feeds, and sources.
• Default UX templates are readily available on the platform, eliminating the need to create manifest settings unless customization of the existing baseline configuration is required, streamlining the setup process for a seamless user experience.

The Fluent Store web app is a preconfigured baseline web app which can be used as a starting point for your projects.

The default UX templates are hosted on the platform, so there is no need to create the manifest settings yourself, unless you need to customize the existing baseline configuration.

• Instructions on how to override the default manifest document
• Details on where to find baseline manifests and configuration guides
• Recommendations for text editors to use when editing manifest documents
• Guidance on saving manifest documents to your account
• Information on adding new fragments to your web app

All the details you need to know about Fluent Commerce support during the Peak period 2024.

• Date of the Peak period 2024
• Fluent Commerce support model

To guide you through your journey of understanding and learning the Fluent Commerce OMS platform, the documentation is modeled according to the internal building blocks of the system, like 🔀Workflow or ⚙️Settings, with other top-level content types, such as 💡Essential Knowledge and 🧭How-to Guides layered on top of it. Dive right into it by starting here.

This is a guidepost for Developers highlighting important guides and articles to speed up Fluent Commerce's learning process. 

• Workflows that consist of states, rulesets, triggers, user actions, and Modules, used for distributing workflows and it's artifacts, are a key part of the Fluent Commerce platform.
• Settings are used to adjust Workflow execution

This Data Privacy Addendum (DPA) details the data protection commitments and obligations of Fluent Commerce in relation to its Fluent Order Management cloud-based platform and services. Readers will find detailed information on the processing, transfer, and security of personal data by Fluent Commerce as data processor, and serves as a guide for clients to understand how their personal data is managed and protected.

• The Data Privacy Addendum details Fluent Commerce's obligations in line with applicable data protection laws as data processor when processing personal data as data processor in context of its Clients' use of the Fluent Order Management Platform and Services. 
• Clients maintain control as data controllers, while Fluent Commerce acts as a data processor, adhering to the Client's documented instructions for data processing.
• Sub-processors may be engaged by Fluent Commerce with prior notification to the Client complying with applicable data protection laws.
• Transfer of personal data across borders is governed by Standard Contractual Clauses to safeguard data in accordance with GDPR and other applicable data protection laws.

This page sets out the:

• Platform usage limits;
• Platform data limits; and
• Acceptable Use Policy and other enforcement rights

relating to the Fluent Order Management Cloud Platform (Platform)

• Usage of the Platform and all related Products are subject to the Platform limits, data limits and acceptable use policy set out or referred to in this document.
•  Read this together with your Agreement/Order Form relating to the Platform. 
• Platform limits (for each type of Account) apply in aggregate across all applicable Accounts referred to in your Order Form.  

There are numerous ways of monitoring the Fluent platform and its functionality. We can distinguish between different types of monitoring, such as business or technical monitoring.

• Create a profile
• Create a retailer
• Install the Fluent Reference Modules
• Install B2C Sample Data modules
• Validate the Account set up

Events are a fundamental part of the Fluent Platform. Not only are they used to trigger workflow logic, but they also capture everything that happens within the system. Events are categorized by type.

• Event Types: Understand the different event categories such as ORCHESTRATION, ORCHESTRATION_AUDIT, API, and GENERAL events, each serving distinct purposes within the Fluent Platform.
• Event Retrieval: Use the GET methods with appropriate parameters to retrieve specific events or a filtered list of events, ensuring you handle possible 404 errors for not found items.
• Event Creation: Leverage the POST methods to create new events either asynchronously (/event/async) or synchronously (/event/sync) based on the workflow requirements.
• Authentication: Remember that authentication is required for all operations within the Event API, ensuring secure access and interaction with the event system.

GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. It provides a complete and easy-to-understand description of the data in your API. Its ability to return select fields enables it to be used with powerful developer tools and ensures that APIs are easily scalable.

Fluent's GraphQL API has two operations:

• Queries 
• Mutations

Queries include predefined Queries and Custom Queries, both of which will be covered below.

• Operations
• Queries
• Mutations
• Custom Queries

The Setting Schema is a JSON schema used by the Settings Component to provide metadata for a setting, helping to define its structure. This schema primarily describes the fields that the component will render, allowing for a no-code configuration experience within the Fluent platform.

• The Setting Schema is defined using JSON schema standards.
• It describes the structure of a setting rather than validating the content of a JSON file.
• Only a subset of JSON schema keywords is utilized to define the structure.

The OMX UX Framework delivers configuration-based solution implementation for UIs (Web Apps). Configuration is managed in a JSON document called the OMX Web App Manifest.

• The OMX Web App Manifest document is essential for configuring Fluent Platform web apps and is stored in a setting following the convention "fc.mystique.manifest.<appname>". For instance, Fluent Commerce UIs have settings like "fc.mystique.manifest.oms" and "fc.mystique.manifest.store." 
• The document, configured in the ACCOUNT context, is a specific JSON structure that includes sections like App-Level Configuration, Route-Level Configuration, and Local Development Options. Each web app defined within an account has a unique URL, and the Manifest guides app development, covering aspects like navigation, screen layouts, data sources, and user actions. 
• Manifest updates can be done through Console/settings or directly via the API, with the ability to partition the document for manageability.

• Overview
• Prerequisites
• Installation
• Next Steps

If a company has an internal IdP then this IdP can be integrated with our SSO Vendor and used for future user authentication.

API user is always managed in the SSO vendor environment and doesn't have an MFA authentication option.

• For SSO to work, you need to establish a connection between your Corporate IdP and our vendor IdP. Once the relationship is established then your password policies and MFA configuration will be used during user authentication in Fluent.

• It is possible to use the generic SAML configuration to add an external identity provider that follows the SAML standard
• This page provides a guide on how to configure an external identity provider via SAML configuration.

User management is a client’s internal process. Your nominated IT team or a partner is responsible for user management.

• Corporate IdP
• Fluent IdP & API Users

The Ready for Launch process (RFL) is an engagement with the Fluent Commerce Expert Services team throughout the lifecycle of a Fluent project. The process is initiated at the beginning of a Fluent Commerce project and completed with the go-live of the project in production.

The final review ("RFL Launch Gate") should be planned for 3-4 weeks before the desired Go-Live event to receive the approval to move into production.

• The Kickoff stage covers the introduction to the Ready for Launch process and the initial project & solution overview.
• The Design Review stage covers a detailed presentation of the solution by the partner and the review of the implementation by Fluent Commerce.
• The Launch Gate stage covers the presentation of the final solution and performance test results as well as the confirmation of the desired launch date. After a final review, Fluent Commerce provides the production go-live approval.

• Often you might need to display JSON payload on the Admin Console
• You can use a mustache helper, or you can display individual values with deep references

• This guide is about displaying HTTP(S) links in Admin Console.
• This can be achieved through a Mystique configuration.
• Store a HTTP(S) link to a document e.g. packing slip as an attribute against an entity.
• Display the attribute as a clickable link in the Admin Console.

Below are the properties available in the Category object, which can be updated and retrieved through the APIs in this document.

• Below are the properties available in the Category object  
• This can be updated and retrieved through the APIs in this document.

Carriers configuration contains:

• Carriers List page
• Carrier Details page

The Admin user interface in the Fluent OMS Web App provides comprehensive administrative capabilities to manage the entire system efficiently.

• The Admin section helps in managing users, retailers, settings, etc.
• It contains some or all of the following: Retailers, Carriers, Users, Roles and Permissions, and Settings.

• This guide will walk you through configuring the main sections of the Pack Wizard: Unpacked Items, Packed Items, Rejected Items, and the scanner, enabling you to tailor it to your specific requirements.
• The default configuration does not include a list of parcel types with predefined dimensions. It only displays basic details of the items being packed (such as image, product name, and reference) and allows users to select from four predefined reasons for rejecting items.

Please refer to this document to confirm contact points, SLAs and escalation paths.

• Overview
• Severity Definitions
• Service Level - Response and Resolution
• Service Level - Availability
• Issue Submission Process

Please refer to this agreement to confirm contact points, SLAs and escalation paths.

• Overview
• Severity Definitions
• Service Level - Response and Resolution
• Service Level - Availability
• Issue Submission Process

This Support Policy describes the support services provided by Fluent Commerce in connection with the “Fluent Order Management” Cloud Platform.

• Support Policy - Fluent OMS

This Support Policy describes the support services provided by Fluent Commerce in connection with the “Fluent Order Management” Cloud Platform.

• Support Policy - Fluent OMS

Fluent Order Management components are Web Apps, Modules, Order Management Experience (OMX), Orchestration Engine, and Cloud Infrastructure. These components operate within the framework to enable the order management experience on the platform.

Fluent Order Management components are Web Apps, Modules, Order Management Experience (OMX), Orchestration Engine, and Cloud Infrastructure. These components operate within the framework to enable the order management experience on the platform.

This page sets out the:

• Platform usage limits;
• Platform data limits; and
• Acceptable Use Policy and other enforcement rights

relating to the Fluent Order Management Cloud Platform (Platform)

• Usage of the Platform and all related Products are subject to the Platform limits, data limits and acceptable use policy set out or referred to in this document.
•  Read this together with your Agreement/Order Form relating to the Platform. 
• Platform limits (for each type of Account) apply in aggregate across all applicable Accounts referred to in your Order Form.  

This page sets out the:

• Platform usage limits;
• Platform acceptable use policy; and
• Data restrictions which apply to the use by clients and partners and their users of the Fluent Commerce Platform (Platform), also referred to as the Fluent Order Management or the Cloud Services.

• Usage of the Platform and all related Products are subject to the Platform limits, data limits and acceptable use policy set out or referred to in this document.
• Read this together with your Agreement/Order Form relating to the Platform. 
• Platform limits (for each type of Account) apply in aggregate across all applicable Accounts referred to in your Order Form.  

This page sets out the:

• Platform usage limits;
• Platform data limits; and
• Acceptable Use Policy and other enforcement rights

relating to the Fluent Order Management Cloud Platform (Platform)

• Usage of the Platform and all related Products are subject to the Platform limits, data limits and acceptable use policy set out or referred to in this document.
•  Read this together with your Agreement/Order Form relating to the Platform. 
• Platform limits (for each type of Account) apply in aggregate across all applicable Accounts referred to in your Order Form.  

• User action capability is used to create a Refund against an Order. Order workflow should be extended to have a rule to capture appeasement requests and then process them by looking up the billing account of that customer and creating a credit memo of that refund amount. 
• It is possible to configure Appeasement functionality via UI and via Postman.

The following guidelines and specifications apply to the entire schema, with any exceptions documented in the schema of the relevant entity.

• The GraphQL request size is limited to 2MB
• There is no validation on any of the GraphQL fields (except for enums)
• The GraphQL query complexity is limited and checked in accordance with the Query Complexity Calculation Algorithm (11,111 Total Complexity is Max)

The Fluent Store Web App brings Order Management capabilities to the in-store experience, enabling Retailers to transform their existing Stores into fulfillment and distribution centers, optimizing costs and enhancing the customer experience.

Returns OMS configuration contains:

• Creating a Return
• Returns List page
• Return Details page
• Return Fulfillment Details page

• Create a return in Fluent OMS
• View returns from all retailers associated with the logged-in user
• View detailed information about a return
• View detailed information about how a return was fulfilled

• The Pack Slips can be customized using an HTML template.
• This guide outlines the setup and fragment modifications required for generated PDF customization.

The Pack feature of the Fluent Store empowers Store Associates to efficiently manage the packing process for multi-parcel shipments. It allows them to allocate items to specific parcels, add new parcels as needed, set parcel dimensions and weight, remove parcels, and reject items that don't meet requirements. This feature ensures that each parcel is properly organized and labeled, giving Store Associates complete control over the packing process.

• Store Associates can choose which fulfillment to pack next, optimizing the packing process based on operational needs.
• Fulfillments are organized into two tabs—Awaiting Pack and Packed Fulfillments—providing a clear overview of the packing stages.
• A badge displays the number of fulfillments awaiting packing, helping Associates manage their tasks efficiently.
• Store Associates can allocate items to specific parcels, add or remove parcels, set dimensions and weight, and reject items.
• The integrated barcode scanner speeds up the packing process by quickly and accurately identifying parcels and items.

This article introduces the concept of a Fluent Commerce Module, describing it's basic structure and content.

• Provide a good understanding of the following topic:
  • Module Artifacts/Metadata
  • Rules
  • Workflows
  • Settings
  • Web App Manifests
  • Transactions
  • UI Components

The Fluent Store Web App empowers retailers to enhance their operational efficiency by transforming stores into fulfillment centers and optimizing inventory management, ultimately delivering a superior customer experience through streamlined order fulfillment and improved inventory control. 

The app contains the following configurations:

• All Locations
• Stores
• Warehouses
• Networks

• Stores are transformed into efficient fulfillment centers, ensuring a seamless customer experience through optimized order fulfillment and superior inventory control.
• With configurations for all Locations, Stores, Warehouses, and Networks, the app provides a comprehensive toolkit, enabling retailers to manage their entire ecosystem.

This document provides a comprehensive overview of our deprecation policy, detailing the lifecycle and end-of-life processes across our Platform components.

• List of Deprecated Platform components: A detailed list of all the Platform components (from foundational services and frameworks to distinct products and features) that are currently in the deprecation phase, including their respective versions.
• End of Service Dates: Key dates post-deprecation, until which we will continue to offer limited support (such as security patches or critical fixes) for the component.
• End of Life Dates: Specific dates indicating when deprecated products/services will no longer be available or supported.
• Support and Transition Guidance 

This document provides a comprehensive overview of our deprecation policy, detailing the lifecycle and end-of-life processes across our Platform components.

• List of Deprecated Platform components: A detailed list of all the Platform components (from foundational services and frameworks to distinct products and features) that are currently in the deprecation phase, including their respective versions.
• End of Service Dates: Key dates post-deprecation, until which we will continue to offer limited support (such as security patches or critical fixes) for the component.
• End of Life Dates: Specific dates indicating when deprecated products/services will no longer be available or supported.
• Support and Transition Guidance 

Admin section helps in managing users, carriers, and retailers and contains the following configurations.

Discover how the Reports page in the Big Inventory Web App enables understanding an account Inventory Position Update and Inventory Position Change usage for selected periods.

• The reports provided enable a user to understand an account Inventory Position Update and Inventory Position Change usage for selected periods of time
• These usage metrics are split into two different reports so the user can analyze the metric that is most important

• Verify Compatibility: Ensure your existing account meets all prerequisites for enabling Fluent Store.
• Follow Step-by-Step Guide: Adhere to the provided instructions to enable Fluent Store on your account seamlessly.
• Utilize Support Resources: Refer to the official documentation and support channels for any issues or queries.

The customer Collections feature is applicable to the Click and Collect fulfilments. This feature enables the store users to confirm the orders collected by customers in-store.

Fluent Store is an in-store responsive web application that provides store staff with end-to-end order management capabilities.

• Key features of Fluent Store
• Benefits to Retailers
• Module dependencies
• Technical Information (Browser, Device, and Language support)
• Data model
• Further Reading

• This guide covers setting up a fresh new Adobe Connector in the below-required systems:
  •  Fluent OMS information details (account credentials, client secret, etc.)
  • Adobe Commerce
• This guide does not cover:
  • The standard setup of Fluent OMS, this guide is explicitly for the Fluent Adobe Connector configuration.
  • Detail on how to migrate an existing Adobe Commerce to use Fluent OMS.
• Please get in touch with Fluent Expert Services for guidance on any migration.

• This guide shows you how to seamlessly switch Retailers within the Fluent Order Management System web app.
• This guide is aimed at multi-retailer Admin users.

• Understanding the default Order and Fulfilment Types
• Users with SETTING_VIEW, SETTING_CREATE, and SETTING_UPDATE permissions can add new order and fulfilment types to Fluent Store.
• A guide to add a new Order Type to customise the Fluent Store
• A guide to adding a new Fulfilment Type to customise the Fluent Store

We are here to help and there are several ways how to get in touch with our team. Read on if you'd like some help!

• There are several channels to reach out to get help, such as the community #partner_support slack channel, our support ticket system, or via email, depending on the help you need.
• To get help quickly, reach out via the appropriate channel and supply as much context as possible.

•  OOTB, the create wave button on Fluent Store will always be displayed whether there are pending fulfilments or not.
• It’s possible to only display the button when there are pending waves when a condition is added.

Developers can add new components to OMX via the registries.

There are three available:

• Component Registry - for standard in-page components
• Field Registry - for interactive form field components
• Template Registry - for adding new template helpers

You will learn how to design workflows, what they consist off and what are the best practices. 

• The following topic covered when comes to designing workflows:
  • Workflow Boundaries
  • Workflow Patterns
  • Flow Control
  • Cross-Retailer
  • Cross-Workflow
  • Workflow Versioning
  • Defining Rulesets
  • Workflow Settings

Fluent Commerce can post standard webhooks to a configured endpoint so that the third-party system can be notified or react to the provided event. For example, common webhook scenarios include order status updates and shipping notifications.

• A webhook is a way for Orchestrated Workflow Logic to call back to an external application.
• Fluent Commerce provides some standard webhooks as Rules within the Rule Library for common third-party integrations.
• Since the payload and HTTP request cannot be customised, it is rarely necessary to implement a custom rule to send a webhook

• It’s possible to add settings to a workflow via Json in order to improve the performance and the functionality of the workflow.

This article describes settings that can be added to a Workflow. 

• Explore the Workflow Settings available

Please refer to this agreement to confirm contact points, SLAs and escalation paths.

• Overview
• Severity Definitions
• Service Level - Response and Resolution
• Service Level - Availability
• Issue Submission Process

A topic on how to run Inventory batches in the OMS. 

The Inventory module of the Fluent Web app provides comprehensive inventory management capabilities:

• Inventory visibility
• Inventory allocation
• The total quantity of stock for a specific item (stock on hand(SOH)) and the status of that inventory
• Available to promise inventory levels
• Inventory buffers to reduce overselling of products

• The Fluent Web app's Inventory module offers a comprehensive suite of capabilities, including inventory visibility, allocation, total stock quantity (stock on hand), inventory status, available-to-promise levels, and strategically implemented buffers to prevent product overselling.
• The module is equipped with various configurations, such as Inventory Catalogues, Control Groups, Virtual Catalogues, Cross-Catalogue Views, and Location Inventory Views, providing users with versatile tools to tailor their inventory management approach according to specific business needs and scenarios.

This document is intended to introduce the Inventory Feeds feature to Customers and Partners. This page will describe the Inventory Feeds feature and how they fit within the Fluent Big Inventory Product and will direct the reader to resources describing how to use Inventory Feeds.

This document will describe how Inventory Feeds work and guide users through understanding any prerequisites to integrate with Inventory Feeds.

• Inventory Feeds will export a view of inventory data from the Fluent platform into a Customer environment
• The schedule of the export is configurable based on the Customer requirements
• The exported data is ready to be synced with any further systems within a Customer ecosystem to provide real time inventory availability

List of Fluent Commerce sub-processors.

• The list below contains sub-processors for Fluent Commerce's generally available products and services
• This list is effective as of 15 February 2022

The Availability Module facilitates the presentation of Available-to-Sell (ATS) and Available-to-Promise (ATP) data on the Product Detail Page (PDP), Product Listing Page (PLP), and Checkout pages within an e-commerce platform, for instance.

• Available to Sell (ATS) is the quantity of inventory that is immediately available in stock and can be sold to customers. It is usually calculated based on the stock on hand and safety stock buffers.  
• Available-to-Promise (ATP) is the quantity of a product that a company can promise to deliver to customers by a specific date based on the current inventory levels, incoming inventory, production schedules, and outstanding orders.

The Order Management Experience (OMX) Design System provides guidelines for delivering a user experience tailored to the Omnichannel Order Management space. This article will describe the foundations of the Design System, including color palette and typography which make up the overarching design theme of the Fluent Commerce platform. 

The document describes the best practice for onboarding and offboarding users.

• A common practice on how to manage SSO user for the following process:  
  • User Onboarding
  • User Off-boarding

• A new Workflow creation requires the correct permissions for the user, and a valid workflow JSON file (schema,

  `entityType`

  and statuses/rulesets).

An overview of how webhooks work in Fluent Commerce, how they are signed, and validated, and what public keys are used.

• For security purposes, Fluent Commerce cryptographically signs each webhook request with a private key before sending it to the target endpoint.
• Every webhook request from Fluent contains two custom headers

  `flex.signature`

  (MD5withRSA) and

  `fluent-signature`

  (SHA512withRSA). 
• You can use standard cryptography (e.g. in Node) or built-in Java functions to verify webhook calls.

• A step-by-step guide on how to add a custom help menu to the header to serve as inspiration for other custom components that can be added

This article provides an overview of methods for configuring components within the UX framework. Customization is possible through configuring the various types of components, such as sub-components, wrapper components, and context components. Read on to find out how to use the above approaches.

• Core components are highly extensible through configuration; check if your requirements can be met by updating the manifest or component properties (props in the configuration).

• `DynamicAttribute`

  values in core components allow for the creation of small, specialized sub-components that enhance functionality.
• Wrapper components can be used to modify existing components' props or styles, enabling more complex customizations beyond basic configurations.
• Context components can override default data handling by performing additional queries, but be cautious as this can impact performance.

The UX framework provides some "component primitives" that can be used to build more complex components on top. The advantage of this is that these utility components:

• provide a consistent look and feel
• update according to theme options
• enable mobile responsiveness

The OMX UX Component Library contains a suite of UI Components, ready to be configured and used in Fluent Web Apps.  The Library contains Foundation, Content, Layout,  Interaction and Field Components.

• Foundation Components, such as Page Components which form the base of a screen
• Content Components for displaying data and media
• Layout Components for structuring pages
• Interaction Components for capturing user input, and 
• Field Components which are automatically rendered in User Action forms.

• It’s possible to enhance Service Point to show order items from the current order on the collection screen.
• This can be achieved by adding a specific setting and making sure that the user’s role has the appropriate permissions.

• step-by-step guide on how to install modules into your OMS sandbox

The Fluent platform generates unique IDs internally, which serve as the primary key for each new record. They are unique and enforced to avoid ambiguity. Users cannot set these via API. Whereas refs are typically from third-party integrations, they represent external system IDs and occasionally are generated internally with guaranteed uniqueness. It is the integrator's responsibility to ensure refs are unique in Fluent Commerce.

• IDs are generated by the Fluent platform and are guaranteed to be unique at the time of creation. 
• Refs are typically values passed in via third-party integrations and should represent the IDs from external systems.
• Despite the system not enforcing the uniqueness of refs, it is highly recommended to have unique refs for all entities. Every ref should be unique within it's nearest container, for example Retailer refs need to be unique across all . Catalogue or Account.
• If your refs are not unique then there are API's that will not work as expected. This means that our reference modules may not work as expected if you set ref's as non-unique values.

Component SDK provides a collection of React hooks to allow custom components to access the core UX framework functionality.

The SDK includes Typescript declaration files that tell your IDE and compiler what these look like and that they are available on the global scope.

• Component SDK provides a collection of React hooks to allow custom components to access the core UX framework functionality.
• The useAuth can access user session information.
• The useEnv can access the current environment details.
• The useI18n can access the global language to translate static labels
• The useSetting / getSettings can access the current account setting values.
• The useQuery/getQuery and useRest/getRest to retrieve data from OMS.
• The useData hook provides direct access to the page query response and variables.

A best practice guide of creating customer entity.

• A user guide on how to manage customer entities in OMS.
• Best practice guide on creating Customer entity in OMS before the createOrder mutation.
• Relationship between user entity and customer entity.

• Settings Template

The SDK's handling mechanism involves loading and prioritizing handlers during server startup. It provides transparency with special spring actuators for listing active routes and handlers. Message handlers follow error-handling protocols, while job handlers process data polled from external systems. Configuration handlers react to changes, and the SDK supports various ways of receiving messages from external systems.

• Handler Prioritization: Customize execution order by assigning priorities during startup.
• Message Handling Protocols: Follow specific rules for retries, dead letter queue forwarding, and managing multiple items within a message.
• Implementation Guidelines: Adhere to guidelines, use annotations like @HandlerInfo and @Component, and configure routes. Extensibility is seen in job handlers, configuration handlers, and product availability enrichments.
• Receiving External Messages: Support diverse methods, including HTTP requests with authentication filters and external listeners like SQS and Kafka. Custom controllers enhance authentication through the SDK's security module.

• Predefined Filters: Provide a way to access commonly used search parameters with a single click, enhancing the user experience.
• User Efficiency: Predefined filters are designed to save time and streamline workflows.
• Customization: Users may have the ability to create and save their own filters for recurrent use (via manual Manifest changing).
• Consistency: Predefined filters ensure that the same criteria are used for searching, leading to consistent results.
• Learning Curve: New users can quickly become proficient in finding the information they need due to the intuitive nature of predefined filters.
• Integration: These features should seamlessly integrate with the user interface for maximum effectiveness.

Fluent Commerce is a flexible platform with two core components: the UX component for rendering UI and the Workflow Framework responsible for order processes. The platform comes with a range of SDKs for custom development and a set of reference modules.

The OMX UX Framework, or Mystique, delivers configuration-based solution implementation for UIs (Web Apps) that understand the Fluent Platform. It enables UIs to react to changes within workflows and provides best-in-class user experience and design. Web apps can be built using code-free configuration, utilising a rich library of ready-to-use UI Components.  Customising UIs to meet specific business requirements using Component SDKs is also possible.  Configuration is managed in a JSON document called the OMX Web App Manifest.  

• Code-free configuration through the Manifest document.
• Dynamic user management experience.
• Configurable left-navigation menu items.
• Dynamic views, labels, and fields based on configuration and GraphQL queries.
• Dynamic and contextual user actions based on workflow configuration.
• Create and edit all entities, including non-workflow entities.
• Customise UIs to meet specific business needs and processes.
• Configure contextual actions based on roles and process states.

The Wave Dashboard Template is a preconfigured UX Template used within the Fluent Store Web App.

• Provides an overview of Store Waves, including orders awaiting pick, in-progress orders, and completed waves.
• Configurable dashboard tiles and tabs for real-time store performance and bottleneck visibility.
• Supports configuring Pick & Pack SLAs, collection reminders, and exception management.

The Pick by Expiry Template is a preconfigured UX Template used within the Fluent Store Web App.

• Key Features on how to configure the Pick Screen
• Lis of common Use Cases
• Template Configuration details

The Pack Template is a preconfigured UX Template used within the Fluent Store Web App

• Ensure Wave Dispatch User Action is configured in the Location Store Workflow.
• Utilize Wizard Page components from the Component Library.
• Activate Pack screen when Wave is in PACK state.

• Understanding the Market: Recognizing the importance of Cash on Delivery (CoD) in markets like India, where it is a preferred payment method.
• Global Adaptability: The workflow's design serves a global audience, providing a template that can be customised for regions where upfront payment is not the norm.
• Seamless Integration: Ensuring the CoD process is smoothly incorporated into the existing order journey to enhance customer experience.
• Operational Efficiency: Streamlining the CoD transaction to ensure quick and secure payment collection at the point of delivery.

General Principles and the Features of the SDK

• General Principles
• Features of the SDK
• Developer setup

The OMX UX Framework, or Mystique, delivers configuration-based solution implementation for UIs (Web Apps) that understand the Fluent Platform. It enables UIs to react to changes within workflows and provides best-in-class user experience and design. Web apps can be built using code-free configuration, utilising a rich library of ready-to-use UI Components.  Customising UIs to meet specific business requirements using Component SDKs is also possible.  Configuration is managed in a JSON document called the OMX Web App Manifest.  

• Dynamic user management experience.
• Configurable left-navigation menu items.
• Dynamic views, labels, and fields based on configuration and GraphQL queries.
• Dynamic and contextual user actions based on workflow configuration.
• Ability to create and edit all entities, including non-workflow entities.
• Customise UIs to meet specific business needs and processes.
• Ability to configure contextual actions based on roles and process states.
• Enables centralised management of orders, products, inventory, fulfillments, and locations.

• Using Chrome developer tools and IDEA Webstorm to debug Fluent component SDK
• This article will only work for Chrome desktop browser

Getting Started Guide for Component SDK

• Download the Component SDK
• Developer setup requirement
• Component SDK Unit testing example

The Returns feature is available for any OMX web apps. The following guide will step through the areas of configuration to enable the Returns reference solution.

• A step-by-step guide to enable reference return functionality.
  • Settings setup
  • Create & Assign the Instore Return Role
  • Workflow Configuration (Order, returnOrder and Billing)
  • Manifest Changes for Fluent Store and Fluent OMS

• To enable cancelling orders via the UI the cancel order ruleset needs to be used
• Update the mystique manifest to show the list action.

• Order Revision implementation can be done either from the UI or via Postman.
• This implementation requires workflow changes and adding a few specific settings. The detailed process is covered in this article.

• Order Revision User Guide

• step by step to teach you how to add order attribute values into the PACK screen in STORE APP
• the byName function will allow OMS to display the specific attribute value on the UI.

• Address Validation: Ensure that the address entered by the user is valid and correctly formatted to avoid shipping issues.
• Default Address: Allow customers to set a default address for a quicker checkout process.
• Edit Capability: Provide an option for users to edit customer address details in case of errors or changes.
• User Experience: Design the add and edit address process to be user-friendly and accessible, with clear instructions and error messages.

• Quick Search Functionality: Enables users to find information rapidly by typing keywords or phrases.
• User Efficiency: Quick search is designed to save time and streamline workflows.
• Learning Curve: New users can quickly become proficient in finding the information they need due to the intuitive nature of quick search.
• Integration: These features should seamlessly integrate with the user interface for maximum effectiveness.

The Extend Knowledge Content does not form part of the Fluent Order Management Platform or its Documentation, and its use is subject to the terms and conditions below. Extend Knowledge Content is designed to demonstrate how to extend the capabilities of the Fluent Order Management Platform through use of its many extensibility features and tools. Extend Knowledge Content is provided for illustrative purposes only, is not supported or maintained, and may become outdated. Please read the full document thoroughly before using any of the Extend Knowledge Content.

• Extend Knowledge Content does not form part of the Fluent Order Management Platform or its Documentation.
• Extend Knowledge Content showcases the ‘art of the possible’ when using the Fluent Order Management Platform’s many extensibility features and tools to enable a range of use cases that cannot otherwise be met using the standard capabilities of the Fluent Order Management Platform.
• Use of the Extend Knowledge Content is governed by the Extend Knowledge Terms and Conditions.

Exponential backoff is a standard error handling policy for network communications such as the Fluent APIs. 

Exponential backoff involves a client periodically retrying a failed request over an increasing amount of time.

• Retries & Exponential Back-offs

• Extend the Order Module schema
• Modify the Rule for Return Order creation and the Order Workflow Return Order Ruleset
• Update the Order Management Manifest

• This article gives System Integrator (SI) Partners and Businesses a high-level idea of where new features can be built on top of the OMS reference solution to support the customer's requirement within Fluent OMS.
• This idea/solution will provide a new feature where the Store User can take a photo of the returning item and attach it as part of the returnOrder entity.
• The source code will not be provided in this article.

• This article gives System Integrator (SI) Partners and Businesses a high-level idea of where new features can be built on top of the OMS reference solution to support the customer's requirement within Fluent OMS.
• This idea/solution will provide a new feature where the Store User can enter the rejection reason code during the Pick Confirm Process.
• This feature allows specifying the rejection reason for fulfillment on the picking step of wave processing. The user can select the rejection reason code when the picked item list is confirmed as the first step of wave processing.

• This article gives System Integrator (SI) Partners and Businesses a high-level idea of where new features can be built on top of the OMS reference solution to support the customer's requirement within Fluent OMS.
• This idea/solution will provide a new feature where the Store User can enter the rejection reason code during the Pick Confirm Process.
• This feature allows customer service to reroute an existing

  `fulfilment`

  to a specific location that can fulfill the order.

• This article gives System Integrator (SI) Partners and Businesses a high-level idea of where new features can be built on top of the OMS reference solution to support the customer's requirement within Fluent OMS.
• This idea/solution will provide an extended new feature where the Store User can validate the Customer ID during the Customer Collection Process.
• New custom UI components and rules are needed to capture the user input and confirm the selected articles in the UI user Action screen.  Then, the store/business can track and trace the proof of the shopper's collection.
• Due to security reasons, the shopper's sensitive personal information should not be stored within Fluent OMS. Therefore, the proof of collection should be stored at a third-party storage.

• This article gives System Integrator (SI) Partners and Businesses a high-level idea of where new features can be built on top of the OMS reference solution to support the customer's requirement within Fluent OMS.
• This idea/solution will provide an extended new feature where the Store User can update the Store inventory through the UI to ensure the OMS has the most accurate product inventory.
• New custom UI component and rules to capture the user input in the UI user Action screen. Then, the backend will create a new Inventory Quantity entity and update the Inventory Position and the downstream workflow.

• Comprehensive Data Entry: Ensure that all necessary customer information is captured accurately to create a complete profile. This includes personal details, contact information, and any specific requirements or preferences.
• Validation and Verification: Implement validation checks to prevent errors during the data entry process. Verify that mandatory fields are not left blank.
• User Experience: Design the customer creation process to be user-friendly. Provide clear instructions and feedback during the process to enhance the user's experience and minimize the likelihood of errors.

• Data Modification: Ensure that users can modify customer data, including the ability to correct typos in existing information.
• Error Handling: Implement error handling procedures in case the edit fails or invalid data is submitted.
• User Experience: Aim for a seamless and intuitive editing process to minimize the risk of user errors.

• Properties of CUSTOM_PICK_LIST_SORT_CONFIG Setting

A network is a collection of physical fulfillment or collection locations such as stores, warehouses, distribution centres, or even lockers. Fluent Retail allows users to manage their network from a centralized position with control of network-specific order logic via custom rules. The Network API defines the creation and addition of networks as well as retrieval of details pertaining to a network and updating the parameters of a network.

There are three default networks,Collection Point Network,C&C Network, and Home Delivery Network. These can be extended and configured with subnetworks.

• Overview
• Network Properties
• What you can do with Network
• Response on Failures

An Order transaction defines the payment or refund details associated with an Order.

• Return Transaction Properties
• What you can do with Transaction
• Response on Failures

An API Order transaction defines the payment or refund details associated with an Order.

• Order Transaction Properties
• What you can do with Order Transaction
• Response on Failures

Settings API is used to set configurations used by the platform, accounts and retailers. See Commerce Apps documentation for specific settings keys and their function.

Configurations have a hierarchy of contexts in which they can be applied. GLOBAL, ACCOUNT and RETAILER are the levels in decreasing order of context, where GLOBAL is reserved by platform use and ACCOUNT and RETAILER are available to developers to override the GLOBAL defaults.

• Setting Properties
• What you can do with the Settings API
• Response on Failures

SKU is the specific item that can be purchased by the customer. SKU has a unique set of attributes such as colour and size. Product is the parent of SKU and must be created before the SKU API can be used.

• SKU Properties
• What you can do with SKU
• Response on Failures

An order is a customers request to purchase one or more items from a retailer. An order is created when a customer completes the checkout process against a Retailer Products.

• Order API is used to create an order in the system. 
• Customer and Products information should be available.
• Order details like, order items, transaction details, fulfilment choice, customer and delivery information are all required to create an order.

A Product is a conceptual entity with a product description and multiple sets of attributes. A unique combination of the Product attributes defines a SKU which is an item for sale.

• A product can have multiple SKUs associated with it and will have one or more categories associated.
• The properties available in the Product entity which can be updated and retrieved through the APIs.

An Order Item is the SKU purchased by the customer on the Retailer's online store. There can be one or many Order Items within an Order. Each order item has an associated quantity and paid price.

• Order Item Properties
• What you can do with Order Item
• Response on Failures

A Location is any place where an order can be fulfilled and/or collected by the customer. Locations can include a store, warehouse, drop-ship vendor, lockers, or a third-party logistics or collection point.

• Overview
• Operations
• Models

The Fulfillment Options API retrieves the proposed Fulfillment Options for the customer order.

• Fulfillment Options Properties
• What you can do with Fulfillment Options
• FulfilmentOptions.FulfilmentOptionsAddress
• InventoryPosition.ProposedFulfilment.Item
• Attribute
• FulfilmentOptions.UnfulfilledItem
• FulfilmemntPlan
• FulfilmentPlan.Fulfilment
• FulfilmentPlan.Fulfilment.FulfilmentItem
• Exception
• Response on Failures

A fulfilment represents one or more items in an order that need to be picked & packed for the customer. A fulfilment is assigned to a location based on the retailer's fulfilment rules and available inventory. A fulfilment will have an origin (from) and destination (to) associated with it.

• Fulfilment Properties
• What you can do with Fulfilment
• Response on Failures

The Consignment API is responsible for retrieving and updating the status of fulfilment's managed through the Fluent Retail platform. Users can also add consignment details to articles on fulfilment's booked outside of the platform through the Consignment API.

• Consignment Properties
• What you can do with Consignment
• Response on Failures

A Comment provides an additional piece of information to the entity it is related to. An Order and Return can contain multiple comments associated with it.

• Comment Properties
• What you can do with Comment
• Response on Failures

The Category Batch API is used to create a Category using the Fluent Commerce Batch framework.

• Category Batch Properties
• What you can do with the Category Batch API
• Respose on Failures

• Step-by-step configuration guide to enable Returns functionality in ServicePoint.
• The configurations include the following:
  • User Role assignments
  • Settings
  • workflows

• A Client Business Requirement:
  • The returnOrder created by Store Staff must require a Manager’s Approval
  • 2-step process to ensure the customer is refunding the right products/amount. This is done through workflow and roles/permissions modifications.

A return is a customer's request to send back one or more items against an Order from the Retailer. A return can exist with or without the original order reference. If the original order reference exists, the return can contain the details of the returned items, the reasons, and the amount to be refunded. A return also could represent items within an original order that could not be fulfilled or has been canceled by the customer and requires a subsequent refund. Through the type of return, we can identify the context of the return, i.e., if it is a customer return, cannot fulfill or cancel.

• The properties are available in the Return object
• This Return object can be updated and retrieved through the API

• Drawers can be added in any mystique components by modifying the mystique manifest.
• The drawer’s custom data source can be defined via queries and variables.

• A setting can be added or modified directly via UI.
• A new setting requires its name, context, the identifier of the context, the value, and the value type.

• A Workflow can be updated as long as the user has the right permissions.
• A Workflow can be updated via the IMPORT/EXPORT button or via API.

Connect SDK is the launchpad to connect any external system with Fluent Commerce in a predictable way. It reduces implementation timelines and costs so customers can see faster ROI. Technically, Connect SDK is a Java Maven Archetype and Java Library Utils that form a toolkit for building Spring Boot micro-service applications that communicate with the Fluent Order Management System and any external system.

• Connect SDK helps partners and customers quickly start building ad hoc connectors with consistency, better security, and short implementation time.
• A deployed Connect SDK-based integration simplifies middleware setup and support 
• It offers incredible flexibility in building synchronous and asynchronous endpoints with a common credential, logging, and configuration interface
• In regards to hosting responsibility, any connector built using Connect SDK is cloud-agnostic, and the integration layer is still owned and maintained by the solution integrator, becoming part of the project codebase.

• The Connector SDK generates a blank Maven starting project for your custom integrations.

The Rules SDK is a Java based software development kit, which provides Java developers with a toolkit for creating custom Rules for the Fluent OMX Workflow Framework.

The Workflow Framework is a highly configurable and extendable part of the Fluent OMX Platform, which facilitates orchestration of business logic for the Fluent Order Management System.

• A step-by-step guide to deploy your custom Rules Plugin and run the project.
• A fully setup and functioning Fluent Account is required.
• An API User with the 

  `DEVELOPER`

   role (Note: If using a Training Account, the Account Admin already has this role applied)

• A step-by-Step guide to creating your first custom Rule to log "Hello World"

• A step-by-step guide to creating Rule SDK Plugin Project.
• The Rules SDK comes with a Maven Archetype for generating a new Rules Plugin Project, and a handy script file to run the project generation steps.
• A fully setup and functioning Fluent Account is required as of this activity.

• Step-by-step guide to setup Rule SDK in your local Environment. 

Retrieve an order by

`id`

• Sample query on how to use flags as part of the query parameter

Retrieve inventory position, variant product, virtual base position and virtual aggregate position records based on input parameters.

• Sample GraphQL query that extracts inventory position, variant product, virtual position and virtual aggregate position. 

Sample Virtual Position Queries that can be used on a daily basis

• Query sample on extract virtual position by updatedOn

Sample Product Queries that can be used on a daily basis

• Sample Queries on the following:
  • Variant Product (SKU) by Reference
  • Variant Product (SKU) by Details
  • Variant Products (SKU)

Sample Inventory Queries that can be used on a daily basis.

• An actual example of a GraphQL query on the following:
  • Inventory Position by Details
  • Inventory Position by Reference
  • Inventory Positions
  • Inventory Quantity Updated

The GraphQL Plugin for IntelliJ provides useful features for working with GraphQL:

• Schema Introspection
• Auto-complete
• Syntax highlighting and validation
• Query and Mutation execution

• Collection of GraphQL samples handy for accessing Fluent OMS

The 

`run`

• Rules are the smallest building block for logic, it is important to remember that this method should be implemented to perform 1 simple task
• You may not need all of these steps within your Rule. Some rules produce an action without a condition. Some rules do not need to query additional data. Make sure your Rule is as lean as possible, and simple to read.
• The Rubix Plugin SDK provides a useful Util class to facilitate validation: RuleUtils
• You can retrieve the data by using Context / Entity
• Typically, a Rule will produce an output action.

This page describes the best practice testing approaches for rules and plugins.

• As per standard industry practices, rules should be tested as part of the development cycle, on the developer's local machine.
• Testing on Sandbox after local testing has been completed.

• the best approaches to debugging your custom rules and plugins
• Debugging locally in your IDE can be done as per standard Java practice while running rules in Unit Tests or with the TestExecutor.
• Debugging on Sandbox - The primary mechanism for debugging on a deployed environment is by activity tracking or Orchestration Audit Events. You can easily query these for any context via the Event API, or the Admin Console.

Rule Actions are the single output of a Rule.

Rules do not perform actions directly. Rather, they inform the Workflow Engine what it should do as a result of the rule execution. The Workflow Engine interprets the specific Action produced by the Rule and handles it appropriately.

Most Actions are queued internally within the Workflow Engine and executed at the end of the current process.

• There are 4 types of Actions available to produce from a Rule:

  • `SendEventAction`

  • `MutateAction`

  • `WebhookAction`

  • `LogAction`

Accessing the Workflow Builder

• The Workflow Builder UI is accessible through the Admin Console (not available on Fluent OMS).
•  In order to add or edit an existing WF from the UI, you would need to have the right permissions. 

This section provides Rules SDK reference and guidelines for Writing Rules.