How Sourcing Auditability Works

Topic

Authors:

Kirill Gaiduk, Cille Schliebitz

Changed on:

3 Sept 2026

Overview

Sourcing Auditability gives you an immutable record of every sourcing decision. These articles explain how the audit model captures the sourcing profile and version applied, each strategy considered, the pass or fail result of every condition, and per-location criteria scores and positions, so you can compare any considered location against the one selected. Implementing partners gain a faster way to test, debug and validate sourcing logic; businesses gain the traceability their operations, support, analytics and compliance teams need. Applies to the Responsive Sourcing Framework only.

Author:

Kirill Gaiduk

Changed on:

1 Sept 2026

Overview

Sourcing Auditability records why the Responsive Sourcing Framework made each sourcing decision. For each Sourcing Request, it records the inputs evaluated and the outcome reached, so you can review the decision later.It helps teams understand:

Which Strategies and Conditions were evaluated
Which Locations were considered and how they scored against their Criteria
The Location(s) selected, and why

This document explains:

What Sourcing Auditability captures and why it matters
What you can see and answer with it
Where audit data appears, and where to find interface and API detail

Key points

Prerequisites: You should have knowledge of the Responsive Sourcing Framework and How Sourcing Utilities work
A Sourcing Audit is an immutable record of a single Sourcing Request, created at the end of each completed sourcing attempt
Recording an audit never changes the sourcing outcome - if an audit cannot be recorded, the sourcing result still proceeds
Audit records are shown only to users who hold the appropriate permissions
Sourcing Auditability keeps the detailed Location scoring for the Sourcing Strategy that produced the Fulfillments

What Is Sourcing Auditability?

Responsive Sourcing lets you build advanced, dynamic sourcing logic. Before Sourcing Auditability, teams had limited visibility into why the Framework made a given decision, what influenced it, and how a change to the logic affected outcomes.Sourcing Auditability closes that gap. It makes sourcing decisions transparent, traceable, and easy to explain, in four parts:

Capture - the Framework collects the key inputs, evaluation results, and outcome of each Sourcing Request as it runs
Retain - it keeps each Sourcing Request as an audit record
Access - audit records are available through the Sourcing Auditability GraphQL API
Review - audit records appear in the Fluent Order Management System (OMS) Web App, in a new Sourcing tab

Note

A Sourcing Request is a point-in-time request to fulfill unfulfilled items in an Order / Fulfillment Choice using the applicable Sourcing Profile(s).A single Order can produce more than one Sourcing Request - for example, one at creation and another whenever a short pick or non-pick occurs - and each Sourcing Request produces its own audit record.

Value Proposition

Sourcing Auditability addresses operational and governance needs that grow with sourcing complexity:

Explain any decision. See:
- Which Strategies were evaluated or skipped
- Which Conditions passed or failed
- Which Locations were considered
- How each Location scored against each Criterion
- The Location(s) selected, and why
- What each considered Location could not fulfill
Reduce time to resolution. Operations and customer service teams can investigate an unexpected sourcing outcome directly, instead of piecing it together by hand
Validate change. Product and engineering teams can confirm how a change to Sourcing Profiles, Strategies, Conditions, or Criteria affected real outcomes
Support governance and analytics. Immutable, access-controlled records support compliance requirements and provide detailed data for downstream analytics

How It Works

The following diagram shows where Sourcing Auditability fits and how audit data reaches the people who review it:

In practice:

The Responsive Sourcing Framework generates an audit as each Sourcing Request completes, from within the Sourcing Utilities
Recording the audit never affects the sourcing outcome
You review audits in the OMS Web App Sourcing tab, or retrieve them through the Sourcing Auditability GraphQL API

See also

See How Sourcing Utilities work for how audit data is generated.

What Gets Captured

Each audit describes one Sourcing Request. It records:

The Sourcing Request and its overall outcome - Fully Sourced, Partially Sourced, or Not Sourced
The Sourcing Profile and version used for the decision
The items the request was sourcing
Each Strategy considered, in priority order, and whether it was:
- Skipped - a Condition on the Strategy failed, so the Strategy did not run
- Evaluated - the Strategy's Conditions passed and it was evaluated
- Not Considered - an earlier Strategy already produced the required Fulfillments, so this Strategy was not reached
For the Strategy that produced the Fulfillments - the Locations considered, how each scored against the Criteria, the Location(s) selected, and what each considered Location could not fulfill

See also

For the full field-level detail - the GraphQL types, fields, query, mutation, and permissions - see the Sourcing Auditability GraphQL API Overview.

Reviewing Audits in the OMS Web App

Audit data appears in a new Sourcing tab on the Order Detail screen of the Fluent OMS Web App. The tab is read-only and appears only for users with the required permissions.For each Sourcing Request, you can review the request summary, the items sourced, how each Strategy was evaluated, the Locations considered and how they scored, and the Location(s) selected. Location Comparison lets you compare the selected Location against another candidate the same Strategy evaluated.

Note

The Location Position is the position (rank) of a Location within a Strategy's ranked list of candidates. Comparing positions shows whether the most suitable candidate was the one selected, and where other considered Locations ranked.

For the full walkthrough of the tab, see Sourcing Audits in Fluent OMS Web App.

Explanation Through an Example

Consider a Sourcing Request for an order with two items, using a Sourcing Profile that has two Primary Strategies:

The first Strategy - Skipped. The Strategy has a Condition requiring the delivery state to be one of a configured set. The order's delivery state is not in that set, so the Condition fails and the Strategy is skipped. No Location detail is recorded for it.
The second Strategy - Evaluated. The Strategy's Conditions pass, so it is evaluated. The Framework scores the candidate Locations against the Strategy's Criteria and selects the best-ranked Location that can fulfill the items.
Outcome. One Location fulfills both items, so the Sourcing Request is Fully Sourced. Because the second Strategy produced the Fulfillment, the audit records its full Location detail - the considered Locations, their Criteria scores, and what each could not fulfill.
Review. In the Sourcing tab, an operations user opens the order, sees that the first Strategy was skipped because the delivery-state Condition failed, sees the second Strategy's ranked Locations and scores, and uses Location Comparison to confirm why the selected Location was chosen over the others.

The following diagram traces the example:

Note

This is one illustrative scenario. Sourcing Auditability records every completed Sourcing Request across primary and partial sourcing flows, whatever the Profile configuration.

Overview

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

Key points

Prerequisites: This article assumes you're familiar with Java, Maven, and JUnit
Sourcing Orchestration (`SourcingUtils`): Orchestrates the sourcing process and provides helper methods to load a Sourcing Profile
Context Management (`SourcingContextUtils`): Loads and manages Sourcing Context
Order Helper (`OrderUtils`): Performs order-specific operations such as fulfillment creation
Location-Based Optimization (`LocationUtils`): Provides location-based helpers including distance calculations and caching
Fulfillment Options Support (`FulfilmentOptionsUtils`): Creates fulfillment plans with available quantity tracking and ETA calculation
Sourcing Conditions and Criteria Management: Provides functions, registration, and execution logic for tailoring Sourcing Strategies to the specific needs of customers
Sourcing Auditability: Captures a Sourcing Audit of each sourcing decision (strategies, conditions, considered locations and their ratings, and the resulting fulfillments) and submits it through the `createSourcingAudit` mutation

Java Docs

The helper methods contained in the Utility Bundles libraries are many and varied, so the JavaDocs provided with the packages should be treated as the source of truth for documentation.

Value Proposition

Eliminate Manual Sourcing: Pre-built utility methods handle complex inventory allocation and location selection logic
Faster Implementation: Common sourcing patterns are abstracted into reusable, tested components
Reduced Complexity: Standardized approaches prevent common sourcing errors and edge cases
Extensibility: Custom sourcing strategies can be easily implemented.
Consistent Patterns: Enforce best practices across your sourcing rule implementations

Explanation through an Example

Let's walk through a simple real-world scenario to understand how Sourcing Utilities work in practice.Imagine you're running an online store that receives an order for:

2x Gaming Laptops (high-value items)
3x Wireless Mice (medium-value items)
1x Gaming Headset (high-value item)

The customer lives in New York City, and you have inventory at multiple locations:

Main Warehouse (New Jersey) - Has all items in stock
Local Store (Manhattan) - Has laptops and mice, but no headset
Regional DC (Boston) - Has all items but higher shipping costs

How Sourcing Utilities Help

1// Load the sourcing profile for the current context
2SourcingProfile sourcingProfile = SourcingUtils.loadSourcingProfile(context);

Language: java

Name: Load the Sourcing Profile

Description:

Profile can contain Conditions and Strategies like:
- "Peak period" (only apply the strategy during peak period)
- "Bulky items" (only apply the strategy for orders which contain bulky items)
- "Proximity First" (prioritize closest locations)
- "Cost Optimized" (minimize total fulfillment cost)
- "Speed Priority" (fastest delivery regardless of cost)Please note that the Rule property referencing the Sourcing Profile is assumed to be name `sourcingProfileRef`.

1// Create sourcing context with unfulfilled order items
2SourcingContext sourcingContext = SourcingContextUtils.loadSourcingContext(
3    context, 
4    SourcingUtils::getUnfulfilledItems
5);

1// Enable Sourcing Audit capture for this run
2SourcingAuditRecorder auditRecorder = new DefaultSourcingAuditRecorder();
3
4// Find the best sourcing plan based on strategies
5SourcingPlan plan = SourcingUtils.findPlanBasedOnStrategies(
6    SourcingExecutionParameters.builder()
7        .context(context)
8        .sourcingContext(sourcingContext)
9        .profile(sourcingProfile)
10        .positionStatuses(ImmutableList.of(Constants.Status.ACTIVE))  // Consider only ACTIVE positions
11        .inventoryProcessor(this::customInventoryProcessor)
12        .auditRecorder(auditRecorder)
13        .build()
14);

1// The system generates a sourcing plan that might look like:
2SourcingPlan optimalPlan = new SourcingPlan();
3optimalPlan.addFulfilment(
4        SourcingUtils.Fulfilment.builder()
5                .location(Location.builder().name("Manhattan Store").build())
6                .items(Arrays.asList(
7                        Fulfilment.FulfilmentItem.builder().ref("2x Laptops").build(),
8                        Fulfilment.FulfilmentItem.builder().ref("3x Mice").build())
9                )
10                .build()
11);
12optimalPlan.addFulfilment(
13        SourcingUtils.Fulfilment.builder()
14                .location(Location.builder().name("NJ Warehouse").build())
15                .items(Arrays.asList(
16                        Fulfilment.FulfilmentItem.builder().ref("3x Mice").build())
17                )
18                .build()
19);

1// Set fulfillment types
2OrderUtils.fillFulfilmentType(sourcingContext, fulfilments);
3
4// Create fulfillments from the plan
5List<Fulfilment> fulfilments = OrderUtils.createFulfilments(
6    context, 
7    sourcingContext, 
8    plan.getFulfilments()
9);

1// Record the sourcing decision as a Sourcing Audit and submit it
2SourcingUtils.captureAudit(context, plan, sourcingProfile, auditRecorder, sourcingContext);

What Happens Behind the Scenes

Inventory Analysis: System checks real-time inventory at all locations
Distance Calculation: Calculates delivery times and costs for each location
Strategy Evaluation: Applies business rules (proximity, cost, speed)
Optimization: Finds the best combination of locations to fulfil the order
Audit Capture: Records the sourcing decision (evaluated strategies, conditions, considered locations and their ratings, and the resulting fulfillments) as a Sourcing Audit and submits it through `createSourcingAudit` for later review

This example shows how Sourcing Utilities transform a complex business decision into simple code.

Overview

Key points

Main Orchestrator: Central utility class that coordinates all sourcing operations from a rule
Strategy Evaluation: Evaluates and applies sourcing strategies based on business rules
Plan Generation: Generates sourcing plans for order fulfillment
Chunk Loading: Locations are evaluated in incremental chunks to support large sourcing networks. An early availability check skips expensive permutation search when the order cannot be fully sourced from the available stock
Multi-Attempt Sourcing: `getPlanFinder` provides a single entry point for primary and fallback sourcing, generating multiple ranked plans without reloading data
Sourcing Auditability: sourcing captures a Sourcing Audit of the decision (strategies, conditions, considered locations and their ratings, and the resulting fulfillments) and submits it with `captureAudit`

Core Methods

`getPlanFinder()`

The preferred single entry point for running primary or fallback sourcing from the same parameters object. Returns a `SourcingPlanFinder` that exposes:

`nextFullPlan()` for primary-strategy sourcing
`nextFallbackPlan()` for fallback-strategy sourcing

The underlying finder for each variant is initialized lazily on the first call and reused on subsequent calls, so sourcing data is loaded at most once per variant.

1SourcingExecutionParameters params = SourcingExecutionParameters.builder()
2        .context(context)
3        .sourcingContext(sourcingContext)
4        .profile(sourcingProfile)
5        .positionStatuses(ImmutableList.of(Constants.Status.ACTIVE))
6        .build();
7
8SourcingPlanFinder finder = SourcingUtils.getPlanFinder(params);
9
10// Primary sourcing: call multiple times to produce alternative
11// plans without reloading sourcing data
12SourcingPlan plan = finder.nextFullPlan();
13
14// Fallback sourcing from the same parameters object
15SourcingPlan fallbackPlan = finder.nextFallbackPlan();

Decorator Scenario

To wrap the finder in a decorator (for example, location exclusion between attempts), use `getBasedOnStrategiesPlanFinder` or `getBasedOnFallbackStrategiesPlanFinder` directly and wrap the returned finder before calling `nextPlan()`.

`findPlanBasedOnStrategies()`

Finds the best sourcing plan for an order based on sourcing strategies defined in a sourcing profile.Location evaluation uses a `ChunkLoadingPlanFinder` that loads locations in incremental chunks sized proportionally to the order's item count.

A single-location search is run after each chunk
A multi-split search runs across the full evaluated set if no single-location plan is found
An early availability check is performed before entering permutation search - if any item cannot be covered by the combined quantities across candidate locations, permutation search is skipped

1SourcingPlan plan = SourcingUtils.findPlanBasedOnStrategies(
2    SourcingExecutionParameters.builder()
3        .context(context)
4        .sourcingContext(sourcingContext)
5        .profile(profile)
6        .positionStatuses(ImmutableList.of(Constants.Status.ACTIVE))
7        .build()
8);

`getBasedOnStrategiesPlanFinder()`

Returns a `SourcingPlanFinder` configured for primary sourcing strategies.`findPlanBasedOnStrategies(SourcingExecutionParameters)` is equivalent to `getBasedOnStrategiesPlanFinder(sourcingExecutionParameters).nextPlan()`.Use this when you need to call `findPlanForAllItems` multiple times without reloading sourcing data from scratch - for example, when generating a ranked list of fulfillment plans.

1SourcingPlanFinder planFinder = SourcingUtils.getBasedOnStrategiesPlanFinder(
2    SourcingExecutionParameters.builder()
3        .context(context)
4        .sourcingContext(sourcingContext)
5        .profile(profile)
6        .positionStatuses(ImmutableList.of(Constants.Status.ACTIVE))
7        .build()
8);
9// Call nextPlan() for each attempt without reloading sourcing data
10SourcingPlan plan = planFinder.nextPlan();

`findPlanBasedOnFallbackStrategies()`

Finds the sourcing plan for unfulfilled items using fallback sourcing strategies when no primary strategy fully satisfies the sourcing request.

Only one fallback strategy is used, specifically the first that satisfies the sourcing conditions
Supports partial sourcing, where fulfillments may not completely satisfy the order
Location ratings are recalculated after each allocation iteration using remaining unfulfilled items, ensuring each location selection reflects actual demand at that point in the iteration

1SourcingPlan plan = SourcingUtils.findPlanBasedOnFallbackStrategies(
2    SourcingExecutionParameters.builder()
3        .context(context)
4        .sourcingContext(sourcingContext)
5        .profile(profile)
6        .positionStatuses(ImmutableList.of(Constants.Status.ACTIVE))
7        .build()
8);

`getBasedOnFallbackStrategiesPlanFinder()`

Returns a `SourcingPlanFinder` configured for fallback sourcing strategies.`findPlanBasedOnFallbackStrategies(SourcingExecutionParameters)` is equivalent to `getBasedOnFallbackStrategiesPlanFinder(sourcingExecutionParameters).nextPlan()`.Wrap the returned finder (for example, for multi-attempt location exclusion) before calling `findPartialFulfilmentPlan` in a loop.

1SourcingPlanFinder fallbackFinder = SourcingUtils.getBasedOnFallbackStrategiesPlanFinder(
2    SourcingExecutionParameters.builder()
3        .context(context)
4        .sourcingContext(sourcingContext)
5        .profile(profile)
6        .positionStatuses(ImmutableList.of(Constants.Status.ACTIVE))
7        .build()
8);
9// Wrap finder for multi-attempt location exclusion, then call nextPlan()
10SourcingPlan partialPlan = fallbackFinder.nextPlan();

`buildRejectedFulfilment()`

Builds a rejected fulfillment for all remaining unfulfilled items in the sourcing context.

1// Build system rejected fulfillment for unfulfillable items
2Fulfilment rejectedFulfilment = SourcingUtils.buildRejectedFulfilment(
3    context, 
4    sourcingContext, 
5    context.getProp(PROP_SYSTEM_REJECTED_LOC_REF)
6);

`captureAudit()`

Submits the completed Sourcing Audit at the end of a Sourcing Request. Call it after Fulfillments are created: it stamps the applied Sourcing Profile onto the plan's audit and queues the `createSourcingAudit` mutation.Pass the `sourcingContext` so the audit is recorded against the sourced entity, for example it supplies the Fulfillment Choice id and reference stored on the audit.

Parent Entity Handling

`captureAudit` records the Sourcing Audit against the entity that was sourced, and always stores both its internal `entityId` and its human-readable `entityRef`:

`FULFILMENT_CHOICE` - when the sourced Fulfillment Choice has a reference. `entityId` is the Fulfillment Choice id and `entityRef` its ref. This is the usual case.
`ORDER` - when that Fulfillment Choice has no reference (the Fulfillment Choice reference is optional on the create-order input). `entityId` is the Order id and `entityRef` the Order ref.

`entityRef` is a required field on the audit, so falling back to the Order when the Fulfillment Choice has no reference guarantees the audit is always written.To read audits back, query `sourcingAudits` by `entityType: ORDER` with the Order id to get the audits for the Order and all its Fulfillment Choices, or by `entityType: FULFILMENT_CHOICE` with the Choice id for a single Fulfillment Choice.

When building a custom rule with the utilities, enable capture by supplying a `DefaultSourcingAuditRecorder` through `SourcingExecutionParameters.auditRecorder(...)`; when no recorder is supplied the call is a no-op.

`DefaultSourcingAuditRecorder` captures the decision during plan-finding and posts the audit. Create a new instance per rule invocation; it is stateful, so never share it across rules or store it on a rule field
`NoOpSourcingAuditRecorder` is the default when `auditRecorder` is not set. It ignores every capture call, so an un-instrumented sourcing path pays no cost

1final SourcingAuditRecorder auditRecorder = new DefaultSourcingAuditRecorder();
2
3SourcingPlan plan = SourcingUtils.getPlanFinder(
4    SourcingExecutionParameters.builder()
5        .context(context)
6        .sourcingContext(sourcingContext)
7        .profile(sourcingProfile)
8        .positionStatuses(ImmutableList.of(Constants.Status.ACTIVE))
9        .auditRecorder(auditRecorder)
10        .build()
11).nextFullPlan();
12
13if (plan.getFulfilments() != null) {
14    OrderUtils.fillFulfilmentType(sourcingContext, plan.getFulfilments());
15    OrderUtils.createFulfilments(context, sourcingContext, plan.getFulfilments());
16}
17
18// Stamps the profile onto the audit and queues the createSourcingAudit mutation
19SourcingUtils.captureAudit(context, plan, sourcingProfile, auditRecorder, sourcingContext);

Reminder

The account role that Rubix runs as must hold `SOURCINGAUDIT_CREATE` to write audits and `SOURCINGAUDIT_VIEW` to read them back. A failure to create the audit is logged and does not affect or reverse the sourcing outcome.

Supporting Methods

`findPlanForAllItems()`

This helper method is used by the `findPlanBasedOnStrategies` method to identify a plan for an order based on the sourcing strategies. It ranks candidate locations using the provided sourcing criteria, and searches for the best combination of locations that can cover the full order within the allowed split limit. Fewer-location plans are always preferred.Before entering permutation search, an early availability check sums available quantities for each required item across all candidate locations. If any item cannot be covered, permutation search is skipped. If no valid combination exists, it returns an empty plan.

1String networkRef = SourcingUtils.getNetworkRef(sourcingProfile, strategy);
2String virtualCatalogueRef = SourcingUtils.getVirtualCatalogueRef(sourcingProfile, strategy);
3Integer maxSplit = SourcingUtils.getMaxSplit(sourcingProfile, strategy);
4List<Location> locations = LocationUtils.getLocationsInNetwork(context, networkRef);
5
6SourcingPlan plan = SourcingUtils.findPlanForAllItems(
7    SourcingExecutionParameters.builder()
8        .context(context)
9        .sourcingContext(sourcingContext)
10        .positionStatuses(ImmutableList.of(Constants.Status.ACTIVE))
11        .build(),
12    virtualCatalogueRef,
13    locations,
14    sourcingCriteria,
15    maxSplit
16);

`findHighestValuePartialFulfilment()`

This helper method is used by the `findPlanBasedOnFallbackStrategies` method to find the highest-value partial fulfillment. It filters out excluded locations, compares each candidate's rating based on the remaining unfulfilled items at that iteration, and checks whether the location can cover at least part of the remaining items. The method returns the best fulfillment found or none if no positive-value option exists.

1Set<String> excludedLocations = Set.of("warehouse-001", "store-002");
2Optional<Fulfilment> partialFulfilmentOpt = SourcingUtils.findHighestValuePartialFulfilment(
3    locationAndPositions,
4    unfulfilledItems,
5    excludedLocations
6);
7
8if (partialFulfilmentOpt.isPresent()) {
9    Fulfilment partialFulfilment = partialFulfilmentOpt.get();
10    
11    // Calculate remaining items after partial fulfillment
12    List<OrderItem> remainingItems = OrderUtils.itemsMinusFulfilments(
13        unfulfilledItems,
14        Arrays.asList(partialFulfilment)
15    );
16    
17    // Create the partial fulfillment
18    OrderUtils.fillFulfilmentType(sourcingContext, Arrays.asList(partialFulfilment));
19    OrderUtils.createFulfilments(context, sourcingContext, Arrays.asList(partialFulfilment));
20    
21    context.action().log("Created partial fulfillment with {} items", 
22        partialFulfilment.getItems().size());
23}

`findPartialFulfilmentPlan()`

Builds a greedy partial fulfillment plan by repeatedly calling `findHighestValuePartialFulfilment` until the `maxSplit` limit is reached or all unfulfilled items are covered. Location ratings are recalculated after each allocation iteration.Use `getBasedOnFallbackStrategiesPlanFinder` to obtain a pre-loaded `SourcingPlanFinder`, then wrap it (for example, for multi-attempt location exclusion) before calling `findPartialFulfilmentPlan` in a loop.

1SourcingPlanFinder fallbackFinder = SourcingUtils.getBasedOnFallbackStrategiesPlanFinder(
2    SourcingExecutionParameters.builder()
3        .context(context)
4        .sourcingContext(sourcingContext)
5        .profile(profile)
6        .positionStatuses(ImmutableList.of(Constants.Status.ACTIVE))
7        .build()
8);
9SourcingPlan partialPlan = SourcingUtils.findPartialFulfilmentPlan(
10    sourcingContext,
11    fallbackStrategy,
12    unfulfilledItems,
13    locationsWithPositions,
14    criteria,
15    locationLimit,
16    maxSplit
17);

`loadPositions()`

Loads virtual positions for sourcing operations. This method is used by both core methods (`findPlanForAllItems` and `findPlanBasedOnFallbackStrategies`) to load inventory.

1List<LocationAndPositions> locationAndPositions = SourcingUtils.loadPositions(
2    SourcingExecutionParameters.builder()
3        .context(context)
4        .sourcingContext(sourcingContext)
5        .positionStatuses(ImmutableList.of(Constants.Status.ACTIVE))
6        .build(),
7    sourcingCriteria,
8    virtualCatalogueRef,
9    locations
10);

`loadSourcingProfile()`

Loads the sourcing profile for the current context.

1SourcingProfile profile = SourcingUtils.loadSourcingProfile(context);
2if (profile != null) {
3    SourcingPlan plan = SourcingUtils.findPlanBasedOnStrategies(
4        SourcingExecutionParameters.builder()
5            .context(context)
6            .sourcingContext(sourcingContext)
7            .profile(profile)
8            .positionStatuses(ImmutableList.of(Constants.Status.ACTIVE))
9            .build()
10    );
11}

Sourcing Profile Reference

The rule property referencing the sourcing profile should be named `sourcingProfileRef`.

`getUnfulfilledItems()`

Computes outstanding order items after accounting for allocated but non-rejected quantities.

1List<OrderItem> unfulfilledItems = SourcingUtils.getUnfulfilledItems(sourcingContext);

`getNetworkRef()`

Gets the network reference from a sourcing profile or strategy.

1String networkRef = SourcingUtils.getNetworkRef(profile, strategy);

`getVirtualCatalogueRef()`

Gets the virtual catalog reference from a sourcing profile or strategy.

1String catalogueRef = SourcingUtils.getVirtualCatalogueRef(profile, strategy);

`getMaxSplit()`

Gets the maximum split value from a sourcing profile or strategy.

1Integer maxSplit = SourcingUtils.getMaxSplit(profile, strategy);

`getSourcingPlanAudit()`

Returns the `SourcingPlanAudit` attached to a plan. It is always non-null and carries the full decision: the overall status (`FULLY_SOURCED`, `PARTIALLY_SOURCED`, or `NOT_SOURCED`), the sourcing type (`PRIMARY` or `FALLBACK`), the evaluated strategies, the applied Sourcing Profile, the requested Items, and the considered location count.

1SourcingPlanAudit audit = plan.getSourcingPlanAudit();
2String status = audit.getStatus();      // FULLY_SOURCED / PARTIALLY_SOURCED / NOT_SOURCED
3String type = audit.getType();          // PRIMARY / FALLBACK
4List<SourcingAuditStrategy> strategies = audit.getStrategies();
5SourcingProfile profile = audit.getSourcingProfile();

Overview

This article provides technical users with information about the Sourcing Auditability GraphQL API, which writes and reads Sourcing Audit records within the Responsive Sourcing Framework.

Key points

Prerequisites: You should have knowledge of: GraphQL API, Responsive Sourcing Framework, and the Sourcing Auditability Overview
The API exposes two operations: the `createSourcingAudit` mutation (write) and the `sourcingAudits` query (read)
Specific permissions are required: `SOURCINGAUDIT_CREATE` for the mutation, `SOURCINGAUDIT_VIEW` for the query, and `SOURCINGPROFILE_VIEW` to resolve the Sourcing Profile on a returned record
The write path enforces one payload limit - at most 100 Locations for the Strategy that produced the Fulfillments - so records stay bounded
The query returns a Relay-style connection with `cursor` pagination; the default page size is 10 and each `cursor` is an opaque Base64 pagination token
Positional quantity arrays align to the master `items` list by 0-based index: `missingItemQuantities` (per Location) and `itemQuantities` (per Fulfillment) each carry one entry per Item

What is the Sourcing Auditability GraphQL API for?

The Sourcing Auditability GraphQL API lets technical users work with the Sourcing Audit records that the Responsive Sourcing Framework produces:

Write a completed Sourcing Audit record with the `createSourcingAudit` mutation
The Sourcing Rules call this at the end of a sourcing execution
Read the Sourcing Audit records for an Order or Fulfillment Choice with the `sourcingAudits` query

For consumers the API is read-oriented: the platform writes each record once, with no updates or deletes.

Reminder

A Sourcing Audit is an immutable record of a single Sourcing Request. For the architectural context, storage rationale, and how audits appear in the Fluent Order Management System (OMS) Web App, see the Sourcing Auditability Overview.

How the API Works

The following diagram explains the Sourcing Auditability GraphQL API behavior:

The Sourcing Rules generate an audit at the end of each completed Sourcing Request
The write path validates the payload and enforces the write limit before persisting the record
The read path checks permission on the parent entity before returning any data, then returns only the records for the requested page - for an `ORDER` request, the records for the Order and all its Fulfillment Choices

Audit Failure Handling

A failed `createSourcingAudit` call does not reverse the sourcing outcome - the Sourcing Rules log the failure and continue.

Data Model

The following data model outlines the Sourcing Auditability entities:

Recommended practice

For the up-to-date data model we recommend to always refer back to the GraphQL Explorer.

Entities

The core Sourcing Auditability entities are:

Entity	Description
`SourcingAudit`	The root immutable record of one Sourcing Request - its inputs, evaluation, and outcome for an Order or Fulfillment Choice Returned by `sourcingAudits` Identified by: `entityType` `entityId` (internal id) `entityRef` (human-readable reference)
`SourcingAuditItem`	A requested Item and its quantity The `items` list is the master, positionally-referenced Item list for the whole record Stores no price data
`SourcingAuditStrategy`	The evaluation detail for one Sourcing Strategy considered during the request: Its outcome (`SKIPPED` / `EVALUATED` / `NOT_CONSIDERED`) Condition results For a successful Strategy: Produced Fulfillments Considered Locations
`SourcingAuditStrategyLocation`	A Location considered by the successful Strategy, with: Its per-Criterion scores Quantity of each Item it could not fulfill Up to 100 Locations stored only for the successful Strategy
`SourcingAuditStrategyFulfilment`	A Fulfillment produced by the successful Strategy: The Location selected for it The quantity of each Item allocated
`SourcingAuditConnection` / `SourcingAuditEdge`	The Relay-style pagination envelope returned by `sourcingAudits` Each edge wraps a `SourcingAudit` node with an opaque `cursor` used for pagination

Relationship Details

The following relationships define the Sourcing Auditability data model:

Relationship	Type	Description
Connection to Edges	One `SourcingAuditConnection` to many `SourcingAuditEdge`	The `sourcingAudits` query envelope `edges` holds one edge per returned record and `pageInfo` carries the Relay pagination flags
Edge to Audit	One `SourcingAuditEdge` to one `SourcingAudit`	Each edge wraps a single `SourcingAudit` in its `node`, with an opaque `cursor` used for pagination
Audit to Items	One `SourcingAudit` to many `SourcingAuditItem`	The `items` list is the master, positionally-significant Item list for the Sourcing Request (at least one Item) Every quantity array elsewhere in the record aligns to it by 0-based index
Audit to Strategies	One `SourcingAudit` to many `SourcingAuditStrategy`	The Strategies considered during evaluation, held in priority (execution) order
Audit to Profile	One `SourcingAudit` to one `SourcingProfile`	The Sourcing Profile and version used for the decision Resolved at read time and populated only if the caller holds `SOURCINGPROFILE_VIEW`; otherwise `null`
Strategy to Locations	One `SourcingAuditStrategy` to many `SourcingAuditStrategyLocation`	Per-Location evaluation detail Populated only for the Strategy with status `EVALUATED` that produced the Fulfillments - up to 100 Locations
Strategy to Fulfillments	One `SourcingAuditStrategy` to many `SourcingAuditStrategyFulfilment`	The Fulfillments the Strategy produced, each paired with the Location selected for it
Fulfillment to selected Location	One `SourcingAuditStrategyFulfilment` to one `SourcingAuditStrategyLocation`	`selectedLocationPosition` is a 0-based index into the Strategy's `locations` list `location` is the resolved entry - equivalent to `locations[selectedLocationPosition]`

Condition and Criteria Results

The `conditions` and `criteria` fields use the `Json` scalar and hold compact, positional arrays. Their object shapes are:

Field	Shape (one entry per element)	Description
`conditions` (on `SourcingAuditStrategy`)	`{ "p": boolean, "a": value }` - one entry per Condition, in evaluation order	`p` is whether the Condition passed `a` is the actual value from the Order or Fulfillment Choice the Condition was evaluated against, in its original type (for example `"Australia"` for a delivery-country Condition). `a` is always present
`criteria` (on `SourcingAuditStrategyLocation`)	`{ "n": number, "a": value }` - one entry per Criterion, aligned to the Criteria on the corresponding Strategy	`n` is the normalized value (0 to 1) used for ranking `a` is the optional actual value before normalization (for example, the exact distance in km for a `locationDistance` Criterion)

Operations

The Sourcing Auditability GraphQL API exposes one write operation and one read operation - the `createSourcingAudit` mutation and the `sourcingAudits` query - each governed by its own permission. The mutation stores a record; the query returns the stored records for an entity.

Permissions

The following permissions apply to the Sourcing Auditability GraphQL API:

Permission	Applies to	Purpose
`SOURCINGAUDIT_CREATE`	`createSourcingAudit` mutation	Write a Sourcing Audit record
`SOURCINGAUDIT_VIEW`	`sourcingAudits` query	Read Sourcing Audit records for an entity
`SOURCINGPROFILE_VIEW`	`sourcingAudits` query	Resolve and return the `profile` on a record Without it, `profile` is `null`

Query Permission Check

The query enforces the permission against the parent entity (the Order or Fulfillment Choice) before it reads any storage, so an unauthorized or missing parent yields an error before any records are read.

Mutation

`createSourcingAudit` writes a completed Sourcing Audit record. The Sourcing Rules call it at the end of a Sourcing Request; it is not part of a typical integration flow.

Permission: `SOURCINGAUDIT_CREATE`
Input: `CreateSourcingAuditInput!`

Mutation Write Limit

The mutation enforces a single write limit:

The Strategy that produced the Fulfillments (the successful Strategy, with status `EVALUATED`) must contain at most 100 Locations, or the API rejects the mutation
A Strategy without Fulfillments records no per-Location detail

The Sourcing Utilities independently truncate per-Location detail to 100 Locations after evaluation, so the 100-Location cap applies on both the generating and the storing side.

Example

1mutation createSourcingAudit($input: CreateSourcingAuditInput!) {
2  createSourcingAudit(input: $input) {
3    ref
4    entityType
5    entityId
6    entityRef
7    status
8    createdOn
9  }
10}

1{
2  "input": {
3    "ref": "SA-000001",
4    "entityType": "FULFILMENT_CHOICE",
5    "entityId": "789012",
6    "entityRef": "ORD-100123-1",
7    "retailer": { "id": "1" },
8    "type": "FALLBACK",
9    "status": "PARTIALLY_SOURCED",
10    "profile": { "ref": "ANZ_DEFAULT", "version": 3 },
11    "locationCount": 2,
12    "items": [
13      { "orderItemRef": "OI-1", "productRef": "SKU-BEA-1042", "productName": "Hydra-Glow Vitamin C Serum 30ml", "quantity": 5 },
14      { "orderItemRef": "OI-2", "productRef": "SKU-FAS-7781", "productName": "Merino Wool Crew Knit - Charcoal (M)", "quantity": 3 },
15      { "orderItemRef": "OI-3", "productRef": "SKU-PHA-3305", "productName": "Paracetamol 500mg Tablets - 24 Pack", "quantity": 2 }
16    ],
17    "strategies": [
18      {
19        "strategyRef": "b8e7c1a0-4f2d-4c8e-9a1b-2f6d3e5c7a90",
20        "status": "SKIPPED",
21        "evaluatedOn": "2026-08-17T09:30:00Z",
22        "locationCount": 0,
23        "conditions": [ { "p": false, "a": "STANDARD" } ]
24      },
25      {
26        "strategyRef": "c3d9f2b1-5a7e-4b6c-8d0f-1e2a3b4c5d6e",
27        "status": "EVALUATED",
28        "evaluatedOn": "2026-08-17T09:30:00Z",
29        "locationCount": 2,
30        "conditions": [ { "p": true, "a": "NSW" } ],
31        "locations": [
32          { "locationRef": "SYD01", "locationName": "Sydney CBD", "criteria": [ { "n": 1, "a": 2.4 } ], "missingItemQuantities": [ 0, 2, 0 ] },
33          { "locationRef": "MEL01", "locationName": "Melbourne Central", "criteria": [ { "n": 0.61, "a": 713.4 } ], "missingItemQuantities": [ 0, 3, 0 ] }
34        ],
35        "fulfilments": [
36          {
37            "fulfilmentRef": "FUL-1",
38            "selectedLocationPosition": 0,
39            "location": { "locationRef": "SYD01", "locationName": "Sydney CBD", "criteria": [ { "n": 1, "a": 2.4 } ], "missingItemQuantities": [ 0, 2, 0 ] },
40            "itemQuantities": [ 5, 1, 2 ]
41          }
42        ]
43      }
44    ]
45  }
46}

Language: json

Name: Sample createSourcingAudit input

Description:

Example input for a partially-sourced `FALLBACK` Sourcing Request.`entityRef` (required) is the sourced Fulfillment Choice's human-readable reference; `entityId` is its internal id. `entityType` accepts `ORDER` or `FULFILMENT_CHOICE`, but the Sourcing Rules write `FULFILMENT_CHOICE`.Shows the positional quantity arrays and the compact `conditions` / `criteria` shapes: the first Strategy is skipped (its express-only Condition fails), the second is evaluated and fulfills from the best-ranked of two candidate Locations, leaving one Item short. Each Fulfillment carries both `selectedLocationPosition` and the resolved `location` object (both required on input).

1{
2  "data": {
3    "createSourcingAudit": {
4      "ref": "SA-000001",
5      "entityType": "FULFILMENT_CHOICE",
6      "entityId": "789012",
7      "entityRef": "ORD-100123-1",
8      "status": "PARTIALLY_SOURCED",
9      "createdOn": "2026-08-17T09:30:00.000+00:00"
10    }
11  }
12}

Query

`sourcingAudits` retrieves the Sourcing Audit records for an Order or Fulfillment Choice.

Tip

Query by `ORDER` with the Order Id to retrieve the audits for the Order and all its Fulfillment Choices
Query by `FULFILMENT_CHOICE` with the Fulfillment Choice id for a single Fulfillment Choice.

The Sourcing Rules record each audit against the Fulfillment Choice that was sourced - or against the Order itself when that Fulfillment Choice has no reference (due to provided create order input) - so an `ORDER` query returns both, aggregated across the Order.

Permission: `SOURCINGAUDIT_VIEW` (plus `SOURCINGPROFILE_VIEW` to populate `profile`)
Complexity cost: `@complexityCost(value: 400)`
Returns: `SourcingAuditConnection`

Inputs

Argument	Type	Required	Description
`entityType`	`String!`	✅	The audited entity type: `ORDER` Returns the audits for the Order and all its Fulfillment Choices `FULFILMENT_CHOICE` A single Fulfillment Choice
`entityId`	`ID!`	✅	The audited entity identifier
`first`	`Int`	❌	Relay forward pagination - number of records after `after` Default page size is 10
`after`	`String`	❌	Cursor to page forward from
`last`	`Int`	❌	Relay backward pagination - number of records before `before`
`before`	`String`	❌	Cursor to page backward from

Pagination and cursors

Records are returned newest-first. Each `cursor` in the connection is an opaque Base64 token; treat it as a value to pass back, not to parse. The connection's `pageInfo` exposes `hasNextPage` and `hasPreviousPage`. To page forward, pass the last edge's `cursor` as the `after` argument.

Example

1query sourcingAudits($entityType: String!, $entityId: ID!, $first: Int, $after: String) {
2  sourcingAudits(entityType: $entityType, entityId: $entityId, first: $first, after: $after) {
3    edges {
4      cursor
5      node {
6        ref
7        entityType
8        entityId
9        entityRef
10        type
11        status
12        createdOn
13        locationCount
14        profile { ref version }
15        items { orderItemRef productRef productName quantity }
16        strategies {
17          strategyRef
18          status
19          evaluatedOn
20          locationCount
21          conditions
22          locations { locationRef locationName criteria missingItemQuantities }
23          fulfilments { fulfilmentRef selectedLocationPosition itemQuantities }
24        }
25      }
26    }
27    pageInfo { hasNextPage hasPreviousPage }
28  }
29}

1{
2  "entityType": "ORDER",
3  "entityId": "123456",
4  "first": 10
5}

1{
2  "data": {
3    "sourcingAudits": {
4      "edges": [
5        {
6          "cursor": "Y3Vyc29yOi0tLTIwMjYtMDgtMTdUMDktMzAtMDEuMDAwWi1mYjAwMDAwMS5neg==",
7          "node": {
8            "ref": "SA-000001",
9            "entityType": "FULFILMENT_CHOICE",
10            "entityId": "789012",
11            "entityRef": "ORD-100123-1",
12            "type": "FALLBACK",
13            "status": "PARTIALLY_SOURCED",
14            "createdOn": "2026-08-17T09:30:01.000+00:00",
15            "locationCount": 2,
16            "profile": { "ref": "ANZ_DEFAULT", "version": 3 },
17            "items": [
18              { "orderItemRef": "OI-1", "productRef": "SKU-BEA-1042", "productName": "Hydra-Glow Vitamin C Serum 30ml", "quantity": 5 },
19              { "orderItemRef": "OI-2", "productRef": "SKU-FAS-7781", "productName": "Merino Wool Crew Knit - Charcoal (M)", "quantity": 3 },
20              { "orderItemRef": "OI-3", "productRef": "SKU-PHA-3305", "productName": "Paracetamol 500mg Tablets - 24 Pack", "quantity": 2 }
21            ],
22            "strategies": [
23              {
24                "strategyRef": "b8e7c1a0-4f2d-4c8e-9a1b-2f6d3e5c7a90",
25                "status": "SKIPPED",
26                "evaluatedOn": "2026-08-17T09:30:01.000+00:00",
27                "locationCount": 0,
28                "conditions": [ { "p": false, "a": "STANDARD" } ],
29                "locations": [],
30                "fulfilments": []
31              },
32              {
33                "strategyRef": "c3d9f2b1-5a7e-4b6c-8d0f-1e2a3b4c5d6e",
34                "status": "EVALUATED",
35                "evaluatedOn": "2026-08-17T09:30:01.000+00:00",
36                "locationCount": 2,
37                "conditions": [ { "p": true, "a": "NSW" } ],
38                "locations": [
39                  { "locationRef": "SYD01", "locationName": "Sydney CBD", "criteria": [ { "n": 1, "a": 2.4 } ], "missingItemQuantities": [ 0, 2, 0 ] },
40                  { "locationRef": "MEL01", "locationName": "Melbourne Central", "criteria": [ { "n": 0.61, "a": 713.4 } ], "missingItemQuantities": [ 0, 3, 0 ] }
41                ],
42                "fulfilments": [
43                  { "fulfilmentRef": "FUL-1", "selectedLocationPosition": 0, "itemQuantities": [ 5, 1, 2 ] }
44                ]
45              }
46            ]
47          }
48        },
49        {
50          "cursor": "Y3Vyc29yOi0tLTIwMjYtMDgtMTdUMDktMzAtMDAuMDAwWi1wcjAwMDAwMC5neg==",
51          "node": {
52            "ref": "SA-000000",
53            "entityType": "FULFILMENT_CHOICE",
54            "entityId": "789012",
55            "entityRef": "ORD-100123-1",
56            "type": "PRIMARY",
57            "status": "NOT_SOURCED",
58            "createdOn": "2026-08-17T09:30:00.000+00:00",
59            "locationCount": 2,
60            "profile": { "ref": "ANZ_DEFAULT", "version": 3 },
61            "items": [
62              { "orderItemRef": "OI-1", "productRef": "SKU-BEA-1042", "productName": "Hydra-Glow Vitamin C Serum 30ml", "quantity": 5 },
63              { "orderItemRef": "OI-2", "productRef": "SKU-FAS-7781", "productName": "Merino Wool Crew Knit - Charcoal (M)", "quantity": 3 },
64              { "orderItemRef": "OI-3", "productRef": "SKU-PHA-3305", "productName": "Paracetamol 500mg Tablets - 24 Pack", "quantity": 2 }
65            ],
66            "strategies": [
67              {
68                "strategyRef": "a1c4f6e2-8d7b-4e39-b0a2-6c9f1d3e5a72",
69                "status": "SKIPPED",
70                "evaluatedOn": "2026-08-17T09:30:00.000+00:00",
71                "locationCount": 0,
72                "conditions": [ { "p": false, "a": "STANDARD" } ],
73                "locations": [],
74                "fulfilments": []
75              },
76              {
77                "strategyRef": "d4b0e9a7-1c62-4f8d-a3b5-7e9c0d2f4a13",
78                "status": "EVALUATED",
79                "evaluatedOn": "2026-08-17T09:30:00.000+00:00",
80                "locationCount": 2,
81                "conditions": [ { "p": true, "a": "NSW" } ],
82                "locations": [],
83                "fulfilments": []
84              }
85            ]
86          }
87        }
88      ],
89      "pageInfo": { "hasNextPage": false, "hasPreviousPage": false }
90    }
91  }
92}

Language: json

Name: Sample response for sourcingAudits

Description:

The full read for one Order. The Order was sourced in two passes, so `sourcingAudits` returns two records, newest-first. 1. The initial `PRIMARY` audit is `NOT_SOURCED` - its first Strategy was skipped (an express-only Condition failed) and its second Strategy was evaluated but produced no Fulfillments, so neither carries per-Location detail. 2. The subsequent `FALLBACK` audit (the record written by the mutation above) is `PARTIALLY_SOURCED` - its evaluated Strategy ranked two candidate Locations and fulfilled the Order from the best-ranked one, leaving one Item short. Per-Location detail (ranked candidates with their `criteria` scores and `missingItemQuantities`) appears only on the evaluated Strategy that produced the Fulfillments.Timestamps are returned in offset format and each `cursor` is an opaque Base64 token.

Selected Location Position

Within each returned Strategy, `locations` are ordered by rank (best first), so the selected Location is typically at `selectedLocationPosition: 0`.

Overview

Key points

Prerequisites: Understand what Sourcing Auditability captures and how audit records are stored. See the Sourcing Auditability Overview
The tab appears only for users who hold `SOURCINGAUDIT_VIEW`. The resolved Sourcing Profile is shown only to users who also hold `SOURCINGPROFILE_VIEW`
Sourcing Audit records are immutable and cannot be changed from the interface
Each row in the Sourcing Requests list is one Sourcing Request. A single order can produce more than one Sourcing Request
The tab retrieves audit data through the `sourcingAudits` query for the current Order and its Fulfillment Choices

Where to Find the Sourcing Tab

Open Order Management, select an order from the Orders list, then open the Sourcing tab on the Order Detail screen. The tab sits in the tab bar alongside Details, Fulfillments, Transactions, Attributes, Returns, Comments, and Activity. No alt provided

Permissions

Access to the Sourcing tab and its data is controlled by two permissions:

`SOURCINGAUDIT_VIEW` - required to see the Sourcing tab and read Sourcing Audit records
`SOURCINGPROFILE_VIEW` - required to see the resolved Sourcing Profile and version on each request

Users without `SOURCINGAUDIT_VIEW` do not see the Sourcing tab.

Sourcing Requests

The Sourcing Requests list shows one row for each Sourcing Request. Each row summarizes the request:

Column	Description
Entity Type	The type of entity the request sourced - `ORDER` or `FULFILMENT_CHOICE`
Entity Ref	The reference of that entity
Requested At	When the Sourcing Request ran
Strategy Type	`PRIMARY` or `FALLBACK`
Sourcing Profile	The resolved Sourcing Profile and version, shown only with `SOURCINGPROFILE_VIEW`
Active Strategy	The Strategy that produced the Fulfillments
Items	The number of items the request sourced
Fulfillments Allocated	The number of Fulfillments the request produced
Status	`FULLY_SOURCED`, `PARTIALLY_SOURCED`, or `NOT_SOURCED`

Request Summary

When you expand a Sourcing Request, a set of summary tiles reports its headline figures:

Fulfillments Allocated - the number of Fulfillments produced
Locations Considered - the number of distinct Locations evaluated across all Strategies
Strategies Skipped - the number of Strategies skipped because a Condition failed
Strategies Evaluated - the number of Strategies whose Conditions passed and that were evaluated

Items for Sourcing

The Items for Sourcing table lists the items the request tried to source:

Column	Description
Order Item Ref	The order item reference
Product Ref	The product reference
Product Name	The product name
Quantity	The quantity requested

Strategy Evaluation

The Strategy Evaluation section lists the Strategies in the order they were evaluated. Strategies run in priority order, a Strategy is skipped if any of its Conditions fail, and the first Strategy whose Conditions all pass proceeds to Location scoring.Each Strategy shows its outcome:

Evaluated - the Strategy's Conditions passed and the Strategy was evaluated
Skipped - at least one Condition failed, so the Strategy did not run
Not Considered - an earlier Strategy already passed its Conditions, was evaluated, and created Fulfillment(s), so this Strategy was not reached

Expand a Strategy to see its Conditions, the value each Condition was evaluated against, and a pass or fail result for each. No alt provided

See also

Sourcing Result Enricher Component - prepares the audit data this tab shows (resolves Strategy names and the Condition/Criterion values).

Fulfillments and Location Comparison

For the Strategy that produced the Fulfillments, the tab lists each Fulfillment by reference. Expand a Fulfillment to see the items it covers and to compare the Locations the Strategy evaluated.Location Comparison lets you compare the selected Location against another candidate that the same Strategy evaluated.For each Location, the comparison shows:

Its ranking position within the Strategy's candidate list
Each Criterion, its Score (the normalized value), and, where available, the Actual value before normalization
Any missing items the Location could not fulfill

Score and Actual value are displayed rounded to 2 decimal places. No alt provided

See also

Location Comparison Component - the component that renders this side-by-side comparison.

How Sourcing Auditability Works

Overview

Sourcing Auditability Overview

Overview

Key points

What Is Sourcing Auditability?

Value Proposition

How It Works

What Gets Captured

Reviewing Audits in the OMS Web App

Explanation Through an Example

Related content

Responsive Sourcing Framework Overview

Sourcing Auditability GraphQL API Overview

Sourcing Audits in Fluent OMS Web App

How Sourcing Utilities work

Sourcing Utilities Overview

Overview

Key points

Value Proposition

Explanation through an Example

How Sourcing Utilities Help

What Happens Behind the Scenes

Related content

Sourcing Utilities

How Sourcing Utilities work

Sourcing Utils

Sourcing Context Utils

Order Utils

Location Utils

Fulfillment Options Utils

Sourcing Auditability Overview

Sourcing Utils

Overview

Key points

Core Methods

`getPlanFinder()`

`findPlanBasedOnStrategies()`

`getBasedOnStrategiesPlanFinder()`

`findPlanBasedOnFallbackStrategies()`

`getBasedOnFallbackStrategiesPlanFinder()`

`buildRejectedFulfilment()`

`captureAudit()`

Supporting Methods

`findPlanForAllItems()`

`findHighestValuePartialFulfilment()`

`findPartialFulfilmentPlan()`

`loadPositions()`

`loadSourcingProfile()`

`getUnfulfilledItems()`

`getNetworkRef()`

`getVirtualCatalogueRef()`

`getMaxSplit()`

`getSourcingPlanAudit()`

Related content

How Sourcing Utilities work

Sourcing Utilities Overview

Sourcing Auditability Overview

Sourcing Auditability GraphQL API Overview

Sourcing Auditability GraphQL API Overview

Overview

Key points

What is the Sourcing Auditability GraphQL API for?

How the API Works

Data Model

Entities

Relationship Details

Condition and Criteria Results

Operations

Permissions

Mutation

Example

Query

Inputs

Example

Related content

Sourcing Auditability Overview

Responsive Sourcing Framework Overview

How Sourcing Utilities work

How Sourcing Profile GraphQL API works