B2B-Commerce-Developer B2B Commerce for Developers Accredited Professional AP-202 Questions and Answers

For a solution that requires handling complex tax calculations across multiple countries and jurisdictions, it's efficient to leverage third-party tax services that specialize in this area. Implementing the sfdc_checkout.CartTaxCalculations or sfdc_checkout.TaxCalculations interface to integrate with such a service ensures that tax calculations are accurate and up-to-date. Additionally, e xploring the Salesforce AppExchange for packages or sample code can provide ready-made solutions or frameworks that can expedite the development process.

To retrieve metadata about a specific object in a Lightning Web Component, a developer can use the getObjectInfo wire adapter. This adapter provides access to the metadata of a specified Salesforce object, including fields, record types, and layouts, whi ch is essential for dynamic component rendering based on the object's schema.

When implementing code for external pricing comparisons, if the external prices are the same as the sales prices for products in the cart, the implementation should ideally return a status indicating success (such as sfdc_checkout.IntegrationStatus .Status.SUCCESS ). This indicates that the external pricing verification has passed and there are no discrepancies between the external and sales prices.

The sizing keys used in the Salesforce B2B Commerce Global APIs perform five distinct operations. Three of these operations are:

Refetch data (used on s ome Logic classes): This operation indicates that the data should be refetched from the database instead of using the cached data. For example,  ccrz.ccServiceCart.getCart(ccrz.ccAPI.SZ_REFETCH)  will refetch the cart data and refresh the cache.

Related Quer y to call (sub queries or direct queries): This operation indicates that the related entities should be retrieved by using sub queries or direct queries. For example,  ccrz.ccServiceProduct.getProducts(ccrz.ccAPI.SZ_SUBQUERY)  will use sub queries to fetch t he related entities for each product, while  ccrz.ccServiceProduct.getProducts(ccrz.ccAPI.SZ_DIRECTQUERY)  will use direct queries to fetch the related entities separately.

Object type casting: This operation indicates that the data should be cast to a speci fic object type. For example,  ccrz.ccServiceProduct.getProducts(ccrz.ccAPI.SZ_SOBJECT)  will cast the data to sObjects instead of transformed objects. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Data Sizing Conventions

 The developer should implement the custom component so that it subscribes to events on the lightning_commerce_cartChanged channel using the Lightning Message Service. This is the recommended way to communi cate between custom and standard components on the Cart page, as it allows the custom component to receive updates from the standard cart component whenever the cart items or quantities change. The Lightning Message Service is a pub/sub mechanism that enables components to communicate across the DOM, regardless of their namespace, technology, or source. The lightning_commerce_cartChanged channel is a predefined channel that carries information about the cart state, such as the cart ID, the cart items, and the cart total.  References :  Custom Component APIs ,  Light ning Message Service ,  Communicate Across the DOM with Lightning Message Service

Learn more

1 blob:https://www.bing.com/fd286638-e14b-486c-81e8-e8c4e8cdf7c0

developer.salesforce.com 2 blob:https://www.bing.com/fd286638-e14b-486c-81e8-e8c4e8cdf7c0

developer.salesforce.com

The correct answer for how to export data from Salesforce or import data into Salesforce using Salesforce CLI commands is running a command like: sfdx force:data:tree:export -q “SELECT Id, Name FROM Product2” -u “ < your username > ” and sfdx force:data:tree:import -f Product2.json -u “ < your username > ”. The sfdx force:data:tree:export command is a Salesforce CLI command that exports data from an org into JSON files that conform to the SObject Tree API specification. The SObject Tree API specification is a format that defines how records are represented in JSON files for data import or export. The -q flag specifies the SOQL query that selects the records and fields to be exported. The -u flag specifies the username or alias of the org where the data will be exported from. Running this command will generate JSON files that contain the data from the org based on the SOQL query. The sfdx force:data:tree:import command is a Salesforce CLI command that imports data into an org using JSON files that conform to the SObject Tree API specification. The -f flag specifies the path of the JSON file that contains the data to be imported. The -u flag specifies the username or alias of the org where the data will be imported to. Running this command will create records in the org based on the data in the JSON file. Running a command like: sfdx force:data:bulk:export -Product2 -all 0 and sfdx force:data:bulk:import -f Product2.json -all is not a correct answer, as it uses invalid syntax and flags for the sfdx force:data:bulk:export and sfdx force:data:bulk:import commands. The correct syntax and flags for these commands are sfdx force:data:bulk:upsert -s Product2 -f Product2.csv -w 10 -u < your username > and sfdx force:data:bulk:status -i < job ID > -u < your username > . Running a command like: sfdx force:data;tree:export -Product2 -all q and sfdx force:data:tree:import -f Product2.json -all is not a correct answer either, as it uses invalid syntax and flags for the sfdx force:data:tree:export and sfdx force:data:tree:import commands. The correct syntax and flags for these commands are sfdx force:data:tree:export -q “SELECT Id, Name FROM Product2” -u < your username > and sfdx force:data:tree:import -f Product2.json -u < your username > . Running a command like: sfdx force:tree:data:export -q “SELECT Id, Name FROM Product2” -u < your username > ® and sfdx force:tree:data:import -f Product2Json -all is not a correct answer either, as there is no such command as sfdx force:tree:data:export or sfdx force:tree:data:import. The correct commands are sfdx force:data:tree:export and sfdx force:data:tree:import. Salesforce References: [Salesforce CLI Command Reference: force:data:tree:export], [Salesforce CLI Command Reference: force:data:tree:import] , [Salesforce CLI Command Reference: force:data:bulk], [Salesforce Developer Tools for Visual Studio Code]

To override inventory in the checkout process, a developer must implement the sfdc_checkout.CartinventoryValidation interface. This interface provides the necessary methods for custom inventory validation logic, allowing developers to define how invent ory checks are conducted during the checkout process. Salesforce documentation on extending and customizing the checkout functionality in B2B Commerce would include guidance on implementing this interface to meet specific inventory validation requirements.

The API-based record creation is generally handled in the service-layer responsible for the entity in Salesforce B2B Commerce. The service-layer is a set of classes that provide methods for interacting with the data layer and performing business logic. Eac h entity, such as product, cart, or order, has a corresponding service class that handles the create, read, update, and delete operations for that entity. For example, ccrz.ccServiceProduct provides methods for creating and retrieving products. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Service Classes

To expose a click event and react to user input in a Lightning web component, the developer should use a method name as the value of the onclick attribute in the template. The method name should be followed by parentheses, as in tileClick(). This syntax indicates that the method is invoked when the element is clicked. The method should be defined in the JavaScript file of the component, and it can access the event object as a p arameter. The other options are either invalid or incorrect. For example, {event:tileClick} is not a valid syntax for an onclick attribute, javascript:avoid(0);tileClick(); is unnecessary and outdated, and {tileClick} is a property binding expression, not a method invocation.  References:   B2B Commerce and D2C Commerce Developer Guide ,  Lightning Web Components Developer Guide

A target value of lightning__FlowScreen in metadata allows for a Lightning web component to be used in guided user experiences to gather input and to automatically generate configuration properties for the Lightning web component. The lightning__FlowScreen target value specifies that the component can be used on a flow screen, which is a type of flow element that displays information and collects user input in a flow. A flow is a guided user experience that can automa te business processes and guide users through screens, actions, and decisions. By using the lightning__FlowScreen target value, the developer can expose their Lightning web component as a custom screen component that can be added to any flow screen. The de veloper can also use the @api decorator to expose public properties of their Lightning web component as configuration properties that can be set in Flow Builder. Flow Builder is a tool that allows the developer to create and modify flows using a drag-and-d rop interface. A target value of lightning__FlowScreen does not allow the Lightning web component to replace standard functionality in flows and subflows or to be dragged onto a page in Lightning App Builder, as these are not related to the flow screen tar get value. Salesforce References:  Lightning Web Components Developer Guide: Configure Components for Flows ,  Lightning Web Components Devel oper Guide: Communicate with Flow ,  Lightning Flow Developer Guide: Screen Components Basics

The display of CC Menu Items can be customized for different users by using the cc_hk_Menu extension to post-process any cached menu items. This extension allows modifying the menu items based on the user context, such as the user role, account, or cart. For example, the extension can hide or show certain menu items based on the user’s permissions or preferences.

Salesforce B2B Commerce API sizing blocks can support multiple API sizing requests in three ways:

When different entities are specified in the method invocation. For example,  ccrz.ccServiceProduct.getProducts(ccrz.ccAPI.SZ_M, ccrz.ccAPI.SZ_L)  will use the SZ_M sizing block for the product entity and the SZ_L sizing block for the related entities.

SZ_ASSC is used. This flag indicates that the associated entities should use the same sizing block as the primary entity. For example,  ccrz.ccServiceProduct.getProducts(ccrz.ccAPI.SZ_M, ccrz.ccAPI. SZ_ASSC)  will use the SZ_M sizing block for both the product entity and the related entities.

SZ_ASSC is not used. This flag indicates that the associated entities should use the default sizing block, which is SZ_M, unless otherwise specified. For example,   ccrz.ccServiceProduct.getProducts(ccrz.ccAPI.SZ_M)  will use the SZ_M sizing block for the product entity and the SZ_M sizing block for the related entities. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Data Sizing Conven tions

In Salesforce Experience Cloud, components like CMS Collection and Results Layout are designed to be reusable across different Experience templates, not just limited to B2B Commerce. CMS Collection allows for the display of CMS con tent in a flexible and dynamic layout, while Results Layout can be used to present search or query results in a customizable format. Salesforce documentation on Experience Cloud components emphasizes the reusability and adaptability of these components acr oss various templates and contexts.

 According to the  B2B Commerce Developer Guide , the Order List Component (Aura) for B2B stores displays a list of orders that the user c an view and reorder. The component filters the orders based on the current storefront and the current effective account. The current effective account is the account that the user is currently acting on behalf of, which can be different from the user’s own account. The component does not show orders placed in other storefronts or related to other accounts, even if the user has access to them. Therefore, the correct answer is A. Orders placed in the current storefront and related to the current effective acc ount. The other options are incorrect because they do not match the criteria of the component.  References:   B2B Comme rce Developer Guide ,  Show the Order List Widget

Three actions that a developer must take, in a B2B Commerce store, to accept credit card payments using a client’s chosen payment provider are: create a named credential for authentication with the payment provider, create an Apex class that implements the sfdc_checkout.PaymentGatewayAdapter interface, and create a PaymentProviderGateway record for the custom payment provider class. Creating a named credential for authentication with the payment provider allows the developer to securely store and manage authentication information, such as username, password, token, or certificate, for connecting to the payment provider’s API or service. Creating an Apex class that implements the sfdc_checkout.PaymentGatewayAdapter interface allows the developer to define custom logic for processing credit card payments using the payment provider’s API or service. The interface provides methods for validating credit card information, authorizing payments, capturing payments, voiding payments, and refunding payments. Creating a PaymentProviderGateway record for the custom payment provider class allows the developer to register the custom payment provider class as a payment gateway in the store and associate it with a payment method. Creating a RegisteredExternalService record for the custom payment provider class is not a required action, as this is only used for registering external services that are not related to payment processing, such as tax or shipping services. Creating an Apex class that implements the commercepayments.PaymentGatewayAdapter interface is not a required action either, as this is only used for D2C Commerce stores, not B2B Commerce stores. Salesforce References: B2B Commerce Developer Guide: Payment Integration, B2B Commerce Developer Guide: Payment Gateway Adapter Interface, B2B Commerce Developer Guide: Payment Provider Gateway Object

The Product Detail Card component is a standard component that displays the product i nformation and options on the product page.  It includes the following elements 1 :

The product’s SKU

The product’s unit of measure

The product’s available inventory, or a generic availability message, if specified

The product’s short description

The product’s price information

The product’s quantity selector

The product’s add to cart button

The product’s image gallery

To replace this component with custom components, a developer can use the following three components:

Product Fields Sh ort component: This component displays the product’s short description, SKU, unit of measure, and price information.  It also allows the developer to specify which fields to display and how to format them 2 .

Product Field Long compone nt: This component displays the product’s long description, which can include rich text and images.  It also allows t he developer to specify which field to display and how to format it 2 .

Product Detail Image Gallery component: This c omponent displays the product’s image gallery, which can include multiple images and thumbnails.  It also allows the developer to s pecify the image field, the image size, and the image zoom option 3 .

These three components can be combined to create a custom prod uct page that shows the product information and options in a different layout and style than the out-of-the-box Product Detail Card component.  References:   Configure Product Info and Options on the Product Detail Page ,  Product Fields Short Component ,  Product Detail Image Gallery Component

 A developer has written the logic to import products from an enterprise resource planning (ERP) platform into B2B storefront products. The imported products are in Salesforce, but they are not visible in the store. The developer forgot to assign the  storefront  to the imported products.  A storefront is a logical grouping of products, categories, and price books that defines what products are available for purchase in a B2B Commerce site 1 .  A product must be associated with at least one storefront to be visible in the store 2 .  The developer can use the Data Loader to insert or update the storefront assignments for the imported p roducts 3 .

Option A, Option C, and Option D are incorrect because they are not required for the products to be visible in the store.  An entitlement policy is a set of rules that determines the availability of products based on the buyer’s account, contract, or order history 4 . An account is a record that represents a business or person involved in a business transaction. A promotion is a marketing too l that offers discounts or incentives to buyers. These are optional features that can be used to customize the B2B Commerce experience, but they are not necessary for the products to be visible in the store.  References:

Storefronts

Product Visibility

Insert new Products and custom Price Books via Data Loader

Entitlement Policies

[Accounts]

[Promotions]

The event that is invoked by any CCRZ Salesforce B2B Commerce View after the view is rendered is view:*:rendered. This event is triggered by the render method of the CCRZ.View class, which is the base class for all views in the framework. The event can be used to perform any actions or lo gic that depend on the view being rendered, such as initializing widgets, binding events, or updating the user interface. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Events ,  View Class

To implement specific styling for a standard component on a single page of the B2B Commerce store using an Aura templ ate, a developer should create a custom theme layout Aura component that imports the custom CSS file and set up the page to use this theme layout. A theme layout is a type of Aura component that defines the header and footer of a page in the storefront. A theme layout can also import custom CSS files from static resources and apply them to the page. A developer can create a custom theme layout Aura component that imports the custom CSS file that contains the specific styling for the standard component and a ssign it to the page that needs the custom styling. This way, the custom styling will only affect the standard component on that page and not on other pages that use a different theme layout. Using a custom CSS file in a static resource and adding the impo rt using the Edit Head Markup Editor in the Experience Builder is not a valid way to implement specific styling for a standard component on a single page, as it will affect all pages that use the same template. Creating a custom content layout Lightning we b component that imports the custom CSS file and setting up the page to use this content layout is not a valid way either, as it will not affect the standard component that is outside of the content layout. Using the Override CSR Editor in the Experience B uilder and adding the desired CSS to change the styles is not a valid way either, as it will affect all pages that use the same template. Salesforce References:  B2B Commerce Developer Guide: Theme Layout Component ,  B2B Commerce Developer Guide: Content Layout Compone nt ,  B2B Commerce Developer Guide: Override CSR Editor

Three advantages of using ccLog over the Salesforce standard System.debug class are:

There is no need to use string concatenation to easily tag log statements with a subject. ccLog allows passing a subject parameter to the log method, which will prepend the subject to the log message. For example,  ccLog.log('This is a message', 'Subject')  will log  [Subject] This is a message .

There is no need to create a User Trace Flag. ccLog can be enabled by setting the value of CO.logToken to true in CCAdmin, which will activate logging for all users who access the storefront.

There is no need to manually set a cookie to debug with the Site Guest User. ccLog can be enabled for the S ite Guest User by appending #ccLog= < Logging Token Name > to the end of the storefront URL in order to get logs in the inspector console. For example,  https://my-storefront.com/#ccLog=debug  will enable logging for the Site Guest User with the debug level. Sa lesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Logging

 The method signature that is used in the Global API’s is ccrz.cc_Output (ccrz.cc_Input input). This signature indicates that the Global API methods take a single input parameter of type ccrz.cc_Input a nd return an output of type ccrz.cc_Output. These are custom classes that are defined in the cloudcraze managed package and contain various properties and methods for handling the input and output data. For example,  ccrz.ccServiceProduct.getProducts(ccrz.c c_Input input)  is a Global API method that takes an input object and returns an output object containing product data. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  API Classes ,  cc_Input Class ,  cc_Output Class

To leverage a three column layout on a page and move the mini-cart widget from the right to the center column, the requirement can be fulfilled by creating a Gross Layout Override. This is a custom Visualforce page that overrides the default layout of a page and allows changing its structure and content. The us er can create a Gross Layout Override that uses a three column layout and places the mini-cart widget in the center column. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Gross Layout Overrides

 According to the  Platform Events Developer Guide , to debug platform events, a developer needs to include the Apex Code and Workflow log levels in the trace flag entry for the Automated Process entity or the overridden user. The Apex Code log level captures the execution of the Apex trigger that subscribes to the platform event. The Workflow log level captures the execution of the event pr ocess or the resumed flow interview that subscribes to the platform event. The other log levels are not relevant for debugging platform events. The Database log level captures database operations, such as DML statements and SOQL queries. The Callout log le vel captures the details of HTTP requests and responses, such as web service callouts.  References:   Platform Events D eveloper Guide ,  Set Up Debug Logs for Event Subscriptions ,  Set Up Debug Logging

It is preferable to extend the Salesforce B2B Commerce remote invocation object instead of using the standard Salesforce remote action invocation manager for two reasons:

The APEX method called by the remote action will be passed as a Salesforce B2B Commerce context object, which contains useful information such as the current user, cart, storefront, and configuration settings. This can simplify the development and testing of the remote action.

The Salesforce B2B Commerce logger can be utilized in the remote action, which allows logging messages and errors to the debug log or to a custom object. This can facilitate debugging and troubleshooting of the remote action.

To update the checkout process so that buyers can purchase with one of the below payment types:

Credit Card

Purchase Order

Contract Now & Pay Later Additionally, show only Purchase Order and Contract Now & Pay Later if a custom checkbox field on the account is checked, a developer should create a custom Lightning web component for the checkout flow that has all the options available. Within that component, pull data from the account to determine which options to show. Creating a custom Lightning web component for the checkout flow allows the developer to define custom logic and user interface for processing payments using different payment types. The developer can use Apex methods or third-party APIs to integrate with payment service providers or payment gateways and handle payment authorization, capture, void, and refund. The developer can also use @wire or @api decorators to get data from the account object and use its properties, such as the custom checkbox field, to determine which payment options to show or hide based on business logic. Creating a custom Lightning web component that can be used with the standard payment component is not a valid way to meet this requirement, as it does not allow the developer to replace or modify the standard payment component’s logic or user interface. Modifying the standard payment component settings in the checkout screen flow and adding the new payment method is not a valid way either, as it does not allow the developer to add custom payment types or conditional logic based on account data. Adding a new payment gateway through the reference implementation steps so the payment shows up on the checkout payment screen is not a valid way either, as it does not allow the developer to add multiple payment options or conditional logic based on account data. Salesforce References: B2B Commerce Developer Guide: Payment Integration, B2B Commerce Developer Guide: Payment Component, B2B Commerce Developer Guide: Checkout Subflow

For investigating errors during development, Salesforce recommends using the Streaming API Subs cription Channel for Commerce Diagnostics Event Logging. This tool allows developers to subscribe to a real-time feed of system events, including errors, which can be crucial for diagnosing and resolving issues during development. The Streaming API provide s a robust mechanism for monitoring and debugging by delivering secure, scalable, and customizable event notifications within Salesforce or through external systems. This is outlined in Salesforce documentation related to the Streaming API and its applicat ion in commerce diagnostics and event logging.

Handlebar Templates are defined in the uiProperties file in the cloudcraze managed package. This file contains various properties that control the behavior and appearance of the user in terface components. The handlebarTemplates property defines a map of template names and template contents that are used by the handlebars.js templating engine to generate HTML from JSON data. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  UI Properties ,  Handlebars Templates

To debug a flow with detailed tracing of a single input, including watching all variable changes as the checkout process is executed, the developer should enable "Show executio n details" (inline) within the Flow Debugger. This feature allows developers to see a step-by-step execution of the flow, including the values of variables at each step. This is crucial for understanding how data is being passed through the flow and for id entifying any issues. Salesforce documentation on debugging flows provides more information on this feature: Salesforce Flow Debugging Documentation .

The ccUtil apex class provides two methods to check the input or return data of the Global API’s: ccrz.ccUtil.isNotEmpty(Map < String, Object > ) and ccrz.ccUtil.isEmpty(Map < String, Object > ). These methods return true if the map is not null and contains at least one entry, or if the map is null or empty, respectively. Similarly, ccrz.ccUtil.isNotEmpty(List < Object > ) and ccrz.ccUtil.isEmpty(List < Object > ) return true if the list is not null and contains at least one element, or if the list is null or empty, respectively. These methods are useful for validating the input parameters or the output results of the Global API’s.

 A developer should use Jest to author automated tests for custom Lightning web components. Jest is a powerful tool with rich features for wr iting JavaScript tests.  It is the recommended testing framework for Lightning web components by Salesforce 1 .  Jest allows the developer to write unit tests i n local JavaScript files, run them from the command line or Visual Studio Code, and debug them using breakpoints and watch expressions 2 .  Jest also provides features such as mocking, code coverage, snapshots, and asynchronous testing 3 .

Optio n A, Option B, and Option D are incorrect because they are not testing tools, but rather development tools.  Visual Studio Code is an integrated development environment (IDE) that supports Lightning web components development with extensions and plugins 4 .  Salesforce CLI is a command line interface that allows the developer to create, deploy, and manage Lightning web components projects 5 . Salesforce Developer Console is a web-based tool that provides code editing, debugging, and testing features for Apex and Visualforce, but not for Lightning web components.  References:

Test Lightning Web Components

Write Jest Tests

Jest Documentation

Visual Studio Code

Salesforce CLI

[Salesforce Developer Console]

A query containing a subquery is executed. By default, in Salesforce B2B Commerce, “__ccrz” is appended to the subquery name as part of its transformation. This is done to avoid conflicts with the standard Salesforce fields and relationships. For example,  SELECT Id, Name, (SELECT Id, Name FROM Contacts) FROM Account  will be transformed to  SELECT Id, Name, (SELECT Id, Name FROM Contacts__ccrz) FROM Account__ccrz . Sal esforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Query Transformation

The meth od that is used to override when extending the Salesforce B2B Commerce logic providers is doLogic. This method is responsible for executing the business logic for each logic provider class, such as validating inputs, performing calculations, applying rules , or updating data. By overriding this method, the user can modify or extend the existing logic or add their own custom logic. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Logic Classes

To handle the sub scription lifecycle of a message channel in a Lightning web component, the developer should implement the  subscribe()  and  unsubscribe()  methods from the  lightning/messageService  module. The  subscribe()  method returns a subscription object that represents the connection to the message channel. The developer can use this object to unsubscribe from the message channel later. The  unsubscribe()  method takes a subscription object as a parameter and removes the listener from the message channel. The developer sho uld call the  unsubscribe()  method when the component is disconnected from the DOM, such as in the  disconnectedCallback()  lifecycle hook, to avoid memory leaks and performance issues.

The other options are not correct because:

B. stopListener() is not a val id method for handling the subscription lifecycle of a message channel. There is no such method in the  lightning/messageService  module or the Lightning web component framework.

C. startListener() is not a valid method for handling the subscription lifecycl e of a message channel. There is no such method in the  lightning/messageService  module or the Lightning web component framework.

References:

Subscr ibe and Unsubscribe from a Message Channel

Lifecycle Hooks

Use message channel in both direction

To authorize the org for Command Line Interface (CLI) access so the developer can deploy Lightning web components, the developer should run the command: 'sfdx force:auth:web:login -r “https://login.salesforce.com” and then supply the credentials i n the browser when it opens. The sfdx force:auth:web:login command is a Salesforce CLI command that authorizes an org using the web server flow. The web server flow is an OAuth 2.0 authentication flow that opens a browser window and prompts the user to log in to Salesforce and allow access to the CLI. The -r flag specifies the login URL of the org, which is https://login.salesforce.com for production or developer orgs. Running this command will open a browser window and ask the developer to enter their user name and password for the org. After successfully logging in, the developer will be able to use the CLI to perform various tasks with the org, such as deploying or retrieving metadata, running tests, or executing commands. Running the command: 'sfdx force: login -r “https://login.salesforce.com” is not a valid way to authorize the org for CLI access, as there is no such command as sfdx force:login. Running the command ‘sfdx force:auth:web:login -a “https://login.salesforce.com”’ is not a valid way either, as the -a flag specifies an alias for the org, not a login URL. Running the command ‘sfdx force:auth:web:login -r “https://login.salesforce.com” -username’me@my-new-org.org"’ is not a valid way either, as there is no such flag as -username. Salesforce Refere nces:  Salesforce CLI Command Reference: force:auth:web:login ,  Salesforce Developer Tools for Visual Studio Code

When services use the ccServiceDao class to execute queries, variables are bound by string substitution. This means that the query string contains placeholders for variables that are replaced by their values at runtime. For example,  ccrz.ccServiceDao.getQuery('SELECT Id FROM Account WHERE Name = :name')  will replace  :name  with the value of the  name  variable.

According to the  B2B Commerce Developer Guide , the ICart interface provides access to the cart object and its related data. The Details property of the ICart interface returns an ICartDetails object, which contains information about the cart such as the currency, the subtotal, the ship ping cost, the tax, and the grand total. The Fields property of the ICartDetails interface returns a map of field names and values for the cart object. Therefore, to get the grand total amount for items in the cart and in the currency of the cart, a develo per should use the expression {ICart.Details.Fields.grandTotal}, which returns the value of the grandTotal field from the cart object.  References:   B2B Commerce Developer Guide ,  ICart Interface ,  ICart Details Interface

For a deployable Lightning Web Component like displayMyData , the required files include the component's CSS file (displayMyData.css) for styling, the metadata configuration file (displayMyData.js-meta.xml) for defining the component's configuration and properties, and the template f ile (displayMyData.html) for the component's HTML structure. The JavaScript file (displayMyData.js) contains the business logic but is not listed as an option here. For deployment, these files are essential. Refer to the Salesforce LWC documentation for de ployment requirements: Salesforce LWC Deployment Documentation .

A method to re solve if the current storefront customer is a Salesforce B2B Commerce guest user in an apex class is to use ccrz.cc_CallContext.isGuest. This property will return true if the current user is a guest user, or false otherwise. For example,  if(ccrz.cc_CallCon text.isGuest){ // do something for guest user }  will execute some logic only for guest users. Salesforce References:  B2B Co mmerce and D2C Commerce Developer Guide ,  Call Context

 Executing dynamic SOQL inside a without sharing class with a bind variable from PageReference.getParameters(), PageReference.getCookies(), or cc_RemoteActionContext class will open up a major security hole because these sources of input are not sanitized and can be manipulated by malicious users to inject SOQ L queries that bypass the sharing rules and access data that they are not supposed to see. For example, a user can modify the URL parameters or cookies to include a SOQL query that returns sensitive data from the database. To prevent this, it is recommende d to use static SOQL or escape the bind variables before executing dynamic SOQL.

The REST APIs in Salesforce B2B Commerce support pass-through parameter handling by passing parameters through the service handlers. This means that any parameters that are not recognized by the REST API framework will be passed to the service handler class that implements the API logic. The service handler class can then use these parameters for custom logic or validation.

custom getter in a Lightning web component is a JavaScript function that executes logic each time a public property is accessed. A custom getter must start with the keyword  get  and be followed by a name for the property. A custom getter must also have a corresponding custom setter, which is a funct ion that executes logic each time a public property is assigned a value. A custom setter must start with the keyword  set  and have the same name as the getter. One of the getter or setter functions must be annotated with  @api , which makes the property publi c and reactive.

Option A and Option D show the correct syntax for defining a custom getter and setter for a public property called  name . Option A shows the getter function, which returns the value of a private property called  _name . Option D shows the sett er function, which assigns the value of the parameter  value  to the private property  _name . The getter function is annotated with  @api , which makes the  name  property public and reactive.

Option B and Option C are incorrect because they do not follow the syntax for a custom getter and setter. Option B shows a regular function declaration, not a getter function. Option C shows a regular assignment statement, not a setter function. Neither option uses the  @api  decorator, which is required for a public proper ty.  References:

Getters and Setters

Understand g etter in Lightning Web component

When exporti ng Order Summary records via Data Loader, if some orders are missing, a common cause could be that those orders did not have a status that was included in the export criteria, such as 'Created'. Salesforce data exports can be filtered based on specific cri teria, and if the status of some orders doesn't match the criteria, those orders will not be included in the export. The other options listed are less likely to be direct causes for missing orders in an export operation. For more information on using Data Loader and understanding export criteria, refer to the Salesforce Data Loader Guide: Salesforce Data Loader Guide .

The handlebars helper function that is used on Salesforce B2B Commerce pages and components for formatting price values is formatPrice. This function will format a numeric value as a price according to the currency settings and locale of the storefront. For example,  {{formatPrice price}}  will format the price value as $1,234.56 for US dollars or €1.234,56 for euros. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Handlebars Helpers

The handlebars helper expression that is used in Salesforce B2B Commerce pages and components to toggle the display of a block of markup is {{#ifConfig ‘Field__c’}} … {{/ifConfig}}. This expression will evaluate the value of th e configuration setting with the API name Field__c and render the block of markup if the value is true, or skip it if the value is false. For example,  {{#ifConfig 'CO.showMiniCart'}} < div id="mini-cart" > ... < /div > {{/ifConfig}}  will render the mini-cart d iv only if the configuration setting CO.showMiniCart is true. Salesforce References:  B2B Commerce and D2C Commerce Develope r Guide ,  Handlebars Helpers

 To pass HTML from a parent component to a child component, the child com ponent needs to have a  < slot > < /slot >  element in its template. A slot is a placeholder for markup that a parent component passes into a component’s body. Slots are part of the Web Component specification. The parent component can use the slot name or the de fault slot to specify which HTML content goes into which slot of the child component. The other options are not valid elements for passing HTML from parent to child.  References:

Slots

Pass HTML Markup From Parent TO CHILD In Lightning Web Component

How parent component pass HTML to child compo nent in Angular?

The most likely cause of why some orders were missing from the Data Loader export is that the Status was still set to Draft. The Status is a field on the Order Summary object that indicates the current state of the order. The Status can have values such as Draft, Submitted, Confirmed, or Cancelled. A Draft order is an order that has not been submitted or confirmed by the customer or the seller. A Draft order is not considered a completed or valid order and is not included in reports or exports. When using Data Loader to export data from an org, Data Loader will only include orders that have a Status other than Draft, such as Submitted or Confirmed. If an order has a Status of Draft, Data Loader will not include it in the CSV file, which may result in missing orders. The export job did not fully complete is not a likely cause of why some orders were missing from the Data Loader export, as it is not related to the order status or data filtering. Order Life Cycle Type was Managed is not a likely cause either, as it is not related to the order status or data filtering. The Order Life Cycle Type is a field on the Order Summary object that indicates whether the order is managed by Salesforce Order Management or by an external system. The user does not have rights to some of the records is not a likely cause either, as it contradicts the fact that some orders were exported successfully. If the user did not have ri ghts to some of the records, Data Loader would not be able to access or export any orders at all. Salesforce References:  B2B Commerce Developer Guide: Order Summary Object ,  B2B Commerce Developer Guide: Order Status Enum ,  Data Loader Guide: Export Data from Salesforce

Two guidelines for logging that are used within the core Salesforce B2B Commerce product are:

The close method of ccrz.ccLog must be called at the end of the remote action. This method will flush the log messages to the browser console or to a custom object, depending on the logging mode. If this method is not called, the log messages may not be displayed or saved properly.

No calls to ccrz.ccLog can be made before cc_CallContext.initRemoteContext is executed. This method will initialize the call context object, which contains in formation such as the current user, cart, storefront, and configuration settings. These information are required for logging, so calling ccrz.ccLog before initializing the call context will result in an error. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Logging

The default behavior for how the Salesforce B2B Commerce Global APIs transform Salesforce data is to return field names with a lowercase first letter, camelcase convention. For example, the field name ccrz__E_Product__c in Salesforce will be transformed to eProduct in the API. This is done to follow the JavaScript naming convention and to avoid conflicts with the standard Salesforce fields and relationships. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Query Transformation

 According to the  Lightning Web Components Developer Guide , Shadow DOM is a standard that encapsulates the internal document object model (DOM) structure of a web component. Encapsulatin g the DOM gives developers the ability to share a component and protect the component from being manipulated by arbitrary HTML, CSS, and JavaScript. Shadow DOM also provides style and behavior isolation for a web component, which means that the styles and scripts defined inside a component do not affect the rest of the page, and vice versa. Therefore, the purposes of the Shadow DOM in a Lightning web component are to encapsulate the internal DOM structure of a web component (A) and to allow components to be shared while protecting them from being manipulated by arbitrary code (B). The other options are incorrect because Shadow DOM does not allow direct access to the document object model of the component ©, nor does it allow older JavaScript libraries to man ipulate the tagging structure (D).  References:   Lightning Web Components Developer Guide ,  Understand the Shadow DOM Unit

The format that the custom Salesforce field with the API name My_Field_Name__c is transformed onto by default in Salesforce B2B Commerce is myFieldName. This is done to follow the JavaScript naming convention and to avoid conflicts with the standard Salesforce fields and relationships. The transformation rules are as follows:

Remove any namespace prefix from the field name, such as ccrz__ or cloudcraze__.

Remove any underscores from the field name and capitalize the first letter of each word after an underscore, such as MyFieldName.

Lowercase the first letter of the field name, such as myFieldName. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Query Transformation

The format that the custom Salesforce relationship with the API name, My_Relationship_Name__r.My_Name__c is queried and transformed into by default in Salesforce B2B Commerce is myRelationshipName.myName: value. This is done to follow the JavaScript naming convention and to avoid conflicts with the standard Salesforce fields and relationships. The transformation rules are as follows:

Remove any namespace prefix from the field name, such as ccrz__ or cloudcraze__.

Remove any underscores from the field name and capitalize the first letter of each word after an underscore, such as MyRelationshipName and MyName.

Lowercase the first letter of the field name, such as myRelationshipName and myName.

Use a dot (.) to separate the relationship name and the field name, such as myRelationshipName.myName.

Use a colon (:) to separate the field name and the field value, such as myRelationshipName.myName: value. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Query Transformation

The developer should use the getPicklistValues wire adapter to retrieve metadata about a specific picklist. This wire adapter allows the developer to get the picklist values for a specified field on a given object and record type. The wire adapter returns an object that contains the picklist values, the default val ue, and the controlling field (if any). The developer can use this wire adapter to populate a custom picklist component with the appropriate values based on the object and record type context. The other options are incorrect because they are not valid wire adapters for retrieving picklist metadata.  References :  getPicklistValues ,  Retrieving Picklist Values Without Using Apex ,  B2B Commerce and D2C Commerc e Developer Guide

Three statements that are true about Global API versioning are:

Calling in with an API version set to lower than 1 will result in an exceptional case where the exception class ccrz.BelowMinAPIVersionException will be returned to callers. This exception indicates that the API version is not supported by the framework and the caller should use a higher API version.

The API version is scoped at the Class API level and NOT at the method level. This means that all the methods in a class will use the same API version that is specified by the caller. For example, if the caller passes an API version of 4 to ccrz.ccServiceProduct.getProducts(), then all the other methods in ccrz.ccServiceProduct will also use API version 4.

Calling in with an API version set to more than current maximum will result in exception case where the exception class ccrz.ExceedsMaxAPIVersionException will b e returned to callers. This exception indicates that the API version is not supported by the framework and the caller should use a lower API version. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  API Versioning

QUESTION NO: 68

Which three statements are true regarding event handling in the Salesforce B2B Commerce managed package? (3 answers)

A. Salesforce B2B Commerce relies on a series of Javascript click listener events.

B. Writing directly to your own custom Backbone JS Views and Models automatically integrates that data into the Salesforce B2B Commerce Backbone Views and Models.

C. Salesforce B2B Commerce relies on a central event channel for communication across various Salesforce B2B Commerce Backbone Views and Models called CCRZ.pubSub.

D. CCRZ.pubSub defines the following three functions which can be used for event handling: trigger, on, and once.

E. CCRZ.pubSub extends the Backbone.Events JavaScript object.

Answer: C,D,E

Three statements that are true regarding event handling in the Salesforce B2B Commerce managed package are:

Salesforce B2B Commerce relies on a central event channel for communication across various Salesforce B2B Commerce Backbone Views and Models called CCRZ.pubSub. This object allows different components to publish or subscribe to events without being coupled with each other. For example, CCRZ.pubSub.trigger(‘cartChange’) will publish an event named cartChange that can be subscribed by any component that needs to react to it.

CCRZ.pubSub defines the following three functions which can be used for event handling: trigger, on, and once. The trigger function is used to publish an event with a name and optional arguments. The on function is used to subscribe to an event with a name and a callback function. The once function is similar to on, but it will only execute the callback function once for each event.

CCRZ.pubSub extends the Backbone.Events JavaScript object. This object provides methods for managing events in Backbone.js, which is a JavaScript framework that provides models, views, collections, and events for building single-page applications. CCRZ.pubSub inherits all the methods and properties of Backbone.Events and adds some custom ones. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Events ,  PubSub Class

To create custom Lightning web components (LWCs), a developer must take two steps: authorize an org for an SFDX project and deploy a custom component. Authorizing an org for an SFDX project allows the developer to connect to a Salesforce org, such as a scratch org, a sandbox, or a production org, and use it as a development environment. Deploying a custom component allows the developer to push the LWC co de from the local project to the org and make it available for use. Creating an Apex class is not a required step for creating custom LWCs, as not all LWCs need to use Apex. Cloning an LWC is not a required step either, as it is an optional way to create a new LWC based on an existing one. Salesforce References:  Lightning Web Components Developer Guide: Authorize an Org for Development ,  Lightning Web Components Developer Guide: Deploy Your Component

To extend ccServiceProduct and expose custom fields on the Product Detail Page, three statements are true:

Override the getFieldsMap method and add subscriber specific code. This method returns a map of field names and field types for the product entity and its related entities. By overriding this method, the subscriber can add their custom fields to the map and make them available for the API.

Create a global with sharing class that extends ccrz.ccServiceProduct. This class will inherit all the methods and properties of the ccServiceProduct class and allow overriding or extending them. The class should be global and with sharing to ensure that it can be accessed by the API framework and respect the sharing rules.

Override the fetch method and add your subscriber specific code here. T his method executes the query to fetch the product data and returns a result object. By overriding this method, the subscriber can modify the query or the result object to include their custom fields or logic. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Service Classes ,  ccServiceProduct Class

The root cause of why the custom field MyCustomField__c has no values and no column header in the CSV file is that the user does not have access to the field. A user’s access to a field is determined by their profile a nd permission sets, which define their field-level security settings. Field-level security settings control whether a user can see, edit, or delete the value for a particular field on an object. If a user does not have access to a field, they will not be a ble to view or modify its value in any interface, including Data Loader. Data Loader is a tool that allows users to import or export data between Salesforce and CSV files. When using Data Loader to export data from an org, Data Loader will only include fie lds that are accessible to the user based on their field-level security settings. If a user does not have access to a field, Data Loader will not include that field in the CSV file, neither as a column header nor as a value. The user needs to install a spe cific Zulu JDK that is recommended by Salesforce is not the root cause of why MyCustomField__c has no values and no column header in the CSV file, as it is not related to field access or Data Loader functionality. A mapping file was not used when the data was loaded in is not the root cause either, as it is not related to field access or Data Loader functionality. A mapping file is an optional file that maps fields between Salesforce objects and CSV files when using Data Loader to import or export data. The user has rights to the field but there are no values in it is not the root cause either, as it contradicts the fact that MyCustomField__c has no column header in the CSV file. If the user had rights to the field but there were no values in it, Data Loader would still include MyCustomField__c as a column header in the CSV file, but leave its values blank. Salesforce References: [Data Loader Guide: Export Data from Salesforce], [Data Loader Guide: Field Mapping] , [Salesforce Help: Set Field-Level Security]

The event that should be triggered when user facing info, warning or error messages need to be displayed on a Visualforce page is pageMessage. This event is triggered by the displayPageMessage method of the CCRZ.util class, which is a utility class that provides various helper methods for common tasks. The event can be used to display a message on the page with a specified type, title, and text. For example,  CCRZ.util.displayPageMessage('error', 'Oops!', 'Something went wrong.')  will trigger the pageMess age event and display an error message on the page. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Events ,  Util Class

The cookie that stores the effective account ID when effective account is enabled is apex__effacc. This cookie is set by the cc_hk_EffectiveAccount hook when a user switches to another account that they ha ve access to. The cookie value is the ID of the effective account, which is used to determine the pricing, availability, and visibility of products and categories for that account. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Effective Account

To expose delivery time estimates to NTO’s customers in the storefront, a developer should display the Expected Delivery Date on the order page with a Lightning web component. The Expected Delivery Date is a custom field on the Order object that stores the date when the order is expected to be delivered to the customer. The developer can use the @wire deco rator to get the current order object and use its properties, such as order number, status, total amount, and expected delivery date, to display them on the order page. The developer can also use Apex methods or third-party APIs to calculate and update the expected delivery date based on various factors, such as inventory availability, shipping method, shipping address, and carrier service level. Displaying the expected delivery date on the order page allows the customer to see their delivery time estimate at any time and reduce their need to call customer service. Adding the Expected Delivery Date field to the order confirmation email is not a good solution, as it does not allow the customer to see their delivery time estimate if they lose or delete their e mail. Adding a Desired Delivery Date input field during the checkout flow is not a good solution either, as it does not guarantee that the customer’s desired delivery date will be met or reflect any changes in delivery time due to unforeseen circumstances. Configuring an email alert to the customer when the Expected Delivery Date changes is not a good solution either, as it can create confusion or frustration for the customer if they receive multiple or conflicting emails about their delivery date. Salesfor ce References:  B2B Commerce Developer Guide: Order Object , [B2B Commerce Developer Guide: Order Page], [Lightning Web Components Developer Guide: Call an Apex Method Imperatively]

The root cause of why the CustomField__c field they added to the entity has no values under the header in the CSV file output is that the user does not have rights to the custom field. A user’s access to a field is determined by their profile and permission sets, which define their field-level security settings. Field-level security settings control whether a user can see, edit, or delete the value for a particular field on an object. If a user does not have access to a field, they will not be abl e to view or modify its value in any interface, including Data Loader. Data Loader is a tool that allows users to import or export data between Salesforce and CSV files. When using Data Loader to export data from an org, Data Loader will only include field s that are accessible to the user based on their field-level security settings. If a user does not have access to a field, Data Loader will not include that field in the CSV file, neither as a column header nor as a value. The developer does not have the c orrect JDK that is recommended by Salesforce and this is known to cause issues with exporting custom attributes is not the root cause of why CustomField__c has no values under the header in the CSV file output, as it is not related to field access or Data Loader functionality. The developer does not have access to the object’s metadata is not the root cause either, as it is not related to field access or Data Loader functionality. The object’s metadata defines its structure and properties, such as fields, r elationships, and layouts. The field is not populated is not the root cause either, as it contradicts the fact that CustomField__c has no column header in the CSV file output. If the field was not populated but accessible to the user, Data Loader would sti ll include CustomField__c as a column header in the CSV file, but leave its values blank. Salesforce References:  Data Loade r Guide: Export Data from Salesforce , [Data Loader Guide: Field Mapping], [Salesforce Help: Set Field-Level Security]

The use of a standard Visualforce control such as apex:form is discour aged in Salesforce B2B Commerce page includes and subscriber pages because the CCRZ JavaScript object is not accessible within an apex:form control. The CCRZ JavaScript object is a global object that provides access to various B2B Commerce functions and pr operties, such as logging, utilities, events, and configuration. Using an apex:form control would prevent the developer from using the CCRZ JavaScript object and its features. Visualforce does not “scope” controls that are present on a page and scope of th e control will be set to “ccrz”, as this is not a valid statement. Apex:form does not render DOM components slowly, as this is not a performance issue. JavaScript events are supported within an apex:form control, as this is not a limitation. Salesforce Ref erences: B2B Commerce Developer Guide: CCRZ JavaScript Object, B2B Commerce Developer Guide: Page Includes

The template that will correctly display the details message only when areDetailsVisible becomes true given the following code in a Lightning Web Component is option C. Option C uses the if:true directive to conditionally render a template block based on the v alue of areDetailsVisible. If areDetailsVisible is true, the template block inside the < template if:true={areDetailsVisible} > tag will be rendered. Otherwise, it will be skipped. Option A is incorrect because it uses the if:false directive, which does the opposite of if:true. It renders the template block only when areDetailsVisible is false. Option B is incorrect because it uses an invalid syntax for the if directive. The if directive requires a colon (:) after the if keyword, not an equal sign (=). Option D is incorrect because it uses an invalid syntax for the template tag. The template tag requires a closing tag ( < /template > ), not a self-closing tag ( < template/ > ). Salesforce References:  Lightning Web Components Developer Guide: Conditional Rendering ,  Lightning Web Components Developer Guide: Template Syntax

To ensure that a custom field is available to display on a given page, the Developer needs to override the Service Class that the page uses and update the Service Management in CCAdmin for the given storefront to use this new Service Class. The Service Class is responsible for retrieving and setting data for a given page. The Logic Class is respons ible for implementing business logic and validation rules for a given page. Creating a new Service Class or Logic Class is not necessary, as overriding an existing one can achieve the same result. Salesforce References:  B2B Commerce and D2C Commerce Developer Guide ,  Service Classes ,  Logic Classes