Summary: Complete reference of the pfx-api Camel component — the primary interface for all Pricefx API operations (load, fetch, delete, integrate, truncate, flush, etc.).
1. URI Format
pfx-api:method?param1=value1¶m2=value2
The component is producer-only (no consumer/polling support). The method path parameter is required and selects the API operation to perform. All other configuration is passed as URI query parameters, which map to the fields of PfxApiConfiguration.
Minimal example:
<to uri="pfx-api:fetch?objectType=P&filter=myFilter"/>
2. Available Methods
The following methods are registered in PfxApiProducer and dispatched by the method path parameter.
|
Method |
Aliases |
Description |
Key Parameters |
Typical Object Types |
|---|---|---|---|---|
|
|
-- |
Bulk-load data into Pricefx objects (products, customers, pricing parameters, data sources, datamarts, etc.) |
|
P, C, PX, CX, LTV, MLTV, DMDS, and all extension types |
|
|
-- |
Load data from a file (compressed/batched). With |
|
Same as |
|
|
-- |
Fetch (export) data from any supported Pricefx object. Supports batched mode for large data sets. |
|
All object types |
|
|
-- |
Fetch data and write directly to a CSV file. Sets statistics headers on the exchange. |
|
All object types |
|
|
-- |
Continue a batched fetch iteration (used internally with |
(reads from exchange) |
-- |
|
|
-- |
Fetch a field collection structure. If |
|
CFS and related |
|
|
-- |
Upsert data into Pricefx using business-key matching. Existing records are updated; new records are inserted. |
|
P, C, PX, CX, LTV, MLTV, PR, RR, and extension types |
|
|
-- |
Flush data from a Datamart data feed to a data source. |
|
DM/DMDS |
|
|
-- |
Truncate a data feed, data source, or Datamart. |
|
DF, DS, DM |
|
|
-- |
Refresh a Datamart. Available from v1.1.15. |
|
DM |
|
|
-- |
Delete records by filter or typedId. Supports async mode. |
|
All object types |
|
|
-- |
Calculate (recalculate) values -- Datamart derived columns, CFS, Price Lists, etc. |
|
DM, CFS, PL, PG |
|
|
-- |
Execute a Pricefx formula. |
|
F (Formula) |
|
|
-- |
Update a single record by typedId. Body must be the data map. |
|
All object types |
|
|
-- |
Save (create or full-replace) a single record. Body must be the data map with |
|
All object types |
|
|
|
Mass-edit records matching a filter. |
|
All object types |
|
|
-- |
Fetch customers assigned to a customer group. |
|
C (Customer) |
|
|
-- |
Trigger customer Datamart load. |
|
C (Customer) |
|
|
-- |
Trigger product Datamart load. |
|
P (Product) |
|
|
-- |
Cancel an ongoing operation by typedId. |
|
-- |
|
|
|
Reset a column on a given object. |
|
-- |
|
|
|
Internal copy of a Pricefx entity (e.g., duplicate a price list). |
|
-- |
|
|
|
Add products to a Quote. |
|
Q (Quote) |
|
|
-- |
Server-side import using the Pricefx Import API. Reads CSV/file from body or staging. |
|
All loadable types |
|
|
-- |
Import data into a Datamart via the DM Import API. Body is the data. |
|
DM, DMDS |
|
|
-- |
Export data from a Datamart. |
|
DM, DMDS |
|
|
|
Upsert price list or live price grid items. |
|
PLI, LPG, XPLI |
|
|
-- |
Import users into Pricefx. Can also be triggered via |
|
U (User) |
|
|
-- |
Upload a product image. File name is read from |
|
P (Product) |
|
|
-- |
Trigger a distributed calculation job. |
|
DM |
|
|
-- |
Create a new revision of a Pricefx entity (e.g., Price List, Quote). |
|
PL, Q, RBA |
|
|
-- |
Duplicate a Custom Form. |
|
CFO |
|
|
-- |
Change the workflow status of a Custom Form. |
|
CFO |
|
|
-- |
Trigger a named dataload job on Pricefx. |
|
-- |
|
|
-- |
Fetch rebate agreement line items. Exchange body is used as the input data object. |
(body as input) |
RBA |
|
|
-- |
Upload binary data via the BD Manager. |
|
BD |
3. URI Parameters
All parameters below are declared as @UriParam on PfxApiConfiguration and can be set in the endpoint URI or injected via Camel property placeholders.
|
Parameter |
Type |
Default |
Description |
|---|---|---|---|
|
|
|
-- |
The Pricefx object type (e.g., |
|
|
|
-- |
Name of the Pricefx connection bean. Optional -- if omitted the Spring bean named |
|
|
|
-- |
Name of the mapper bean (or header/property reference) used to transform data before sending to Pricefx. |
|
|
|
-- |
Name of the filter bean used by |
|
|
|
-- |
SQL-like syntax as an alternative to |
|
|
|
-- |
Advanced custom filter expression for comparing columns instead of values. |
|
|
|
-- |
The |
|
|
|
-- |
Comma-separated list of typedIds. Used by |
|
|
|
-- |
Unique name of a Data Source or Datamart. Resolves to |
|
|
|
-- |
Unique name for the Quote API. Resolves to |
|
|
|
-- |
Unique name for Data Change Request API. Resolves to |
|
|
|
-- |
Pricing parameter ID (for Lookup Tables / Matrix tables). |
|
|
|
-- |
Pricing parameter name (for Lookup Table values). |
|
|
|
-- |
Condition Record Set ID. |
|
|
|
-- |
Condition Record Set name. |
|
|
|
-- |
Comma-separated business key field names for |
|
|
|
-- |
Comma-separated max lengths for business key fields. |
|
|
|
|
Whether join field definitions should be auto-detected from the server. |
|
|
|
|
Strategy for join fields. Values: |
|
|
|
-- |
Start row for |
|
|
|
-- |
End row for |
|
|
|
-- |
If |
|
|
|
|
Enable batched fetching for large data sets. |
|
|
|
|
Number of rows per batch when |
|
|
|
-- |
Comma-separated field names to include in the result. All fields are fetched from DB; filtering happens in the response. Result is a Map. |
|
|
|
-- |
Comma-separated field names to fetch from the database (server-side projection for better performance). Result is a list of field values, not a Map. |
|
|
|
-- |
Sort-by clause. Overrides any |
|
|
|
|
Whether null fields should be returned via the REST API. |
|
|
|
|
Add a DISTINCT clause to the search query. |
|
|
|
-- |
Output format for |
|
|
|
|
Use human-readable column names (e.g., "Attribute 1") instead of attribute codes in CSV output. |
|
|
|
-- |
Target data source name for |
|
|
|
-- |
Source data feed name for |
|
|
|
-- |
Incremental date for |
|
|
|
-- |
Incremental flag for |
|
|
|
|
If |
|
|
|
|
Used by |
|
|
|
-- |
Target name for |
|
|
|
-- |
Filter expression on the target, used by |
|
|
|
-- |
Condition for |
|
|
|
-- |
Label for the target object. Used by |
|
|
|
-- |
SKU for |
|
|
|
-- |
Formula name for |
|
|
|
-- |
Price List ID for fetch/upsert operations. |
|
|
|
-- |
Price List Item ID. |
|
|
|
-- |
Where to store the API response in the exchange. Values: |
|
|
|
-- |
Name of the exchange header or property when |
|
|
|
-- |
Data auto-conversion strategy. Values: |
|
|
|
-- |
Field definitions for the |
|
|
|
-- |
Column name for the |
|
|
|
-- |
File name for |
|
|
|
-- |
Staging file reference for |
|
|
|
|
Whether the staging file should be deleted after import completes. |
|
|
|
|
Whether to truncate the target before importing. Used by |
|
|
|
|
Whether to de-duplicate records during import. |
|
|
|
|
Whether to skip indexing during import. |
|
|
|
|
Whether the datamart import runs with |
|
|
|
|
Maximum rows for |
|
|
|
|
Suffix for |
|
|
|
|
Run the operation asynchronously. Supported on |
|
|
|
|
Timeout (ms) for async operations. For |
|
|
|
|
Poll interval (ms) between JST status checks. |
|
|
|
|
How IM waits for the async JST jobs of |
|
|
|
-- |
Comma-separated SKUs for |
|
|
|
-- |
Parent property for |
|
|
|
|
CSV delimiter for |
|
|
|
|
Quote character for |
|
|
|
|
Escape character for |
|
|
|
|
String representing null in import input. |
|
|
|
`\r |
|
|
| |
ecord separator (end of line) for import input. | |
||
|
|
|
-- |
Comma-separated column headers for |
|
|
|
-- |
For |
|
|
|
-- |
Operation for |
|
|
|
-- |
Model Table name. |
|
|
|
-- |
Parent Model name for a Model Table. |
|
|
|
-- |
Type of dataload to run (used with |
|
|
|
|
Whether |
|
|
|
|
Whether |
|
|
|
|
Whether |
4. Common Patterns
4.0 loaddataFile vs loaddata
Choose the import method based on your use case:
|
Method |
When to Use |
How It Works |
|---|---|---|
|
|
Default for all CSV imports (P, PX, C, CX, LTV, MLTV2) |
Streams the file directly to the Pricefx server. The server handles batching internally. Much faster for large files. |
|
|
When you need Groovy row-level transformations or complex logic per record |
IM parses and maps each record in memory, then sends via JSON API. Slower but more flexible. |
Batch size guidance for loaddataFile (based on number of fields per record):
|
Fields per Row |
Recommended batchSize |
|---|---|
|
< 10 fields |
|
|
10–20 fields |
|
|
20+ fields |
|
More fields per row = more memory per batch. Default for loaddata: 5000.
PX / CX: table name in mapper, not in URI
There is no extensionName parameter on loaddata or loaddataFile. For Product Extension (PX) and Customer Extension (CX) imports, the table name is set as a <constant> element in the mapper:
<loadMapper id="my-px-import.mapper">
<constant expression="Prices" out="name"/> <!-- Table name — required for PX/CX -->
<body in="sku" out="sku"/>
<body in="price" out="attribute1" converterExpression="stringToDecimal"/>
</loadMapper>
This <constant ... out="name"/> element is mandatory for PX and CX. Its position in the mapper does not matter.
4.1 Load Data (Import into Pricefx)
Load products into Pricefx using a mapper to transform the incoming data:
<route>
<from uri="direct:loadProducts"/>
<to uri="pfx-api:loaddata?objectType=P&mapper=productMapper&businessKeys=sku"/>
</route>
Load data into a Data Source:
<route>
<from uri="direct:loadDataSource"/>
<to uri="pfx-api:loaddata?objectType=DM&dsUniqueName=MyDataSource&mapper=dsMapper&businessKeys=sku,region"/>
<onCompletion onCompleteOnly="true">
<to uri="pfx-api:flush?objectType=DM&dsUniqueName=MyDataSource"/>
</onCompletion>
</route>
Load data from a file asynchronously (JST-tracked) and wait for the result. waitForCompletionStrategy has an effect only together with async=true; size asyncTimeout to the expected duration of the load:
<route>
<from uri="file:{{import.directory}}?{{archive.file}}&{{read.lock}}"/>
<to uri="pfx-api:loaddataFile?objectType=P&mapper=productMapper&businessKeys=sku&async=true&waitForCompletionStrategy=Always&asyncTimeout=3600000&asyncRetry=5000"/>
</route>
waitForCompletionStrategy - how IM waits for the async load
The strategy applies only to loaddataFile with async=true. Each async batch creates a JST job on the partition, and the submission itself returns immediately. The strategy tells IM what to do after it submits the batches:
|
Value |
Does IM wait for the jobs? |
Does a failed job fail the route? |
Use when |
|---|---|---|---|
|
|
No. The route continues immediately. |
No. Job results are never checked. |
Something else checks the jobs. Do not use in a normal dataload route. |
|
|
Yes. IM polls every |
Yes. |
The route result must reflect the load result. This is the correct setting for dataloads. |
|
|
Yes. Same polling as |
No. Failed jobs count as completed. Only a timeout fails the route. |
Partial loads are acceptable. The route only needs to know that the load has ended. |
Rules of thumb:
-
The default (
Never) does NOT wait. The route reports success even when the load fails. Set the strategy explicitly whenever the data must be in Pricefx before the route continues. -
Set
Alwayswhen a later step depends on the loaded data - a flush, a delete-after, a completion event, or the removal of the source file. -
Size
asyncTimeoutto the expected duration of the load. The 30 s default is too low for real dataloads.
4.2 Fetch (Export from Pricefx)
Fetch all products using a filter:
<route>
<from uri="direct:fetchProducts"/>
<to uri="pfx-api:fetch?objectType=P&filter=allProductsFilter"/>
</route>
Fetch with SQL-like filter syntax and pagination:
<route>
<from uri="direct:fetchFiltered"/>
<to uri="pfx-api:fetch?objectType=P&sql=SELECT sku, attribute1 WHERE attribute2 > 100 ORDER BY sku ASC&startRow=0&endRow=1000"/>
</route>
Fetch in batched mode for large data sets:
<route>
<from uri="direct:fetchBatched"/>
<to uri="pfx-api:fetch?objectType=DMDS&dsUniqueName=MyDS&filter=myFilter&batchedMode=true&batchSize=10000"/>
</route>
Fetch with CSV output:
<route>
<from uri="direct:fetchCsv"/>
<to uri="pfx-api:fetch?objectType=P&filter=myFilter&output=CSV&useColumnNames=true"/>
</route>
Fetch to CSV file (fetchToCsv method):
<route>
<from uri="direct:fetchToCsvFile"/>
<to uri="pfx-api:fetchToCsv?objectType=P&filter=myFilter&batchSize=5000"/>
</route>
4.3 Truncate
Truncate a Data Source:
<route>
<from uri="direct:truncateDS"/>
<to uri="pfx-api:truncate?objectType=DS&targetName=MyDataSource"/>
</route>
Truncate a Data Feed with a filter:
<route>
<from uri="direct:truncateDF"/>
<to uri="pfx-api:truncate?objectType=DF&targetName=MyDataFeed&dtoFilter=myTruncateFilter"/>
</route>
4.4 Delete
Delete records by filter:
<route>
<from uri="direct:deleteByFilter"/>
<to uri="pfx-api:delete?objectType=P&filter=deleteFilter"/>
</route>
Delete by typedId (async):
<route>
<from uri="direct:deleteById"/>
<to uri="pfx-api:delete?objectType=PL&typedId=123.PL&async=true&asyncTimeout=60000"/>
</route>
4.5 Integrate (Upsert)
Integrate (upsert) data using an integrate mapper:
<route>
<from uri="direct:integrateProducts"/>
<to uri="pfx-api:integrate?objectType=P&mapper=productIntegrateMapper&businessKeys=sku"/>
</route>
Integrate with a condition (only update records matching the condition):
<route>
<from uri="direct:conditionalIntegrate"/>
<to uri="pfx-api:integrate?objectType=P&mapper=productIntegrateMapper&businessKeys=sku&condition=myConditionFilter"/>
</route>
4.6 Internal Copy
Copy (duplicate) a Price List:
<route>
<from uri="direct:copyPriceList"/>
<to uri="pfx-api:internalCopy?objectType=PL&label=CopiedPriceList"/>
</route>
4.7 Flush
Flush data from a data feed to a data source:
<route>
<from uri="direct:flushDM"/>
<to uri="pfx-api:flush?dataFeedName=MyFeed&dataSourceName=MyDS"/>
</route>
Incremental flush:
<route>
<from uri="direct:flushIncremental"/>
<to uri="pfx-api:flush?dataFeedName=MyFeed&dataSourceName=MyDS&incrementalDate=2026-01-01"/>
</route>
4.8 Refresh Datamart
<route>
<from uri="direct:refreshDM"/>
<to uri="pfx-api:refresh?targetName=MyDatamart&incremental=true"/>
</route>
4.9 Calculate
Calculate a CFS by label:
<route>
<from uri="direct:calculateCFS"/>
<to uri="pfx-api:calculate?objectType=CFS&label=MyCFS"/>
</route>
Calculate Datamart derived columns:
<route>
<from uri="direct:calculateDM"/>
<to uri="pfx-api:calculate?objectType=DM&typedId=5.DM&targetName=MyTarget"/>
</route>
4.10 Execute Formula
<route>
<from uri="direct:executeFormula"/>
<to uri="pfx-api:execute?formulaName=MyFormula"/>
</route>
4.11 Import (Server-Side)
Server-side import using the Pricefx Import API. The method automatically routes to V1 or V2:
-
V1 (delegates to
loaddata) — for all non-Datamart object types (P, C, LTV, etc.) -
V2 (compressed staging upload) — for Datamart types: DMF, DMDS, DM, DMSIM, DMM
<route>
<from uri="direct:serverImport"/>
<to uri="pfx-api:import?objectType=P&fileName=products.csv&truncate=false&deDuplicate=true&delimiter=,"/>
</route>
4.12 Upsert Price Items
<route>
<from uri="direct:upsertPLI"/>
<to uri="pfx-api:upsertPriceItems?objectType=PLI&priceListId=42.PL&performRecalculation=true"/>
</route>
4.13 Custom Form Operations
Change status:
<route>
<from uri="direct:submitCFO"/>
<to uri="pfx-api:changeStatusCustomForm?objectType=CFO&typedId=99.CFO&cfoStatusOperation=SUBMIT"/>
</route>
Duplicate:
<route>
<from uri="direct:duplicateCFO"/>
<to uri="pfx-api:duplicateCustomForm?objectType=CFO&typedId=99.CFO"/>
</route>
5. Headers
5.1 Headers Consumed by the Component
The following Camel message headers are read by pfx-api commands and can be used to override or supplement URI parameters at runtime:
|
Header |
Type |
Used By |
Description |
|---|---|---|---|
|
|
|
|
Overrides the mapper for loaddata when set on the incoming message. |
|
|
|
|
Overrides the mapper for integrate when set on the incoming message. |
|
|
|
|
Overrides the |
|
|
|
|
Overrides the |
|
|
|
|
The file name used when uploading product images or binary data. |
|
|
|
|
S3 object key, used as file name when importing from S3. |
5.2 Headers Set by the Component
The following headers are set on the outgoing exchange message after a pfx-api operation completes:
|
Header |
Type |
Set By |
Description |
|---|---|---|---|
|
|
|
|
Total number of rows returned by the server for the query (before pagination). Set on the exchange for use in batching logic. |
|
|
|
|
Number of input records in the current batch. |
|
|
|
|
Total number of input records processed across all batches. |
|
|
|
|
Total number of failed input records. |
|
|
|
|
Number of failed batches. |
|
|
|
|
Path to the output CSV file. |
|
|
|
|
Batch size used during the fetch. |
|
|
|
|
Number of batches fetched. |
|
|
|
|
Total number of records fetched. |
|
|
|
|
Total time (ms) spent on API calls. |
|
|
|
|
Total time (ms) spent writing to the file. |
|
|
|
|
Signals that the fetch preview result is Base64-encoded. |
6. Commonly Used Object Types (Quick Reference)
|
Code |
Label |
Description |
|---|---|---|
|
|
Product |
Products master data |
|
|
Customer |
Customers master data |
|
|
ProductExtension |
Product extension tables (PX3..PX50) |
|
|
CustomerExtension |
Customer extension tables (CX3..CX50) |
|
|
LookupTableValue |
Simple lookup table values |
|
|
MatrixLookupTableValue |
Matrix lookup table values (MLTV..MLTV6 for multi-key) |
|
|
Pricelist |
Price Lists |
|
|
PricelistItem |
Price List items |
|
|
PriceGrid |
Price Grids |
|
|
PriceGridItem |
Price Grid items |
|
|
LIVEPRICEGRID |
Live Price Grid |
|
|
Quote |
Quotes |
|
|
QuoteLineItem |
Quote line items |
|
|
DMDatamart |
Datamarts |
|
|
DMDataSource |
Datamart Data Sources |
|
|
Model |
Model Tables |
|
|
(data source) |
Data Source (for truncate/flush) |
|
|
(data feed) |
Data Feed (for truncate/flush) |
|
|
CalculatedFieldSet |
Calculated Field Sets |
|
|
PriceRecord |
Price Records |
|
|
RebateAgreement |
Rebate Agreements |
|
|
RebateRecord |
Rebate Records |
|
|
CustomForm |
Custom Forms |
|
|
User |
Users |
|
|
Simulation |
Simulations |
|
|
DataChangeRequest |
Data Change Requests |
For the full list, see the ObjectType enum in pricefx-client/src/main/java/net/pricefx/integration/api/ObjectType.java.
7. Filter Definition (XSD Reference)
Filters are defined in dedicated filter XML files (under filters/) using the <filters> wrapper. The filter structure supports and, or, and not logical operators with criterion leaf nodes.
<filters>
<filter id="myFilter" resultFields="sku,attribute1" sortBy="sku">
<and>
<criterion fieldName="attribute1" operator="greaterThan" value="100"/>
<criterion fieldName="attribute2" operator="notNull"/>
</and>
</filter>
</filters>
Supported Filter Operators
|
Operator |
Description |
|---|---|
|
|
Equals |
|
|
Not equal |
|
|
Greater than |
|
|
Less than |
|
|
Greater than or equal |
|
|
Less than or equal |
|
|
Contains (case-sensitive) |
|
|
Starts with (case-sensitive) |
|
|
Ends with (case-sensitive) |
|
|
Contains (case-insensitive) |
|
|
Starts with (case-insensitive) |
|
|
Ends with (case-insensitive) |
|
|
Does not contain |
|
|
Does not start with |
|
|
Does not end with |
|
|
Does not contain (case-insensitive) |
|
|
Does not start with (case-insensitive) |
|
|
Does not end with (case-insensitive) |
|
|
Is null |
|
|
Is not null |
|
|
In set (comma-separated values) |
|
|
Not in set |
|
|
Custom SQL expression |