Frameworks

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.

Sourcing Criteria determine which eligible Locations are best once a Strategy applies. You’ll learn how to configure, sequence, and extend Criteria so your prioritization is predictable and explainable across business scenarios.

• Define prioritization with configurable Sourcing Criteria that score and order candidate Locations
• Reference Sourcing Criteria schema is global and can be extended or overridden with customer-specific definitions for tailored Strategies
• Criterion Utilities provide reference functions, normalization, and a registry/annotations model for custom extensions
• Configure all Criteria with clear names, parameters, and evaluation order to ensure accurate and predictable ranking

Sourcing Conditions let you control how Sourcing Strategies are applied within the Responsive Sourcing Framework. After reading, you will understand how to configure and extend them to adapt sourcing logic for specific Sourcing Requests.

• Define your sourcing logic with configurable Sourcing Conditions that evaluate Sourcing Requests and return true/false outcomes
• Reference Sourcing Conditions schema is global but can be extended or overridden with customer-specific definitions for tailored Strategies
• Condition Utilities provide reference function, default operators (equality, comparison, membership, existence), and support custom extensions
• All Conditions should be configured with clear naming and parameters to ensure accurate and predictable evaluation

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.

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

• The Admin interface helps in managing users, retailers, settings, etc.
• Depending on the configuration, it can contain any combination of the following: Retailers, Carriers, Users, Roles and Permissions, and Settings.

The `util-sourcing` library is a comprehensive collection of utility functions designed to minimize the overhead and complexity of writing sourcing logic in your Fluent Commerce rules.

Prerequisites

These articles assumes you're familiar with:

• Java
• Maven
• JUnit

The `SourcingUtils` class in the `util-sourcing` bundle is the main utility class that orchestrates the entire sourcing process within a Rule. It provides core helper methods such as loading a Sourcing Profile, initialise the Sourcing Context, and trigger the execution of the sourcing logic configured in the profile. Each stage supports multiple customisation points throughout the process.

• Main Orchestrator: Central utility class that coordinates all sourcing operations from a Rule.
• Strategy Evaluation: Evaluates and applies sourcing strategies based on business rules.
• Plan Generation: Creates optimal sourcing plans for order fulfillment

The `OrderUtils` class in the `util-sourcing` is a utility class that provides order-specific utilities for sourcing operations. It handles order-related sourcing operations including fulfillment creation, fulfillment type determination, and order item management.

• Order-Specific Operations: Handles order-related sourcing operations.
• Fulfillment Creation: Creates fulfillment records based on sourcing plans.
• Fulfillment Type Management: Sets fulfillment types based on business rules.
• Order Item Management: Manages order items and their allocation to fulfillments.

`SourcingContextUtils` in the `util-sourcing` is a utility class for managing sourcing context and data loading operations. It provides methods to create and populate sourcing contexts with order details, unfulfilled items, and supporting data required for sourcing decisions.

• Context Management: Creates and manages Sourcing Context for the sourcing process.
• Data Loading: Handles loading of order, item and required information.

The `LocationUtils` class in the `util-sourcing` is a utility class that provides utilities for location-based sourcing decisions. It handles location-specific sourcing logic including distance calculations, location availability checks, and provide location-based caching optimization.

• Location-Based Decisions: Handles location-specific sourcing logic.
• Distance Calculations: Calculates distances between locations for proximity-based sourcing.
• Location Availability: Checks if locations are active and available for sourcing.
• Caching Optimization: Provides location-based caching optimization.

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.

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.

• Webhooks enable real-time communication between Fluent workflows and external systems, eliminating the need for frequent API polling.
• The `sendWebhook` rule simplifies outbound communication by passing essential data that external systems can use to fetch additional details.
• Typical use cases include order status updates, shipping notifications, payment captures, and stock transfers.
• Webhooks should not be used for Inventory domain operations due to scalability concerns, performance impacts, and stability risks, so use Inventory Feeds instead.
• In rare cases where inventory-related webhooks are required (e.g., conditional stock change notifications), contact our team to discuss alternatives before implementation.

`DynamicEntityQuery`, with the help of the `DynamicUtils` class, automatically derives the correct GraphQL query operation for the primary Entity from the `RulesetContext`. It dynamically retrieves fields related to that Entity, removing the need for pre-compiled queries while preserving type safety and performance.

• Runtime Query Generation: Automatically builds GraphQL queries at runtime based on entity context, eliminating pre-compiled queries.
• Dual Usage Patterns: Type-based mapping with POJO classes for strong typing, or path-based queries for maximum flexibility.
• Universal & Validated: Works across different entity types with automatic schema validation and connection pattern handling.
• Flexible Access: Results accessible as typed objects, JsonNode, or flattened maps with Lombok integration.
• Connection Handling: Built-in support for paginated connections with automatic pagination handling via `queryList()` methods.
• Dynamic Mutations: Update entity properties dynamically using key-value pairs without pre-compiled mutation queries.
• Unified Data Access: `getJsonPath()` method provides unified access to both event and entity data using consistent path syntax.

This module will guide you through a hands-on lab where you can put all of the theory to practice and implement a simple Fraud Check solution.  This will cover adding new business logic to your workflow, including configuring some user actions to enable business users to approve or cancel orders that have been flagged as potentially fraudulent.

• For this lab you will need:
  • Postman application installed
  • A Fluent Commerce training account
  • A Postman environment file corresponding to your your Fluent Commerce account
• This Lab uses the fc_sports_admin retailer, please make sure to use this retailer when logging into your Fluent Commerce training account

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

The `RuleExecutor` is the primary tool in the `util-test` library for unit testing a single rule in isolation. It provides a builder-style interface for setting up a mock `Context`, executing your rule's `run` method, and asserting the results.

• Unit Testing Focus: `RuleExecutor` is the main tool for testing a single rule in isolation.
• Arrange-Act-Assert: It's designed to follow the clean Arrange-Act-Assert pattern. You use the constructor to arrange the context, call `execute()` to act, and use `getActions()` to assert the outcome.
• Rule Properties Configuration: Rule properties are passed as a `Map` in the `RuleExecutor.of(Class, Map)` constructor.
• Event Configuration: Custom events can be passed to the `execute(Event)` method.
• GraphQL Mocking: The `.mockNamedQuery()` method is a critical feature that allows you to provide predefined JSON responses for any GraphQL query your rule executes, enabling you to test different data scenarios without making live API calls.

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`

The Rules SDK Maven archetype will generate 2 sample Rules into the Plugin Project.

• DemoSendArbitraryEvent
• DemoAddAttributeToOrder

• DemoSendArbitraryEvent
• DemoAddAttributeToOrder

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.
• Entities have types and subtypes, types are rigidly defined, subtypes are more flexible.

While the `RuleExecutor` is perfect for unit testing a single Rule, the `WorkflowExecutor` is the tool of choice for integration testing an entire Workflow or parts of it. It reads a Workflow definition from a JSON file and simulates the Fluent Orchestration Engine by executing the sequence of Rules and Rulesets.

• Integration Testing Focus: `WorkflowExecutor` is the primary tool for integration testing an entire or parts of a Workflow.
• Workflow Simulation: It mimics the Fluent Commerce Orchestration Engine by processing an initial Event and then passing the resulting Event to the next Ruleset in the chain.
• Rule Mocking: The `.mockRule()` method is a powerful feature that allows you to replace a real Rule in the Workflow with a mock implementation. This is crucial for isolating the part of the Workflow you want to test.
• Targeted API Mocking: The `.mockNamedQuery()` method lets you mock a GraphQL query only when it is called by a specific Rule, giving you fine-grained control over test data for different stages of the Workflow.
• Consolidated Assertions: The `execute` method returns a single Context containing a consolidated list of all Actions from all Rules, allowing you to assert the final state.

This topic describes the cloud native nature of the Fluent platform

• Scalable
• Secure
• Versionless software
• Zero downtime

This page describes how Event Execution works.

• When an Orchestration Event is received by the Rubix Orchestration Engine, it initiates the Execution Context. The Execution Context includes the event and the entity specified by the event.
• Rubix will locate the Ruleset within the workflow that matches the signature of the event.

This article provides an example of how OMS selects the next best location for fulfilment

• The below example demonstrate the reference solution on how OMS selects the next best location for fulfilment.

The Fulfilment Choice Entity is used to store the shipment specific information:

• Delivery method
• Delivery or pickup address
• Delivery dates

• A Delivery method is determined for a Fulfilment Choice with a Fulfilment Choice type
• The Fulfilment Choice is an Orchestrateable Entity that allows to update and configure its sub-workflow to fit your specific requirements
• The Fulfilment Choice is an Order child entity that used to have one-to-one relations to it

This page provides all the information needed to design best practice Rules for your workflows. There are some important things to be aware of, so we highly recommend you thoroughly read through this page, and refer back to it regularly during development.

• providing a guideline of designing your Rule within Fluent
• It is important to keep the best practices and design principles in mind when designing your rules.
• understand types of analogies when come to building rules

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

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. 
• A selection of helper functions are also available to control and transform these values as required, for example, number, logic, i18n, array, date, and string functions.
• Additional options like TextOptions and ImageOptions provide styling choices.

Understand what are some general Rule principles.

• Fluent uses jsonPath, which is a period-separated string that describes a "path" between the entity being processed and a field on it or a related entity.
• In essence, this category of rules understands how to generate dynamic queries. 
• There are some helpers for traversing connection types, edges, and node fields, which will be automatically skipped, for example, `items.0.currency`  is equivalent to `items.edges.0.node.currency` 

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.

.

• .

The Workflow Engine (aka Rubix) is the engine that drives the Fluent platform. The Workflow Engine enables business process orchestration, workflow automation, and underpins the specific feature sets and functionality for each of the Fluent apps. Additionally, the Workflow Engine is built to be highly scalable, and provide high-performance workflow execution across any domain.

• Cloud-native, high availability, scale-on-demand workflow execution.
• Pre-built, customizable workflows delivering capabilities across each of the Fluent App domains.
• Rich Rule Library containing reusable rules across each of the Fluent Apps.
• Software Development Kit (SDK) and Developer Tooling, enabling the implementation of custom rules and integrations.
• Business Tools to manage, configure, and implement workflow and process automation.

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.

A workflow defines the orchestrated business logic to be applied to an entity on a given event. A workflow consists of Workflow States and Workflow Rule Sets for an Entity. The Workflow States specify the states that the entity could be in at any given point in time. The Workflow Rule Sets specify the business rules behind the progression of these states.

• This API method supports the creation or update of a Workflow within the Fluent Platform. 
• This API method validates the body of the request to ensure that the structure of the Workflow is correct. 
• Requests containing invalid Workflows will respond with an error.

In this document we will describe how to work with workflows and workflow fragments using the Fluent CLI. Then delve into how the tool is tracking the installed workflows, fragments in the workflow log.

Workflows are the backbone of the Fluent platform as they describe the lifecycle of an entity. Defining subsections or sub-processes within a workflow allows to manage and evolve them independently. Thus fostering loosely coupled and self-contained fragments with no duplication of shared or unchanged behavior of a baseline workflow.

On this page we will look at the different ways of structuring workflows into fragments and then how to optimally merge them into a final workflow that is used to orchestrate entities. Finally how to package both workflows and fragments into a module.

This section explains the settings used in Retailer context.

• This article lists retailer-level settings

The Pick and Pack feature suiteof the Store Fulfilment app allows stores to pick and pack online orders that are allocated to the store based on store inventory at the time of order creation. The Fluent Store’s interface is used to access the capabilities of the Pick and Pack feature suite.

• Adaptability: The process is responsive, ensuring a seamless experience on screens of varying sizes. Customization options are available through UI configuration or creating new components.
• Process Stages: The wave process involves creating a wave, picking order items, packing them, and booking carriers.Prioritization logic is applied based on factors such as expiration dates, order types, or delivery types.
• Efficient Picking: Picking orders is initiated by creating a wave, followed by selecting orders and using a user-friendly PICK component.Confirmation of picked items involves a final review, confirmation, and automatic rejection of unpicked items.
• Completion Process: The wave-picking process leads to the completion of fulfilling online orders in-store, providing a streamlined approach to order fulfillment.

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. 

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, Stock On-Hand (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 interfaces 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 Unified View of Inventory (UVOI) interface 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.

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

The Inventory interface 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 interface 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 interface 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.

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

• Fulfilment Options page
• Further Reading

• Fulfilment Options page
• Further Reading

Collections configuration contains:

• Collections List page
• Article Details page

• Collections List page
• Article Details page

Waves configuration contains:

• Waves List page
• Wave Details page

• Waves List page
• Wave Details page

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

This topic explains the dispatch process for Home Delivery (HD) and Click and Collect (CC) fulfilments using the ServicePoint console.

• Customer Collections

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.

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 UNCOLLECTED Articles feature of the Fluent Store module provides a capability for the retailers to set a collection SLA for the customers.

• This feature enables the retailers to set clear in-store processes and drive positive customer experience for the click-and-collect orders, in the scenarios where the customer fails to pick up the order.
• This also then enables the retailers to reuse the inventory after a certain period of time rather than waiting for the customer for longer periods.
• Having this extra tab of Uncollected articles in Fluent Store, allows the store users to differentiate between the articles awaiting collection for a longer time, and enables the store associate to help out the customers in case they fail to pick up in-store, which in turn drives positive customer experience.

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.

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. 

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

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 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.

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. 

The Store interface empowers retailers to enhance their operational efficiency by transforming stores into fulfillment centers and optimizing inventory management. This ultimately delivers 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.

Stores configuration contains:

• Stores page
• Store Details page
• Location Ref
• Created On
• Updated On

• Stores page
• Store Details page
• Location Ref
• Created On
• Updated On

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

•  Access to Fluent Training account is required

The Order Management interface is the central workspace for managing the order lifecycle. It brings together orders, customers, billing accounts, returns, and escalated fulfilments in one view. Orders provide access to details and fulfilments. Customers show records including accounts and order history. Billing Accounts manage financial operations such as invoices, memos, and payments. Returns track customer or system-initiated cases with refund details. Escalated Fulfilments highlight exceptions requiring action.

• The Order Management interface brings together orders, customers, billing accounts, returns, and escalated fulfilments in one place.
• It enables visibility and control over the entire order lifecycle, from creation through fulfilment, return, or escalation.

The `util-dynamic` library is a collection of utility functions that allow you to generate GraphQL queries and mutations at runtime. This enables the creation of highly configurable and reusable rules that can adapt to different needs without requiring code changes.

Prerequisites

These articles assumes you're familiar with:

• Java
• Maven
• JUnit

• Dynamic Queries: Fetch any field from an entity at runtime by providing a POJO class that defines the desired data structure, eliminating the need for pre-compiled queries.
• Dynamic Mutations: Update any field on an entity by passing a simple `Map` of key-value pairs, allowing for the creation of generic "field setter" rules.
• Dynamic Connections: Easily query and iterate over paginated one-to-many relationships (like `order.items`), as the utility handles all the pagination logic for you.
• Advanced JSON Path: A powerful `getJsonPath` method that can retrieve data from either the event or the entity itself, automatically determining the correct source.
• Enhanced JSON Utilities: This bundle includes a more advanced `JsonUtils` with powerful methods for navigating and transforming complex JSON structures.

The Fluent OMS Web App's dashboard interface serves as a central hub for monitoring and managing order activity and alerts.
It provides real-time visibility into key operational metrics — such as orders received, escalations, returns, cancellations, and pending actions — enabling quick responses to exceptions.

The dashboard is fully configurable to match business requirements. The numbers displayed represent the total records returned by these queries.

The `util-test` library is a comprehensive collection of utility functions, mock objects, and executors designed to minimize the overhead and complexity of testing your Fluent Commerce rules.

Prerequisites

These articles assumes you're familiar with:

• Java
• Maven
• JUnit

• `RuleExecutor`: The primary tool for unit testing a single rule in isolation.
• `WorkflowExecutor`: An advanced executor for integration testing an entire workflow from a JSON definition.
• `RuleContextGenerator`: The underlying builder for creating the mock `Context`, allowing you to define the event, entity, properties, and mock API responses for your test.
• `MockApiClient`: A critical component for providing predefined GraphQL responses, enabling you to test how your rule handles different API outcomes without making live calls.
• `TestActions`: A helper object that captures all actions your rule performs and provides fluent assertions (e.g., `sendEvent().assertCount(1)`) to easily verify the results.

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.

The Insights interface is a comprehensive repository of system Events, representing occurrences or triggers within the Fluent Platform. These Events, like changes in inventory position or entity states, act as notifications, prompting specific workflows and providing a dynamic overview accessible through a user-friendly configuration featuring the Events Search Form, the Events Search Results, and the Event Details Drawer for efficient information retrieval.

• The Insights interface is a comprehensive repository providing full information about system Events, representing occurrences and triggers that prompt actions or log activities within the Fluent Platform.
• With a user-friendly configuration, the module enables efficient interaction through the Events Search Form, providing filtered event searches and responsive Events Search Results. The Event Details Drawer ensures users can seamlessly access detailed event information without losing search results or experiencing delays in page navigation.

The Sources interface provides inventory and batch-processing metrics visibility, enabling data ingestion and processing efficiency tracking. It includes:

• Sources Dashboard – Monitors inventory updates, failure rates, and processing times.
• BPP Metrics Dashboard – Tracks batch-processing efficiency, showing processed, changed, and unchanged records with a date range filter of up to 31 days.

Both dashboards use structured data, support trend analysis within configurable time frames, and require METRICS_VIEW permission for access.

• Sources Dashboard provides real-time tracking of failed updates, update frequency, total received updates, and estimated processing times.
• BPP Metrics Dashboard enhances visibility into batch data ingestion by tracking record modifications.

The `JsonUtils` class in the `util-core` bundle provides a foundational set of helper methods for working with JSON data. Built on top of the Jackson library, these utilities simplify the conversion of raw JSON into usable Plain Old Java Objects (POJOs) and vice-versa.

JSON is a common data format found in event attributes, entity attributes, and setting values, and these utilities are essential for effective rule development.

• Universal Conversion (`anyToPojo`):This method can convert almost any Java object (especially `Map`s from event attributes) into a strongly-typed POJO, making the code safer and easier to read.
• POJO to Map (`pojoToMap`): The reverse of `anyToPojo`. This is essential for when it is necessary to need to add a complex object as an attribute to a new event.
• String to POJO (`stringToPojo`): Directly converts a raw JSON string into a typed POJO, which is useful when dealing with data from external systems or settings.
• Built on Jackson: The utilities are built on the Jackson library.

`DynamicUpdateMutation` automatically derives the correct update Mutation for the primary Entity based on the `RulesetContext` and then performs the update on one or more fields.

• Automatic Mutation Selection: GraphQL mutations are automatically selected from the `RulesetContext` based on entity type.
• Flexible Field Updates: Update single fields or multiple fields in bulk using simple key-value pairs.
• Type-Based Safety: Use POJO classes for strongly-typed updates with automatic field derivation.
• Runtime Validation: Built-in validation ensures only valid fields are included in mutations.
• Universal Application: Works across different entity types without requiring entity-specific mutation code.

The `LogUtils` class in the `util-core` bundle provides structured logging helpers that remove boilerplate code when using logging actions within your rules. These utilities make it easy to record key actions, errors, and checkpoints to the event log for debugging and auditing purposes.

• Standardized Logging: The utilities provide a standard, structured format for log messages, making the event log easier to read and search.
• Automatic Titling: The log entry's title is automatically generated from the rule's class name, ensuring consistency and saving you from writing boilerplate code.
• Simple Checkpoints: `logOnce` is an easy way to record a specific outcome or checkpoint in your rule's execution with a formatted message.
• Collections: `logAttributeCollection` is a convenient helper for logging a list of attributes.

The `SettingUtils` class in the `util-core` bundle provides a robust set of tools for retrieving configuration settings from the Fluent Commerce API. A key feature of this utility is that it automatically respects the platform's setting hierarchy, ensuring that the most specific setting value is always returned.

• Automatic Hierarchy: `SettingUtils` automatically respects the Fluent Commerce setting hierarchy (Location > Retailer > Account > Global), so you always get the most specific value without any extra work.
• Type-Safe Conversion: The `.as(MyClass.class)` method allows you to convert a setting's value to any type—from simple primitives (`String`, `Integer`) to complex POJOs—in a single, null-safe operation.
• Efficient Bulk Fetching: You can retrieve multiple settings (`getSettings`) or a group of settings by a common prefix (`getSettingsByNamespace`) in a single API call, which is more performant than fetching them one by one.

The `QueryUtils` class in the `util-core` bundle offers a set of functions to simplify GraphQL queries from within your Rules. These helpers make it easier to work with query results and handle common data structures like paginated connections.

• Type-Safe Queries: The `query` method is a wrapper that eliminates the need to manually cast GraphQL responses to the correct type, making your code cleaner and safer.
• Simplified Connections: `connectionToList` is a powerful helper that converts a standard GraphQL "connection" (with its `edges` and `nodes`) into a simple `List` of objects, removing a significant amount of boilerplate code.
• Inline Transformation: `connectionToList` can also accept a function, allowing you to transform the list of GraphQL nodes into a list of your own domain objects (POJOs) in a single operation.

The `RuleUtils` class in the `util-core` bundle provides helper methods to streamline the process of retrieving and validating Rule properties. Using these utilities helps ensure that your Rules are configured correctly and reduces the risk of runtime errors caused by missing or invalid parameters.

• Flexible List Properties: `rulePropAsList` reliably parses a rule property into a `List`, whether it's configured as a comma-separated string or a JSON array. This is ideal for properties that require multiple values.
• Configuration Validation: `validateRulePropsIsNotEmpty` provides a simple, one-line way to ensure that all required properties have been provided to a rule, preventing runtime errors.
• Fail-Fast Errors: When validation fails, the utility throws a `PropertyNotFoundException` with a clear error message. This stops the rule from executing with an invalid configuration and makes debugging easier.

The `EventUtils` class in the `util-core` bundle provides a set of essential helper methods to simplify event creation, modification, and forwarding. Using these utilities helps to eliminate boilerplate code and prevent common errors, such as forgetting to copy event attributes or improperly handling event schedules.

• Safe Event Handling: The utilities eliminate common errors by automatically handling attribute copying and schedule management when cloning or forwarding events.
• Immutability: `Event` objects are immutable. `EventUtils` methods always return a new event instance when a modification is made.
• Simplified Forwarding: Provides simple, one-line methods for common forwarding patterns, like cloning and sending an event immediately (`forwardInboundEventWithNewName`) or adding attributes (`forwardInlineEventWithAttributes`).
• Type-Safe Attribute Access: Use `getEventAttributeAs` to retrieve and convert an event attribute to a specific type (including complex POJOs) in a single, null-safe operation.

The Core Utility (`util-core`) is a standard library of utility functions designed to simplify and accelerate Rule development on the Fluent Commerce platform. It provides a foundational set of helper classes that address common development challenges - such as safely handling event attributes, retrieving and converting settings, logging consistently, and minimizing boilerplate code when forwarding events or querying data.

Prerequisites

These articles assumes you're familiar with:

• Java
• Maven
• JUnit

• Event Management (`EventUtils`): Simplifies creating and forwarding events, ensuring attributes are copied correctly.
• Rule Properties (`RuleUtils`): Streamlines retrieving and validating rule properties to avoid configuration errors.
• Query Simplification (`QueryUtils`): Eases the execution of GraphQL queries, especially for paginated data.
• Settings Management (`SettingUtils`) : Simplifies retrieving settings and automatically converts them from JSON to POJOs.
• Logging (`LogUtils`): Provides structured logging for easier debugging and auditing.
• JSON Handling (`JsonUtils`): Offers helpers for JSON serialization, deserialization, and comparison.
• Date Formatting (`GqlDateUtils`): A simple utility for handling GraphQL-compatible dates.

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.

The `GqlDateUtils` class in the `util-core` bundle provides a simple and effective set of functions for handling the specific date format required by the Fluent Commerce GraphQL API. The platform uses the ISO 8601 format (`yyyy-MM-dd'T'HH:mm:ss.SSS'Z'`), and this utility ensures you can easily parse and format dates to be compatible.

• GraphQL Compatibility: This utility ensures that dates are always in the precise ISO 8601 string format required by the Fluent Commerce GraphQL API (`yyyy-MM-dd'T'HH:mm:ss.SSS'Z'`).
• Parsing (`parseGqlDate`): Safely parses a string from an event or external system into a standard Java `Date` object, preventing common parsing errors.
• Formatting (`toGqlDate`): Converts a Java `Date` object into the specific string format required when passing dates as variables in GraphQL queries or mutations.
• Centralized Logic: Centralizes date handling to avoid bugs and ensure consistency across your entire implementation.

The `MockApiClient` is a critical component of the `util-test` library. It provides a mock implementation of the `ApiClient`, which is the interface Rules use to communicate with the Fluent Commerce GraphQL API.

By using the `MockApiClient`, you can test how your Rule behaves with different API responses without making any actual network calls. This isolates your tests, makes them faster, and allows you to simulate any scenario, including errors or empty data results.

• Test API Interactions: The `MockApiClient` allows you to test how your rule responds to different API outcomes (e.g., success, failure, empty data) without making live network calls.
• Isolate and Speed Up Tests: By mocking the API, your tests run faster and are isolated from network or environment issues.
• Executor Integration: You typically don't use `MockApiClient` directly. You use the helper methods on `RuleExecutor` and `WorkflowExecutor` (like `.mockQuery()` and `.mockSetting()`) to configure it.
• Full Coverage: It supports mocking pre-compiled queries/mutations, dynamic queries/mutations, and settings, giving you complete control over your test environment.

`DynamicConnectionQuery` automatically derives the Connection fields (arrays) for the primary Entity based on the `RulesetContext` and can dynamically load all connection items, with pagination handled internally.

• Automatic Pagination: `DynamicUtils.queryList` completely automates fetching paginated data from a GraphQL connection. You get a simple `Iterable`, and the library handles fetching subsequent pages in the background as you iterate.
• Lazy Loading: The utility is highly efficient because it uses a "lazy loading" approach. It only fetches the next page of data when you have iterated through the current one.
• POJO-Driven: You define the data you need by creating a simple POJO class. The utility dynamically builds the GraphQL query to fetch only the fields defined in your POJO.
• Server-Side Filtering: You can pass a `Map` of parameters to `queryList` to filter the connection on the server. This is much more efficient than fetching all the data and filtering it in your rule.

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.

Frequently asked questions around composing a workflow from workflow fragments.

• A collection of frequently asked questions and answers
• Elaborate on topics that do not neatly fit into the either the reference or long-form how-to's

Fluent platform functionalities are designed to be flexible by integrating with other APIs and Connectors and provides a real time view of the Inventory to the sales channels, enables integration with Warehouse Management Systems (WMS), carrier services, ERPs, etc.

• 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

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.

Product Master in Fluent OMS is defined in this hierarchy:

• Categories
• Standard Product
• Variant Product

The UPSERT_PRODUCT event will help the user to manage the product-related entities in the OMS.

• Standard Product Management outlines the features that are available in the reference workflows to manage any Standard Products within a Product Catalogue.
• When a Standard Product is updated there is a step specifically that will update the categories associated with that Standard Product. This is in the same flow as the Update Product, however, there is a distinct step in the flow where the category associations are updated.
• When a Variant Product payload is sent into the Product Catalogue via a UPSERT_PRODUCT event, the workflow will identify whether that Product exists or not and create a new Product if the given Product doesn't exist.

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

The values on the packing list.

• List of values on the packing list 

Understand the Master Buffer: a tool for final Available-to-Sell (ATS) quantity adjustments. This guide covers its function, configuration, and strategic applications. Using it offers precise, SKU-level ATS control, helping optimize stock, support promotions, prevent over/underselling, and align inventory with business goals.

• Key Points:
  • Final SKU-level ± adjustment applied after all quantity buffers to the aggregated SOH.
  • Directly modifies ATS; negative calculated ATS becomes zero.
  • Intended for strategic, deliberate application.

• Concluding ATS modifier: Applies a direct SKU-level override after all quantity buffers, just before ATS is calculated.
• Strategic & Product-Specific: Use it for deliberate, product-level inventory goals (like promotions or managing supply risks), not for general, location-based stock on hand buffering.
• Direct Impact on Sales: A positive buffer value increases ATS; a negative value decreases it. A resultant negative ATS will always be floored to zero.
• Use Deliberately & Review: Due to its significant impact, apply the Master Buffer thoughtfully. Document the rationale and regularly review its necessity.

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 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.

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

Mystique customizes the Fluent Admin Console UI, offering businesses development-free control over data presentation and business rules. This empowers them to configure user-centric functions for optimal value. A best-practice template is included. Mystique optimizes existing modules and enables new module creation based on entity perspectives. Please take a look at how it works below for configuration details.

• Features
• Benefits
• How it Works

The lab covers creating and managing different order types in Fluent OMS, simulating warehouse and store interactions, and enabling user actions for order cancellation. It focuses on Home Delivery (HD), Click and Collect (CC), split fulfilment, and enhancing workflows with user-configured actions. This lab guide users through hands-on exercises using Postman and the Fluent OMS interface.

• HD Workflow (Home Delivery): Process and fulfill home delivery orders via a warehouse.
• CC Workflow (Click and Collect): Understand click and collect orders and simulate stock management and pickup.
• Split Fulfillment: Explore multi-shipment scenarios when stock is insufficient at one location.
• Order Cancellation: Configure user actions for order cancellation with reasons before fulfillment starts.
• Postman Integration: Use Postman to authenticate, create orders, and simulate fulfillment steps.
• Workflow Customization: Enhance order workflows by adding business rules and user actions.

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.

The labs in this article will walk you through the following scenarios: GraphQL Introspection and Sending a Webhook

• Postman Configuration for auto-complete
• Access to mockable.io

The Setup and Configuration lab covers the step by step guide to setup a Retailer from scratch

• Stick to the following sequence while creating different entities

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 and Modules
  • Order management Experience (OMX)
  • Orchestration Engine and Cloud Infrastructure
• Together, they enable faster implementation, decrease development costs, and adapt quickly to ongoing changes.

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 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 section covers the scope of the Setup and Configuration course and the required prerequisites 

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

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.

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.

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

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 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` hook. We'll move away from relying on page query data and instead directly query the Fluent GraphQL API to retrieve a list of nearby locations with product stock. This involves defining data structures for query results, storing the query in a constant, and using the `useQuery` hook to execute the query with dynamic parameters derived from the form's context and the user's context (via `useAuth`). We will then render the results in a selectable list using radio buttons.

• 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`. We'll also cover best practices like using the `useEffect` hook for debugging.

• 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` hook to manage the state of pin interactions, specifically clicks. This will enable us to trigger actions when a pin is clicked, making the map more dynamic and responsive.

• 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` hook provided by the Component SDK, which grants access to crucial information about the currently logged-in user. We'll learn how to retrieve user details, including roles/permissions and the current location/retailer context. Specifically for location-context web apps like Fluent Store, we'll focus on using this hook to access the currently selected store's information, such as longitude and latitude coordinates, which will be essential for our map implementation.

• `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` interface with properties like `title` and `width`, and then configure these properties within the Manifest to dynamically control the component's appearance and behavior.

• 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 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` and its utility methods for generating formatted HTML.

• 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` event provided by the `FormFieldProps` to pass the structured data (containing `locationRef` and `quantity`) back to the form. This ensures that the user's input is included in the data posted when the form is submitted. We'll also demonstrate how to verify the output using browser developer tools.

• 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` and `quantity` and outputs a JSON object structured as required by the Ruleset. The lesson covers configuring the user action button, creating the custom field component using React Function Components and the `FormFieldProps` interface, registering the field, and updating the workflow definition to use the new custom field type.

• 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` and `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` that appears when a map pin is clicked, and how to fully configure the information displayed within it directly from the Manifest using Dynamic Attributes. This approach allows for flexible and data-driven component content.

• 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` hook provided by the Component SDK to retrieve configuration values from platform settings. This approach makes components more configurable and reusable across different clients and environments, simplifying maintenance and updates.

• 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.

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.

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.

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.

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 section outlines how the webapps interact with the modules

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

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 

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.

• 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 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.

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

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.

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

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

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

• Explore the Workflow Settings available

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. 

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.

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 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 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.

The `run` method is called by the Workflow Engine when executing each Rule in a Ruleset triggered by an Orchestration Event.

• 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.

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. 

Handy reference guide on how to display date time value on the UI

For Date format and conversion in UI, two functions can be used:

• `formateDate`
• `dateStringFormatter` (if true, then it will leave it as UTC timezone, else, it will convert to the user's browser timezone)

• Examples of how to display date time format in both OMS webapp and Admin Console

Fluent's Order Management Experience (OMX) framework comprises the UX Framework, Workflow Framework, and Connect Framework, which can be configured and extended (or customised) using software development kits (SDKs).

• Configuration of user interfaces via the UI Builder
• Configuration of workflows Workflow Builder
• Configuration of system integrations via Connector Builder
• Custom Rules (workflows), UI features, and integration are also possible via Rules SDK, Components SDK, and Connect SDK.

This document provides an overview of enhancing visual representation within a system by displaying coloured dots. These dots serve as a quick reference to different statuses of orders or items, making it easier to recognize and prioritize tasks at a glance. You will learn how to customize the appearance of these dots by changing their colour through hex codes and understand the default settings. The guide also includes recommendations for a colour palette to optimize the utility of status indicators.

• Feature Benefits: Utilize colourful dots to easily identify and prioritize different statuses.
• Status Color Palette: Use recommended hex codes to customize dot colours for optimal status indication.
• Configuration Guide: Follow step-by-step instructions to implement coloured status dots in your system. notify and prioritize different statuses.
• Default Settings: The system defaults to a grey colour for statuses that are not configured, ensuring consistency across various status indicators.
• Customization: Hex codes allow for full customization of dot colours to match your company's branding or to signify specific statuses.
• Visual Prioritization: Assign colours to statuses based on the level of urgency or importance, aiding in quick decision-making.
• Colour System Best Practices: Refer to the detailed best practices in the Colour section to effectively apply theming and enhance user experience.

This section covers the fundamentals of the Workflow Engine, provides an overview of the architecture, identifies key concepts, and prepares clients to build and use their workflows.

• How it Works
• Workflow Engine Architecture
• Workflow Builder
• Rules SDK
• Key Concepts of the Workflow Engine

This page provides a high-level understanding of what settings represent within the Fluent platform.

• Settings are leveraged to enable/disable specific features in the platform.   
• Settings are set in a specific context (Account, Retailer, Location/Agent).

A fulfillment represents one or more items in an order that need to be picked and packed for the customer. It is assigned to a location based on the retailer's fulfillment rules and available inventory. A fulfillment will have an origin (from) and destination (to) associated with it. A fulfillment containing unfulfillable items can be moved to the Escalated state. The Escalated Fulfilments page displays fulfillments in the Escalated state.

• Layout
• Fulfilment Details page

OMS Webapp's Users List page allows users to efficiently search and view existing users using a versatile filter component. The Users table provides essential user details, with a clickable Username link leading to a detailed User Details page displaying user information. The paging control at the bottom ensures easy entry management with customizable rows per page and intuitive navigation.

• `Type`: Understand the different types of users; ADMIN, RETAILER, API, and AGENT
• User Status: Be aware of the user status options, ACTIVE and INACTIVE, which reflect the user's current accessibility.
• Filtering Users: Utilize the filter component to efficiently search for users based on various criteria like username, status, creation date, and type.
• Roles and Permissions: Assign roles to users to manage permissions within the system, ensuring each user has the appropriate level of access.
• Paging Control: Utilize the paging controls at the bottom of the Users table to navigate between pages and manage the number of entries displayed per page, with options for 10, 25, or 100 entries.
• Deprecation Notice: Be aware that certain user types such as AGENT, SUPPORT, and others have been deprecated and should not be used for new users.

Federated identity management means establishing of a trusted relationship between separate organizations and third parties, allowing users to authenticate to one domain and access resources in another without a separate login, enhancing security and user satisfaction. Fluent's Federated SSO utilizes protocols like SAML and OIDC for secure data exchange, providing a seamless single sign-on experience across Fluent OMX applications. These open standards enable the secure transmission of authentication and access information across domains

• Federated IdP data storage

Roles & Permissions configuration contains:

• Roles & permissions page
• Role Details page

• Roles & permissions page
• Role Details page

This config guide refers to version 1 of the UX Framework which is now deprecated

• Mystique Components
• Add/Edit Entities
• Configure Dynamic UIs
• Configure Search or Listing Pages
• Configure Detail Pages
• Add Attributes to Mystique Components

Character escaping and unescaping are crucial for data integrity and security in UX frameworks. This document focuses on the Mustache.js templating engine, which escapes HTML by default to prevent XSS attacks. When special characters like ampersands need to be displayed, the framework offers unescaping methods to ensure correct and secure rendering.

This overview highlights the significance of proper value escaping and the techniques for accurately rendering special characters within the UX framework.

• Mustache.js Templating: The UX framework utilizes mustache.js for templating, which automatically escapes HTML characters. This is important for preventing XSS (Cross-Site Scripting) attacks and ensuring data is displayed as intended.
• Unescaping Variables: To display special characters properly, such as ampersands, you must unescape variables using triple mustaches, e.g., `{{{variable}}}`, or the `&` symbol in the variable tag, e.g., `{{&variable}}`.
• Correct Display of Values: Escaping or unescaping variables correctly is crucial for the accurate representation of data within the UX. This ensures that special characters are rendered as intended, maintaining the integrity of the information displayed to users.

A Location represents a physical place, whether a retail store, a warehouse, or even third-party vendor facilities.  A Location page displays the list of existing locations, while a Location Details page displays detailed information about the particular location.

• Locations page
• Location Details page

Using the Event API