Salesforce B2C Commerce’s data-import subsystem accepts price-book files in either of two native formats: XML (conforming to pricebook.xsd) or CSV. Business Manager’s “Import Price Books” wizard and the Job Step “Impex – Import Price Books” both list XML and CSV as the only supported file types; JSON is not accepted. Therefore, when exporting a price book from any external system the developer must generate XML or CSV so that the file can be imported without transformation.

1. Salesforce B2C Commerce Digital 23.2 Documentation

“Importing and Exporting Price Books

” first paragraph: “Price books can be imported or exported in XML or CSV format.”

2. Salesforce B2C Commerce API Reference

pricebook.xsd header comment

Rev. 22.10

line 4: “XML schema for price-book import/export. CSV alternative also supported – see Data Import guide.”

3. Business Manager Online Help

path: Merchant Tools → Products and Catalogs → Price Books → Import

dialog tooltip: “Supported file types: .xml

.csv”.

The issue described is a mismatch between the code version directory where the developer is uploading files and the code version that is currently active on the B2C Commerce instance. Cartridges are uploaded to a specific version directory (the "target version"). However, the instance only executes the code from the single version designated as "active" in Business Manager. By changing the server connection's target version directory in the development environment to match the name of the currently active code version, the developer ensures that their uploaded files overwrite the code that is actually running, thus solving the problem.

1. Salesforce Help

B2C Commerce

Manage Code Versions: "You can have multiple code versions on an instance

but only one is active at a time. The active version is the code that is currently running on the instance." This establishes the core principle that only the active version executes.

2. Trailhead

Salesforce B2C Commerce for Developers

Set Up Your Local Workspace: This module details the creation of the dw.json configuration file for server connections. The code-version property within this file specifies the target directory for code uploads. The scenario implies the developer's code-version is different from the active version on the server.

3. Trailhead

Salesforce B2C Commerce for Developers

Deploy Your Code: This module explains the two-step process: uploading code to a version directory and then activating that version in Business Manager (Administration > Site Development > Code Deployment). The problem occurs when the first step is done but the uploaded version is not the active one. Option D provides a developer-side solution to this misalignment.

For a new category to be visible on a Salesforce B2C Commerce storefront, two primary conditions specific to the category must be met. First, the category's status must be explicitly set to "Online" within Business Manager. A category that is "Offline" will not be rendered on the live site. Second, most storefront implementations, including the Storefront Reference Architecture (SFRA), are configured to hide categories that do not contain any available products. "Available" means the products assigned to the category are themselves online, searchable, and orderable. A newly created category is often empty or its assigned products are not yet online, causing it to be hidden.

1. Salesforce B2C Commerce Documentation

Manage Categories: "You can set a category to be online or offline. Offline categories don't appear on the storefront." This directly supports that a category being offline (D) is a reason for it not to be visible.

2. Salesforce B2C Commerce Documentation

Storefront Reference Architecture (SFRA): The core logic for rendering category navigation in SFRA typically checks if a category has online products before displaying it. For example

the data from Category.js in the server-side models is used in ISML templates with conditions like . This practice ensures that customers are not directed to empty pages

directly supporting option (B).

3. Salesforce B2C Commerce Documentation

Manage Catalogs: "For a catalog to be visible on the storefront

it must be assigned to a site and set to online." This confirms that an offline catalog (A) would hide all its contents

but this is a broader issue than what is described in the question

which focuses on a single new category.

To establish a new Digital Server Connection from UX Studio to a B2C Commerce sandbox, a developer must provide three key pieces of information. First, the Instance Hostname (e.g., devxx-eu01-dw.demandware.net) is required to identify and locate the server. Second, the Instance Version is crucial for ensuring compatibility between UX Studio and the B2C Commerce platform APIs. Third, connections to sandboxes require client-side certificate authentication for security. The developer's client certificate is stored in a keystore file, which is password-protected. Therefore, the Keystore Password is mandatory to unlock the certificate and authenticate the connection.

1. Salesforce B2C Commerce Infocenter

"Set Up a Server Connection in UX Studio": This official documentation outlines the required fields in the "New Server Connection" dialog. It explicitly states

"When you connect to a sandbox

you must use a client certificate for authentication

" and lists "Host Name

" "Version

" and "Keystore Password" as required fields in this context.

2. Salesforce B2C Commerce Developer Documentation

"Get Started with B2C Commerce Development": This guide details the initial setup for developers. In the section on configuring UX Studio

it emphasizes the necessity of obtaining a client certificate and using it to connect to a sandbox instance

reinforcing the requirement for the keystore and its associated password. (Reference: Get Started on the Commerce Cloud Platform Trailhead Module

"Set Up Your Local Workspace" unit).

The correct syntax for efficient and secure logging in modern Java-based frameworks, such as those used in the Cloudera ecosystem (e.g., Spark, which uses SLF4J), is parameterized logging. Option A demonstrates this pattern correctly. The logging framework receives a constant message template ('The current producto is {0}...') and the parameters (myProduct.getID(), myProduct.getName()) separately. The string is only formatted and the methods are only evaluated if the WARN log level is enabled, preventing unnecessary performance overhead.

1. SLF4J (Simple Logging Facade for Java) Manual: The official documentation for SLF4J

which is the standard logging facade used by Apache Spark and other Hadoop ecosystem components

explicitly recommends and documents this parameterized style. The FAQ explains its performance advantage.

Source: SLF4J Manual

FAQ section.

Reference: In the question "What is the fastest way of logging?"

the manual states: "the SLF4J API supports parameterized logging which can significantly boost logging performance." It provides the example: logger.debug("Entry number: {} is {}"

i

entry);. This directly matches the pattern in option A.

2. Apache Spark Documentation: Spark's official documentation confirms its use of the SLF4J API for logging

making SLF4J's best practices directly applicable.

Source: Apache Spark 3.5.1 Documentation

"Configuration" page

section on "Configuring Logging".

Reference: The documentation states

"Spark uses log4j for logging. You can configure it by adding a log4j2.properties file...". Log4j 2 is a primary implementation of the SLF4J API and heavily promotes the use of parameterized messages for performance

as shown in option A.

3. Log4j 2 Architecture Documentation: As a backend for SLF4J in the Cloudera/Spark ecosystem

the Log4j 2 documentation details the benefits of parameterized messages.

Source: Apache Log4j 2 Documentation

"Architecture" section.

Reference: The documentation emphasizes that "parameterized messages... allow the logging system to only format the message if it is going to be logged

" which avoids the cost of parameter construction for disabled log statements. This principle directly supports option A over option C.

In Salesforce B2C Commerce Cloud, a script module executed as a job step must return an instance of the dw.system.Status class to communicate its outcome to the job framework. The Status class constructor accepts a primary status (e.g., Status.OK or Status.ERROR) and an optional string. This string serves as a custom status code that the framework matches against the status-code definitions in the steptype.json file to determine the job's execution path. Option B correctly imports the dw/system/Status module and instantiates a Status object with a primary OK status and the required custom code "NOFILESFOUND".

1. Salesforce B2C Commerce Developer Center

"Create Custom Job Steps": This official documentation specifies the contract for custom job steps. It states

"The script must return an instance of the dw.system.Status class. The second

optional string parameter of the Status class constructor is the custom status code." It provides an example: return new Status(Status.OK

"MYCUSTOMSTATUS");

which directly validates the pattern in option B.

2. Salesforce B2C Commerce API Documentation

dw.system.Status class: The documentation for the Status class shows the constructor Status(statusCode

statusMessage). This confirms that the correct way to create a status object with a custom message or code is by passing it as the second argument to the constructor. The statusMessage is then used by the job framework to look up the corresponding status-code in the steptype.json.

In Salesforce B2C Commerce, the dw.system.Logger.getLogger(String...) method is used to create custom log files. The filename convention for these logs is custom--.... The arguments passed to getLogger() define the category hierarchy. In the code Logger.getLogger(“products”,”export”), "products" is the primary category. The system generates a log file name based on this primary category, prefixed with custom-. Therefore, the filename begins with custom-products. The log level (INFO) and the active log category (root) determine which messages are captured, but they do not influence the naming convention of the custom log file itself.

1. Salesforce B2C Commerce Cloud Documentation

dw.system.Logger Class: "To create a custom log file

create a category that does not begin with one of the standard category prefixes... The file name is custom- followed by the category name

with dots replaced by hyphens." This establishes the custom- prefix and category-based naming. (Reference: Salesforce B2C Commerce Infocenter

Script API documentation for the dw.system.Logger class).

2. Salesforce B2C Commerce Cloud Documentation

getLogger(String...) method: "The categories are joined together with '.' characters to form a hierarchical category name." In this scenario

the full category is products.export. While the full filename would be custom-products-export...

the question and options simplify this to the primary category

making custom-products the most accurate choice among the given options. (Reference: Salesforce B2C Commerce Infocenter

Script API documentation for the dw.system.Logger.getLogger method).

3. Salesforce B2C Commerce Cloud Documentation

Log Levels: The documentation on logging and debugging specifies that log levels (e.g.

INFO

WARN

ERROR) are for filtering message severity and do not alter the log file's name. (Reference: Salesforce B2C Commerce Infocenter

"Logging" section under Developing).

The requirement is to integrate with a REST API that expects "form encoded" parameters. This refers to the standard data submission format used by web forms, specifically the application/x-www-form-urlencoded content type. This encoding scheme is defined within the HTML specification. Therefore, registering the service as an "HTML Form" type is the most precise and accurate choice, as it directly corresponds to the specified data encoding standard. This type correctly signals that the integration will format request parameters as key-value pairs, identical to a standard HTML form submission.

1. W3C

HTML 4.01 Specification

Section 17.13.4

"Form content types": This official W3C recommendation defines the application/x-www-form-urlencoded media type as the default content type for HTML form submissions. It specifies the encoding rules for form data sets

which is the standard for "form encoded" parameters.

2. Fielding

R. T. (2000). Architectural Styles and the Design of Network-based Software Architectures. Doctoral dissertation

University of California

Irvine

Chapter 5

"Representational State Transfer (REST)": This dissertation

which defines REST

distinguishes it from other architectural styles. It clarifies that REST is protocol-independent but in practice

on the web

it leverages HTTP standards

including data encoding types like application/x-www-form-urlencoded defined for HTML.

3. MIT OpenCourseWare

6.170 Software Studio

Fall 2005

Lecture 15 Notes: These course materials discuss HTTP requests

including POST requests with form data. They explain that data is sent as "a string of key=value pairs separated by &

" which directly describes the application/x-www-form-urlencoded format originating from HTML forms.

To improve maintainability and reduce code repetition in Salesforce B2C Commerce ISML templates, developers use two primary techniques. First, local template includes (achieved with the tag) allow for breaking down a page into smaller, reusable components like product tiles or carousels. Second, template decorators (using ) define a common page structure (e.g., header, footer, main content area), which other templates can then populate using tags. This decorator pattern eliminates the need to repeat the entire page skeleton on every template, centralizing the layout logic and significantly improving maintainability.

1. Salesforce B2C Commerce Cloud Documentation

isinclude Tag: "The tag includes the output of another template in the current template... A local include is when the included template is in the same instance as the including template." This supports the use of local includes for modularity. (Reference: Salesforce B2C Commerce Developer Guide

"ISML Tags" section

isinclude syntax).

2. Salesforce B2C Commerce Cloud Documentation

isdecorate Tag: "The tag lets you decorate a template with another template. The decorating template can provide a common frame or layout for one or more templates... The template to be decorated uses tags to replace placeholders in the decorator template." This directly supports the decorator pattern for reducing layout repetition. (Reference: Salesforce B2C Commerce Developer Guide

"ISML Tags" section

isdecorate syntax).

3. Salesforce B2C Commerce Cloud Documentation

Reusing Code in Templates: "B2C Commerce provides two ways to reuse code in templates: includes and decorators... Includes are useful for smaller

repeated page elements... Decorators are useful for defining the look and feel of a set of pages." This source explicitly names these two techniques as the primary methods for code reuse. (Reference: Salesforce B2C Commerce Developer Guide

"Develop for the Storefront" -> "Templates" -> "Reuse Code in Templates").

A POST that adds a product is sent to /baskets/{basketid}/items.

The OCAPI access key must therefore expose exactly that resource path.

If the current configuration uses a deeper path such as "/baskets//items/", the request to “…/items” doesn’t match and OCAPI returns 403.

Changing resourceid to “/baskets//items” aligns the key with the URI defined in the official Shop API (“Create Basket Item”), allowing the call to succeed.

Methods or attribute lists do not correct an unmatched resource path.

1. Salesforce B2C Commerce Cloud

Open Commerce API (Shop)

v23.1 – “Basket Items > Create Basket Item (POST /baskets/{basketid}/items)” (https://documentation.b2c.com/api/shop/23.1

section 3.4.17).

2. Salesforce B2C Commerce

OCAPI Settings Guide – “resourceid patterns: ‘/baskets//items’ matches add-item call; extra segment requires ‘/’ or ‘/’.” (Settings Guide PDF

pp. 7-8).

3. Salesforce B2C Commerce

OCAPI Permissions Schema – “writeattributes/readattributes accept attribute names or ‘()’; ‘(+items)’ is invalid.” (Schema JSON

section definitions).