Recently Updated

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

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

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.

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 product synchronization process involves the handling of events and messages through various queues and handlers. It utilizes the commercetools platform for product updates, employs a message router to direct events, and features extensible message handlers for customization.

• Queue-Based Flow: Events triggered by product initiation or modification in commercetools are pushed to the CT Queue through subscriptions. The CT Queue Listener class reads these messages and forwards them to the Event Queue.
• Message Routing and Handling: The Message Router guides event names from the Event Queue to the relevant handlers. Extensible message handlers offer partners the flexibility to customize logic by overriding existing handlers.
• Batch Job and Delta Sync: The Batch Queue manages bulk data asynchronously, activated by an external scheduler for product catalog synchronization. The Job Router directs the job name to the Product Batch Handler, facilitating filtering and syncing. Automatic Delta Sync ensures continuous background synchronization, relying on commercetools subscriptions.

commercetools CloudFormation Template

• CloudFormation Template

commercetools connector enables the syncing between commercetools and the Fluent commerce system. There are specific settings that need to be configured in the commercetools system i.e.: custom fields, channels, etc.

• The commercetools connector allows seamless integration between commercetools and Fluent. 
• The connector requires a set of custom fields and channels on commercetools. This article covers all the settings that need to be added to commercetools.

Below are the key features from `fc-commercetools-module`.

•  List of key features from fc-commercetools-module which can be used during the connector development.

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

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

The Extend Knowledge Content serves as a showcase for the versatile extensibility features of the Fluent Order Management Platform, enabling use cases beyond its standard capabilities. This content operates under distinct licensing terms from the main platform and documentation. It includes open source licenses with disclaimers, emphasizing user responsibility. Contributions are welcome from both Fluent Commerce and external parties, provided they adhere to the established open source licenses. For legal inquiries, contact legalnotices@fluentcommerce.com.

• Extend Knowledge Content showcases the extensibility of the Fluent Order Management Platform beyond standard capabilities.
• Content is licensed under Creative Commons Attribution 4.0 and Apache 2.0, with disclaimers emphasizing user responsibility.
• Contributions are welcome from both Fluent Commerce and external parties, subject to open source licenses.

• Supports full or partial cancellation of order line items based on remaining quantity.
• Extended UI component enforces cancellation reason and visualises cancellable quantity.
• Rule/Rule set updates to cancelledQuantity are required but not covered in this document.

There are several ways to get in touch with the team. Continue reading for assistance.

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

Learning Pathways offer structured learning consisting of Knowledge Tracks, Labs, and Assessments to up-skill for specific roles. You can choose from various pathways tailored to your role and complete assessments to earn certificates. Completing all pathways is recommended before you pursue a full certification.

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

The following mappings capture the features supported by the Shippit Connector.

• All the features described below should be driven by the retailer's requirements
• The table provides the reference mapping for integration purposes to enable certain features of the connector

This Study Guide helps prepare for the Functional Practitioner Certification Exam. It provides some summaries of various areas that will be relevant for the exam and other details to help you pass the exam.

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

This article explains what happens when an account is temporarily locked due to multiple failed login attempts, whether caused by a user entering the wrong password or an integration using outdated credentials.

After reading this article, you will understand:

• What triggers a username lockout in Fluent 
• How the lockout works 
• What actions users and integration owners should take

Key Points to Know:

• Lockouts are temporary (15 minutes).
• Applies to both web console users and API clients.
• A lockout is enforced even if the correct password is entered after the threshold is reached.

• Accounts are locked after multiple failed login attempts ( 5 attempts).
• Lockouts are specific to the username with failed login attempts
• The lockout period is 15 minutes, starting from the last failed attempt.
• Lockouts apply across all login methods (web, API, scripts) using the same username.
• During a lockout for a given username:
  • All logins (even with correct credentials) will return an error
  • The error message will be exactly the same as providing an incorrect username and password (even with correct credentials)
• The login screen and error messages will clearly reflect lockout status.
• Technical users maintaining integration code should ensure their code does not retry authentication more than 5 times. 
• Avoid account sharing between UI users and integrations to prevent cross-impact.
• Contact Support if you're locked out and need urgent access.

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.

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

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.

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

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

• It’s possible to add a new state to an existing workflow by adding a new status to the `Statuses array` of the workflow JSON.
• Create a simple User Action to allow the user to change the status.

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

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

Usage

The Fluent CLI is activated by typing the keyword `fluent` into a terminal command line, followed by a Command, Subcommand, Argument, and Options:

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

• The `<command>` will refer to a noun (or “a thing”).
• The `<subcommand>` will refer to a verb (or action).
• The `<argument>` is the primary required name of the “thing” identified by the `<command>`.
• The `[options]` may include required or optional additional parameters to be used by the `<command>` and `<subcommand>`.

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.

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

This document explains the GraphQL Error Codes used by Fluent Commerce.

• Understand the Error Code structure: Each code follows the Prefix + 4-digit Code + Suffix format (e.g., C0001E), which instantly reveals the source (Client/Server/Third-party) and type (Error/Warning) of the issue
• Quick diagnosis and resolution: Error Codes are grouped by category and purpose, helping developers diagnose and resolve issues faster without deep debugging or guesswork
• Self- vs. support-resolvable issues: 
  • Codes with a C prefix usually point to issues clients can fix on their own 
  • While S prefixed Codes may require platform support

Creating new retailers within an SSO-enabled account involves specific considerations to ensure seamless integration and secure user management. This section provides guidelines on how to set up new retailers effectively post-SSO enablement.

• Active SSO: With SSO activated, the `*_admin` user as `RETAILER` cannot access Fluent OMS via corporate IdP due to external IdP configurations. 
• User Role Management: Remove existing roles from `*_admin` users to restrict access appropriately.
• User Creation: Create new users  tailored for specific roles.

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

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

The SSO Cutover Planning and Execution details the essential steps for migrating and transitioning to SSO in Fluent. The specifics may differ based on the client's implementation of Fluent. It is advisable to have discussions with your partner and the Expert Services contact to gain further clarification.

• Necessary prerequisites for migration and cutover
• Planning the user migration
• Availability during cutover
• SSO Activation and Testing

Dive into suggested articles covering the basics of the Fluent Commerce OMS platform. 

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

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

All the details you need to get ready for peak season and black Friday.

• Peak period readiness preparation
• Fluent Commerce support model

Get a visual overview on all available commands and sub-commands for the CLI.

• Use this cheat-sheet to quickly see how to use the commands and sub-commands
• Differentiate between usage within a CI/CD pipeline and ad-hoc

Sample Product Queries that can be used on a daily basis

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

Query operations are used for retrieving data. Fluent's GraphQL API provides two types of query operations:

• `Get`: To retrieve and display unique results
• `Search`: To search and display a list of results

• Get
• Search
• Pattern Based Searches
• Search with Wildcard Characters
• Performing Pattern-Based Searches
• DateTime Search Operations
• Link-Based Query Searches
• Default Sort Order for Query Results
• GraphQL Error Handling

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.

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.

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.

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.

Rewarding way for customers to share their achievements.

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

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

This article explains how to interpret and act on GraphQL and REST API Error Codes to resolve issues faster.

Implementing partners will learn how to:

• Identify Error types 
• Decode Error Codes
• And apply suggested solutions

This supports:

• Faster debugging
• Better Error handling
• And improved integration reliability

The below content covers:

• Error Classifications 
• Known examples
• And guidance on when and how to self-resolve vs. escalate

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

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

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

Fluent REST API returns specific HTTP Error Codes which may vary depending on the API endpoint and are explained in this document.

• Categorization by HTTP Status Code: The errors are organized by standard HTTP status codes (e.g., 400, 401, 403, etc.), which helps developers quickly understand the type of issue
• Coverage of Common Scenarios: The examples span a range of typical failure conditions, from authentication issues to plugin errors and timeouts, offering a practical reference for API consumers

• Each location has an opening hours setup that can be used for store activities. One activity could be during the fulfillment allocation phase, where the fulfillment expiry time for a store is calculated, giving store staff sufficient time to process the order before it expires.
• Since opening hours can change week by week, we have created this guide to showcase how you can enable Store Managers to make these changes directly in the Fluent Store Web App.

• A simple guide to add product status as part of the order search filter.
• This feature will utilize OOTB components, so it does not require any customer components.

• Postman has a special client for GraphQL requests called the GraphQL client. 
• The GraphQL client has features that allow you to create and execute GraphQL requests more efficiently.
• It automatically fetches the schema of a GraphQL API and uses introspection to show you the available data fields. 
• You can explore the data fields of a GraphQL API and construct queries by selecting fields or entering code in an editor.

• This is an enhanced feature that allows users (e.g., Customer Service Representatives) to look up customer orders by using either the customer's email address or phone number. 
• This feature can be achieved by configuration in the setting manifest without any custom components nor custom rules.
• This article will provide the following:
  • code snippet of the search Order by Customer phone/email manifest
  • Language settings
  • Display the page on the left panel menu by adding a code snippet in the setting: `fc.mystique.manifest.oms` 

• A simple guide to creating an OMS webapp page from scratch

This article covers the typical methods used to estimate projects. Take a look at our project sizing template, the MOSCOW framework, and an example of estimating by priority.

• Project effort estimation - Learn how to size a project.
• Requirement prioritisation - Learn about the MOSCOW framework and prioritisation methods.

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

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

• Setting Example
• Defining the Dot for Each Value in the Cell
• Setting Naming Convention - fc.order.list.status.column

• The CI/CD pipeline is configured for Bitbucket and requires changes for other repositories
• The CLI is not used for retailer creation in the deployment process
•  One retailer's assets can be deployed at a time through manual selection.
• The E2E plugin must be manually placed in the `plugins/` folder before starting the pipeline.

• Typically, the HD shipping label is generated by the nominated carrier company or carrier aggregator.  The label URL is then stored in OMS for printing. 
• This guide will take you through the setup to allow the store users to print the shipping label from Fluent STORE. 

• The CC pack label on the Fluent Store can be customised via an HTML template.
• This guide will take you through the setup and fragment changes required to customise the pack label.
• The printed pack label can then be attached to the paper bag or parcel ready for customer collection in-store.
• Enhancements can be made to the reference label content. For example, the client's logo or an additional barcode for scanning purposes can be included.

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

The values on the packing list.

• List of values on the packing list 

• The Pack Slip on Fluent Store can be customised via an HTML template.
• This guide will take you through the setup and fragment changes required to customise the Pack Slip.

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

• Overview
• Operations
• Models

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

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

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

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.

• Step by step to demonstrate how to add fulfilment line details into the PACK screen.
• This is a configuration change only. Hence,  no custom component is required.

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.

• a handy tip on how to use fc.filterPanel in fc.tabs.card

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.

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.

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

• The below example demonstrates how to hide a specific user action button via OMS manifest setup in Fluent OMS or STORE.

• The best practice for controlling the visibility of the user action button should be driven by the entity status within the ruleset.  
• However, if the customer does not want to enhance the list of statuses, this trick can be used to control the User Action button visibility by using the entity's attribute value.
• This article will demonstrate the following in an Order entity:
  • Display a user action button:  once clicked,  it will add an attribute (SENT_TO_WMS) to the order entity
  • Update the manifest to check the attribute (SENT_TO_WMS), if the value is not "True", then display the button.    
• the sample source code will be provided in this article.

The Upsert Location Module contains the workflow and supporting rules to update or create (aka upsert) locations. This page covers the steps to configure and install the Upsert Location Module.

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

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

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

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

Reference behaviour: Inventory Batch, Inventory Position and Inventory Quantity (Quantities) with CORRECTION

• This article will give a good understanding of Last On Hand and how OMS calculates the Inventory On Hand quantity.  
• Covers how inventory quantity values are handled during the batch process.
• For the Virtual Catalogue and Virtual Positions, please refer to the training articles.

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

Reference behaviour: Inventory Batch, Inventory Position and Inventory Quantity (Quantities)with RESERVED & SALE

• This article will give a good understanding of Last On Hand and how OMS calculates the Inventory On Hand quantity.  
• Covers how inventory quantity values are handled during the batch process.
• For the Virtual Catalogue and Virtual Positions, please refer to the training articles.

Reference behaviour: Batch Inventory, Inventory Position and Inventory Quantity (Quantities) with CORRECTION

• This article will give a good understanding of Last On Hand and how OMS calculates the Inventory On Hand quantity.  
• Covers how inventory quantity values are handled during the batch process.
• For the Virtual Catalogue and Virtual Positions, please refer to the training articles.

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.

These labs focus on debugging and troubleshooting Fluent Order Management workflows using GraphQL and Postman. They cover retrieving detailed data for orders and waves, analyzing audit events, identifying stuck orders, and re-triggering workflows. The goal is to simulate real-world scenarios, understand workflow paths, and resolve issues efficiently.

• Full Order/Wave Retrieval: Use GraphQL to fetch information on orders and waves.
• Audit Events: Use Event APIs to trace orchestration activities and errors.
• Status Transitions: Track entity status changes and time spent in each state.
• Stuck Orders: Identify and troubleshoot orders stuck in specific statuses.
• Workflow Debugging: Simulate workflow breaks and resolve stuck entities.
• Re-trigger Rulesets: Fix workflows and re-trigger events for stuck orders to progress.

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: Fulfill CC, HD Order with Store-to-Store Transfer and Short Pick, Reassignment, and Multi-shipment.

• This lab cover store to store transfers and ship from store case scenario. 
• You would need a Store's dedicated user to log into Fluent Store and run the different operations in that store.
• All necessary master data can be set up via API or via Fluent OMS, as usual. 

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

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

• A guide to extend Fluent STORE UI capabilities to allow the store users to have a better visibility on the fulfilments by expiry time.
• The use case where the store staff would like to see number of fulfilments for the next 2 hours so that they can plan their pick and pack process accordingly. 
• One of the solutions is by using OOTB component and manifest to display the fulfilments number based on the expiry time.  Hence, there are no custom rules nor custom component is required for this solution.
• Here are the steps to archive the outcome:
  • Create a new screen in fluent Store
  • Create dashboard tiles

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

This article will allow you to apply the practical knowledge you've acquired related to availability in this knowledge track course.

• Setting up the Postman workspace (API+environment collections) is the first step towards testing availability. 
• Fulfillment options utilize the fulfillment options workflow; we usually have one for HD and one for CC. They can both be customized to consider extra parameters when providing the ATS quantity.
• The workflow can be inspected on Admin Console. 

This article will allow you to apply the practical knowledge you've acquired related to inventory in this knowledge track course.

• The page provides step-by-step instructions for:
  • Setting up Postman
  • Performing a full inventory load via Batch API
  • Checking stock on hand and available to sell quantities
  • Creating and applying a buffer to modify the ATS

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

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

What is Fluent Order Management?

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

• The main components that comprise the platform architecture are:
  • Webapps 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.

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 `tag1`, `tag2`, and `tag3` filters allow users to filter orders based on an exact match of the entered value.
• These filters can be configured to use predefined values instead of a text input field that is available out of the box, enhancing usability and consistency.

• Target audience: Configurers or Fluent Partners.
• The guide explains how to successfully configure the status filter with predefined values.

Learn how module dependencies work, how they are described and when they are enforced.

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

• Describe the steps to create a new module with a custom plugin
• TL;DR from module creation to installation:
• Create: `fluent module create`
• Update `resources/module.json` with the module's version, dependencies and module name
• Add in the source code + unit and integration tests under the `plugins/` folder

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

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

• Create a profile
• Create a retailer
• Configure and Install the Fluent Reference Modules
• Configure and Install the Extension Data module
• Validate the Account setup

• Describe the steps to create a new Data Module
• Use B2C Sample data for reference
• Build and Install the Extension Data Module

• Eligibility & Conditions – Clearly define the conditions under which an item can be exchanged, such as time limits, product conditions, and receipt requirements.
• Exchange Process – Outline the step-by-step process, including how customers initiate an exchange, return shipping details, and replacement timelines.
• Inventory & Availability – Ensure the desired replacement item is in stock and provide alternatives if it's unavailable.
• Refund vs. Exchange Policy – Specify whether price differences will be refunded or charged.
• Customer Communication – Keep customers informed at every stage with order tracking, confirmation emails, and support availability.

Fluent integrates key Google Cloud Platform (GCP) services to enhance scalability, performance, and security across its infrastructure. By leveraging Compute & Serverless, Data & Storage, Networking & Delivery, and Security & Compliance solutions, Fluent ensures a reliable and efficient cloud environment.

• Google Cloud Platform components used by Fluent fall into the Compute & Serverless, Data & Storage, Networking & Delivery, and Security & Compliance categories
• Compute & Serverless: Run workloads with virtual machines (GCE), Kubernetes (GKE), and event-driven functions (Cloud Functions). 
• Data & Storage: Store and analyze data with Cloud Storage, BigQuery, Cloud SQL, and Cloud Spanner. 
• Networking & Delivery: Speed up content with Cloud CDN and balance traffic efficiently with Cloud Load Balancer. 
• Security & Compliance: Protect workloads with IAM, Cloud KMS, Secret Manager, and Audit Logs.

• Create the new module: `fluent module create -n <module-name> `
• Populate the plugin structure in `plugins/`
  `rules/` - Contains rules, unit tests and GraphQL queries/mutations
    `types/` - Stores model classes and extended DTOs
    `util/` - Holds service classes and utilities
• Build the module:  `./scripts/build-module.sh`
• Install the module: `fluent module install dist/<module-name>-<version>.zip -p <profile> -r <retailer>`

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

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

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

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

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 article will explore the different stages involved in an order's lifecycle. Through the various tabs and sections in the Fluent OMS interface, you can easily track the status and progress of orders including customer delivery preferences and details. This promotes transparency and efficiency in the order fulfillment process.

• You will be introduced to the Order List, Order Details, and Order Item Details pages, and their components along individual tabs. 
• This knowledge will assist users in effectively navigating the Fluent OMS interface and using relevant filters to find essential information for a specific order and a particular retailer.

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

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

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

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

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

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

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

• The timestamp
• The User who created it (`USER_VIEW` Permission is required to access the User data)

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

• Add Comments to any Entity Type, enabling detailed documentation of business actions
• Specific Permissions are required for Comment operations
• Use the `createComment` and `updateComment` Mutations to manage Comments
• Use the `commentById` and  `comments` Queries to retrieve Comments

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

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

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

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

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

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

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

Controls can be used to:

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

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

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

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

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

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

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

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

•  Enhance Fulfilment Option speed
• Customise setting for speed

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

• Optimize Inventory Updates: Batch Pre-Processing enhances system efficiency by processing only necessary changes, reducing unnecessary load on the workflow engine.
• Structured Batch Updates: Properly structuring your batch updates with the correct use of fields like `ref`, `type`, and `status` is essential for accurate change detection and effective use of Batch Pre-Processing.
• Essential Knowledge: Even if you don't delve into all the details, remember that precise batch update structures are crucial. Pay special attention to how the `ref` field is constructed and the default behaviors when certain fields are not specified.
• New Fields and Defaults: Be aware of the new fields introduced by this feature and understand the default transient types and statuses. This knowledge will help you implement Batch Pre-Processing correctly and avoid potential pitfalls.

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

This guide explains how to leverage the `attributes` object to include custom data in your inventory payloads. By supporting both simple key-value pairs and complex JSON structures, the `attributes` object offers the flexibility to meet diverse business requirements—whether you’re managing detailed product information, optimizing warehouse processes, or integrating with custom workflows. You’ll also learn about recommended attribute fields like `expectedOn`, `storageAreaRef`, and `condition`, which are automatically integrated into Inventory workflows for streamlined updates and better data consistency.

• Flexible Attribute Structure: The `attributes` object supports any combination of key-value pairs, including complex JSON structures and arrays. This flexibility allows you to customize the data sent in your inventory payloads to meet specific business needs.
• Recommended Attributes: Certain key attributes, such as `expectedOn`, `storageAreaRef`, and `condition`, are automatically integrated into our platform’s workflows. These fields will be directly updated in the inventory quantity associated with the incoming record, facilitating seamless integration with existing fields.
• Custom Attribute Availability: Any custom attributes that you include in the `attributes` object will be available in workflows via `inventoryPosition.inventoryQuantity.attributes.<fieldname>`. This enables you to incorporate custom data into rule-based processes or other logic tailored to your business requirements.
• ISO 8601 Date Format: For any date-related attributes, it is recommended to use the ISO 8601 format (e.g., `YYYY-MM-DDTHH:MM:SSZ`) to ensure consistency and proper handling within the system.
• Integration with Workflows: The system is designed to handle both recommended and custom attributes, making them accessible within the workflow context. This ensures that you can leverage these attributes in custom rules and other logic, depending on the specific needs of your implementation.
• Extensibility: While the table of recommended attributes provides a useful starting point, you are encouraged to extend the `attributes` object with any additional fields relevant to your business processes. The flexibility of this structure allows for robust customization.

• The 'Create Order' wizard streamlines the order creation process by guiding users through each step, reducing the chances of errors, and ensuring all necessary information is captured.
• It provides a user-friendly interface that simplifies complex order configurations, making it accessible for users with varying levels of technical expertise.
• The wizard includes validation checks at each step, ensuring that all entered data is accurate and complete before proceeding to the next step.

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

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

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

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

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

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

•  Access to Fluent Training account is required

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

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

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

• Prerequisites setup
• Basics of Rule writing

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

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

• Installed SDK
• GQL Basics

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

• Prerequisites software installation

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

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

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

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

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

• Manifest Fragment Creation: Learn to create and configure a new Manifest fragment for managing storage areas.
• Account Settings Integration: Integrate the new fragment into account settings and reference it in the main Manifest.
• List Component Integration: Use the List Component to display storage area data.
• Data Source Configuration: Use the `activeLocation` context to configure a page query as a data source for the List Component.
• Details Page Creation: Create a details page for individual storage areas with a dedicated page query.
• Dynamic Value Handling: Learn to work with dynamic values using formatters (e.g., `dateStringFormatter`), array access, attribute retrieval by name, and image rendering.
• i18n Configuration: Configure i18n language translation keys for the web app.

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

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

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

• Download and Extract: Download the Component SDK zip file and extract it to a suitable development location on your computer.
• Yarn Installation: Navigate to the `omx-component-sdk` folder in your terminal and run yarn install to download all project dependencies.
• Visual Studio Code Setup: Open the project in Visual Studio Code and verify that the sample components (e.g., `Hello.tsx`) are error-free.
• Local Development Server: Start the development server using yarn start. This allows you to run your plugin locally and test it within your Fluent Web Apps.
• Manifest Configuration: Add a reference to your local plugin project (running on localhost:3001) within your Fluent Store main manifest (`fc.mystique.manifest.store`) using a "type": "url" and "src" entry, linking your development environment to your application.

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

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

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

Token authentication is mandatory for all Fluent integrations.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

You will learn about key Workflow concepts and the Workflow Builder 

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

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

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

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

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

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

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

API, Integration, and Connectors

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

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

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

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

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

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

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

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

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

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

This topic describes the cloud native nature of the Fluent platform

• Scalable
• Secure
• Versionless software
• Zero downtime

This section outlines how the webapps interact with the modules

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

This page sets out the:

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

relating to the Fluent Order Management Cloud Platform (Platform)

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

This page sets out the:

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

relating to the Fluent Order Management Cloud Platform (Platform)

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

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

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

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

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

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

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

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

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

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

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

• Example createOrder mutation payload for MULTI order type

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

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

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

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

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

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

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

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

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

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

The `payment` is an entity that is required as part of the payment process. 

• The page provides GQL example of how to use `payment`:
  • Create
  • Update
  • Query

This guide teaches you how to manage large monetary values accurately in Fluent OMS using `scale` and `unscaledValue` rather than relying solely on floating-point `amount`. By following these practices, you’ll learn to configure financial values for invoices and other transactions with precision. Implementing partners benefit from consistent, reliable data, and customers gain accurate, trustworthy financial information—especially when handling large currency amounts.

• Avoid floating-point inaccuracies by using `scale` and `unscaledValue` for large amounts.
• Treat `unscaledValue` and `scale` as the source of truth for exact monetary values.
• Adjust `scale` to handle very large amounts while maintaining precision.
• For display and reporting, always reconstruct amounts from `unscaledValue` and `scale`.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

This page sets out the:

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

relating to the Fluent Order Management Cloud Platform (Platform)

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

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

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

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

Fluent's GraphQL API has two operations:

• Queries 
• Mutations

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

• Operations
• Queries
• Mutations
• Custom Queries

• Overview
• Prerequisites
• Installation
• Next Steps

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

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

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

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

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

• Corporate IdP
• Fluent IdP & API Users

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

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

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

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

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

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

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

Carriers configuration contains:

• Carriers List page
• Carrier Details page

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

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

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

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

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

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

• Support Policy - Fluent OMS