B2B-Commerce-Developer Salesforce Accredited B2B Commerce Developer (SU24) Questions and Answers

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 the 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'}}

The Product Detail Card component is a standard component that displays the product information and options on the product page. It includes the following elements1:

• 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 Short 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 them2.
• Product Field Long component: This component displays the product’s long description, which can include rich text and images. It also allows the developer to specify which field to display and how to format it2.
• Product Detail Image Gallery component: This component displays the product’s image gallery, which can include multiple images and thumbnails. It also allows the developer to specify the image field, the image size, and the image zoom option3.

These three components can be combined to create a custom product 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

Two methods from the platformResourceLoader module that are relevant for including third party JavaScript and CSS in a Lightning web component are loadScript and loadStyle. The platformResourceLoader module is a module that provides methods for loading JavaScript or CSS files from static resources or external URLs into a Lightning web component. The loadScript method is used to load a JavaScript file and execute it in the component. The loadStyle method is used to load a CSS file and apply it to the component. The loadClientScript method does not exist or is not relevant for including third party JavaScript in a Lightning web component. The loadCss method does not exist or is not relevant for including third party CSS in a Lightning web component. Salesforce References: Lightning Web Components Developer Guide: Load Scripts and Style Sheets, [Lightning Web Components Developer Guide: platformResourceLoader Module]

To retrieve metadata about a specific object, a developer should use the getObjectInfo wire adapter. The getObjectInfo wire adapter imports data from the @salesforce/schema module and returns an object that contains information such as the object’s label, key prefix, fields, child relationships, record type infos, and theme. The getObjectMetadata wire adapter does not exist. The getObject wire adapter does not retrieve metadata, but rather returns a record object based on the record ID. The getObjectDescribe wire adapter does not exist either. Salesforce References: [Lightning Web Components Developer Guide: getObjectInfo], [Lightning Web Components Developer Guide: Import Salesforce Schema]

To automatically add 1 unit of Product A to the cart when a user buys 10 units of Product B, the requirement can be fulfilled by overriding the prepareToAdd method in ccrz.cc_api_CartExtension. This method is responsible for preparing the cart line items before they are added to the cart. By overriding this method, the user can check the quantity and product ID of the cart line items and add an additional cart line item for Product A if the condition is met. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, API Classes, cc_api_CartExtension 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 user 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

 To pass HTML from a parent component to a child component, the child component needs to have a  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 default 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 component in Angular?

In Lightning Web Components, the decorators@api,@track, and@wireplay crucial roles. The@apidecorator is used to expose public properties and methods, making them accessible to other components. The@trackdecorator is used to mark private properties as reactive, so the UI updates when their values change. The@wiredecorator is used to wire Apex methods or Salesforce data to the component. Salesforce documentation on LWC development extensively covers these decorators, explaining their usage and best practices.

In Salesforce, standard page reference types are used within the Lightning Component framework to reference different types of resources. The types includestandard__appfor Salesforce apps,standard__componentfor Lightning components, andstandard__recordPageto reference a specific record detail or edit page (notstandard__recordDetailPage, but it's implied). Thestandard__pageNamedandcomm_loginPageare not standard page reference types recognized by Salesforce. For more details, refer to the Salesforce documentation on PageReference Types:Salesforce PageReference Types Documentation.

Two data types that are considered discrete units of work (code units) within a transaction in the debug logs are web service invocation and Apex class. A discrete unit of work (code unit) is a segment of executable code that runs as part of a transaction in Salesforce. A transaction is a sequence of operations that are treated as a single unit of work and are executed under certain isolation and consistency rules. A transaction can consist of one or more discrete units of work (code units) that are executed sequentially or concurrently depending on various factors such as triggers, asynchronous calls, or limits. A debug log is arecord of database operations, system processes, and errors that occur when executing a transaction or running unit tests in Salesforce. A debug log can capture information about each discrete unit of work (code unit) within a transaction, such as its start time, end time, duration, events, variables, and limits. A web service invocation is a type of discrete unit of work (code unit) that involves calling an external web service from Apex code using SOAP or REST protocols. A web service invocation can be synchronous or asynchronous depending on the method used to make the callout. A web service invocation can be captured in a debug log with its details and results. An Apex class is another type of discrete unit of work (code unit) that involves executing Apex code that defines a class with properties and methods. An Apex class can be invoked from various sources such as triggers, Visualforce pages, Lightning components, or API calls. An Apex class can be captured in a debug log with its details and results. A validation rule is not a type of discrete unit of work (code unit) within a transaction in the debug logs, as it is not a segment of executable code but rather a formula expression that defines a business rule for a field or object. A validation rule can be evaluated during a transaction and cause an error if the rule condition is not met, but it cannot be captured as a separate code unit in a debug log. A Lightning component load is not a type of discrete unit of work (code unit) within a transaction in the debug logs either, as it is not a segment of executable code but rather an event that occurs when a Lightning component is rendered on a web page or application. A Lightning component load can be measured by various performance tools such as Lightning Inspector or Lighthouse, but it cannot be captured as a separate code unit in a debug log. Salesforce References: [Salesforce Developer Blog: Transactions and Request Processing], [Salesforce Help: Debug Logs], [Salesforce Developer Guide: Invoking Callouts Using Apex], [Salesforce Developer Guide: Apex Classes], [Salesforce Help: Validation Rules], [Salesforce Developer Blog: Measuring Lightning Component Performance]

Lightning Data Service (LDS) is a Salesforce UI API layer that empowers developers to perform CRUD operations and manage Salesforce data without the need for custom Apex controllers. LDS is designed to improve performance, user interface consistency, and developer productivity by handling data operations and sharing rules, thus reducing the need for server-side code. For more details, refer to the Salesforce documentation on Lightning Data Service:Salesforce Lightning Data Service Documentation.

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

 To wrap a Lightning Web Component inside an Aura component, you need to use the  tag, where c is the default namespace for custom components. This tag allows you to reference the Lightning Web Component by its name and use it as a child component of the Aura component. You also need to use the lwc:dom="manual" directive on the Aura component to indicate that you are manually rendering the Lightning Web Component inside the Aura component. This directive prevents the Aura component from interfering with the rendering of the Lightning Web Component. Option C shows the correct syntax for wrapping a Lightning Web Component inside an Aura component. Option A is incorrect because it uses the  tag, which is not a valid tag for referencing a Lightning Web Component. Option B is incorrect because it uses the  tag, which is also not a valid tag for referencing a Lightning Web Component. Option D is incorrectbecause it does not use the lwc:dom="manual" directive on the Aura component, which is required for manually rendering a Lightning Web Component inside an Aura component. References: Composition | Lightning Web Components Developer Guide, Using Lightning Web Components inside Aura Components, Aura Coexistence | Lightning Web Components Developer Guide

To make Lightning Web Components mobile-ready, one maintainable approach is to create a Lightning app page and then add the component to the mobile navigation. This ensures that the component is accessible and optimized for mobile users within the Salesforce mobile app. Another approach is to design the component's templates with responsiveness in mind, using CSS and layout techniques that adapt to different screen sizes. Salesforce documentation on mobile-ready development practices provides guidelines on creating responsive designs and optimizing components for mobile use.

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. Each 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

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 automate 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 developer 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-drop 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 target value. Salesforce References: Lightning Web Components Developer Guide: Configure Components for Flows, Lightning Web Components Developer Guide: Communicate with Flow, Lightning Flow Developer Guide: Screen Components Basics

Three actions that are applicable when modifying the number of steps required in the Salesforce Commerce Checkout flow are:

• Perform a template override on the Checkout page. This action will allow you to change the structure and content of the Checkout page, such as adding or removing sections, widgets, or fields. For example, you can override the checkout.handlebars template and modify it according to your requirements.
• Set the value of the configuration setting defined as CO.overrideFlow to TRUE. This setting will enable you to use your own custom checkout flow instead of the default one. You need to set this value to true before you can modify the checkout flow.
• Set the value of the configuration setting defined as CO.useDef to TRUE. This setting will enable you to use a single-page checkout flow instead of a multi-step checkout flow. You need to set this value to true if you want to reduce the number of steps in the checkout flow to one. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Checkout Flow

To fire a custom event called CustomEvent from the Lightning web component and propagate it up to the DOM, the developer must set two event settings: bubbles and composed. The bubbles setting determines whether the event bubbles up through the component’s ancestors in the DOM tree. The composed setting determines whether the event crosses the shadow boundary and reaches the light DOM. Setting both bubbles and composed to true allows the event to be handled by any element in the DOM that listens for it. The cancelable setting is not required for firing or propagating the event, as it only determines whether the event can be canceled by calling preventDefault() on it. Setting composed to false would prevent the event from reaching the light DOM and limit its propagation to the shadow DOM. Salesforce References: Lightning Web Components Developer Guide: Create and Dispatch Events, Lightning Web Components Developer Guide: Event Propagation

In general best practices for tax implementation in systems like Salesforce B2B Commerce, previous tax entries are usually preserved or saved before any recalculation is performed. This ensures that there is a record of the original tax calculations before any modifications, which can be crucial for auditing, historical data integrity, and in case the new tax calculation needs to be rolled back for any reason.

A valid way of referencing the CC Cart Object whose API name is E_Cart__c in a SOQL query is to use ccrz__E_Cart__c. This is the transformed name of the object that is used by the Salesforce B2B Commerce framework. All custom objects and fields that are part of the cloudcraze managed package have the prefix ccrz__ in their API names. For example, SELECT Id, Name FROM ccrz__E_Cart__c will query the CC Cart Object records. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Query Transformation

To know if a CSS file containing small changes was actually deployed to the org, one way that a developer can accomplish this is by right-clicking the CSS file and choosing Diff File Against Org. Diff File Against Org is an option that allows the developer to compare a local file with its remote version in the org using Salesforce CLI commands. The developer can use Visual Studio Code to execute these commands by right-clicking on files or folders in the project and choosing from various diff options. Right-clicking the CSS file and choosing Diff File Against Org allows the developer to see the differences between the local CSS file and the remote CSS file in the org side by side in Visual Studio Code. This way, the developer can verify if their changes were deployed successfully or not. Clicking the Tools menu and selecting Diff Styles Against Org… is not a valid way to know if a CSS file was deployed to the org, as there is no such option in Visual Studio Code or Salesforce CLI. Right-clicking the folder for the component and choosing Diff Styles Against Org is not a valid way either, as there is no such option in Visual Studio Code or Salesforce CLI. Right-clicking the folder for the component and choosing Diff Files Against Org is not a valid way either, as it will compare all the files in the folder, not just the CSS file, which may not be efficient or necessary. Salesforce References: [Salesforce CLI Command Reference: force:source:diff], [Salesforce Developer Tools for Visual Studio Code]

The developer forgot to publish the storefront after making changes to the products. Publishing the storefront is a necessary step to make the changes visible to the store visitors. Publishing the storefront updates the site’s metadata and content, and also triggers the site index and search index rebuilds. If the developer does not publish the storefront, the changes will not be reflected on the live site.

The following actions are not required or relevant for the scenario:

• Activate the product list. This action is only needed when creating a new product list or modifying an existing one. It does not affect the visibility of the products on the storefront.
• Rebuild the search index. This action is automatically performed when the developer publishes the storefront. It is not a separate step that the developer needs to take manually.
• Publish the catalog. This action is not applicable for Salesforce B2B Commerce for Visualforce, which does not use catalogs. Catalogs are only used by Salesforce B2B Commerce for Lightning Experience.

References:

• Finalize and Publish Your Storefront
• Customize the D2C Store Template
• Configure Public Pages for a Storefront

The XML fragment that the developer should include in the component’s configuration XML file to ensure the custom component is available to add to the page is option B. Option B uses the tag to specify where the component can be used in an app. The tag contains a list of tags, each of which defines a valid target for the component. The value of the tag for the Product Detail page in the store is lightningCommunity__RecordPage, which means that the component can be used on any record page in a Lightning community. Option A is incorrect because it uses an invalid value for the tag. There is no such target as lightningCommunity__ProductDetailPage. Option C is incorrect because it uses an invalid syntax for the tag. The tag should not have any attributes, such as isAvailable. Option D is incorrect because it uses an invalid syntax for the tag. The tag should not be self-closing, but rather have a closing tag (). Salesforce References: Lightning Web Components Developer Guide: Configure Components for Lightning Communities, Lightning Web Components Developer Guide: Configure Components for Different Pages and Apps

To override inventory in the checkout process, a developer must implement thesfdc_checkout.CartinventoryValidationinterface. This interface provides the necessary methods for custom inventory validation logic, allowing developers to define how inventory 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 next step that the developer should do after suspecting that recent edits made to a checkout flow have created a defect and having data points available to use as inputs in reproducing the scenario is to open the flow, select Debug, provide the Input values, and select Run. A flow is a type of application that automates a business process by collecting data and performing actions in Salesforce or an external system. A flow can be used to customize the checkout process in the storefront by defining the steps and logic that are executed when a customer places an order. A flow can be edited or modified using Flow Builder, a point-and-click tool that allows developers to create and manage flows. Flow Builder also provides debugging and testing tools that allow developers to run and troubleshoot flows before deploying them. To debug or test a flow, the developer can open the flow in Flow Builder, select Debug from the toolbar, provide the Input values for the flow variables, and select Run. This will execute the flow in debug mode, which simulates how the flow runs in the org with real data. The developer can use debug mode to verify if the flow works as expected or if there are any errors or issues with the flow logic or actions. Open the flow, select Attach to Live Session, provide the session ID, and select Attach is not a valid next step, asit is not a feature or option available in Flow Builder or Salesforce CLI. Attach to Live Session is a feature that allows developers to attach a debugger to a running Apex session and inspect the state of the code execution. Open the flow, select Debug with Inputs, provide the Input values, and select Run is not a valid next step either, as it is not a feature or option available in Flow Builder or Salesforce CLI. Debug with Inputs is a feature that allows developers to debug an Apex class or trigger with predefined input values and breakpoints. Open the flow, select Debug, provide the session ID for replay, and select Run is not a valid next step either, as it is not a feature or option available in Flow Builder or Salesforce CLI. Replay is a feature that allows developers to replay an Apex log file and inspect the state of the code execution at each line. Salesforce References: [B2B Commerce Developer Guide: Customize Checkout Flows], [Salesforce Help: Flow Builder], [Salesforce Help: Debug Your Flows], [Salesforce Developer Blog: Apex Replay Debugger]

Three pages that should be enabled for the Guest user profile for a storefront to have anonymous checkout are:

• CCPaymentInfo: This page allows the guest user to enter their payment information, such as credit card number, expiration date, and security code. The page also displays the order summary and total amount.
• CheckoutNew: This page allows the guest user to enter their shipping and billing information, such as name, address, phone number, and email. The page also displays the cart items and shipping options.
• OrderConfirmation: This page displays the confirmation message and order number after the guest user places their order. The page also provides a link to view the order details or print the invoice. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Anonymous Checkout

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 responsible 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

The static method invocation that is used to initialize ccrz.cc_CallContext with information from ccrz.cc_RemoteActionContext and return an instance of ccrz.cc_RemoteActionResult in an Apex @RemoteAction method is ccrz.cc_CallContext.initCallContext(ccrz.cc_RemoteActionContext). This method takes in a ccrz.cc_RemoteActionContext object as a parameter and returns a ccrz.cc_RemoteActionResult object. The ccrz.cc_RemoteActionContext object contains information about the current storefront, user, cart, price list, currency, locale, and session. The ccrz.cc_RemoteActionResult object contains information about the status, result, and errors of the remote action. The other methods are not valid or do not exist. Salesforce References: B2B Commerce Developer Guide: cc_CallContext Class, B2B Commerce Developer Guide: cc_RemoteActionContext Class, B2B Commerce Developer Guide: cc_RemoteActionResult Class

To implement specific styling for a standard component on a single page of the B2B Commerce store using an Aura template, 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 assign 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 import 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 web 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 contentlayout. Using the Override CSR Editor in the Experience Builder 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 Component, B2B Commerce Developer Guide: Override CSR Editor

When naming a Lightning Web Components folder and associated files, Salesforce best practices allow the name to begin with a lowercase letter and to use a single hyphen (dash) for compound names.Whitespace and underscores are not recommended in the naming convention. This is in line with web standards for custom elements. More details can be found in the Salesforce LWC documentation on naming conventions:Salesforce LWC Naming Conventions.

To name a Lightning web component’s folder and associated files, the developer should follow these naming rules:

• Must begin with a lowercase letter
• Must contain only alphanumeric or underscore characters
• Must be unique in the namespace
• Can’t include whitespace
• Can’t end with an underscore
• Can’t contain two consecutive underscores
• Can’t contain a hyphen (dash)

The only exception to the last rule is when separating the namespace from the component name in markup. For example, if the component is in the example namespace and has the name myComponent, the folder name should be myComponent, but the markup tag should be . The hyphen character (-) is required by the HTML standard for custom element names. The other options are either invalid or not recommended. For example, including whitespace or using consecutive underscores will cause errors, and using a single underscore will look odd and may confuse developers consuming the component. References: B2B Commerce and D2C Commerce Developer Guide, Lightning Web Components Developer Guide

n: The Commerce Product Data Import resource is the recommended tool for importing products for a B2B or B2C store using a .csv file. This resource supports importing data of related objects, such as ProductCatalog, ProductCategory, Product2, and ProductCategoryProduct, while preserving their relationships. It also does not require additional licenses or third-party tools. The other options are either not specific to Commerce products, or do not support importing data of related objects. References:

• Commerce Product Import Resource
• Import and Export Commerce Data
• B2B and D2C Commerce Data Model

Two statements that are accurate about the Cart Item with a Type of Charge are that it is linked directly to a Cart Id and that it is linked directly to a Catalog Id. A Cart Item with a Type of Charge is a special type of Cart Item that represents an additional charge or fee that is applied to a Cart, such as shipping, handling, or tax. A Cart Item with a Type of Charge is linked directly to a Cart Id, which means that it belongs to a specific Cart and can be retrieved or updated along with other Cart Items. A Cart Item with a Type of Charge is also linked directly to a Catalog Id, which means that it references a specific Catalog that contains the products and prices for the store. A Cart Item with a Type of Charge is not created with the Cart Delivery Group Method after the shipping integration or after the freight integration, as these are not related to the creation of Cart Items. The Cart Delivery Group Method is a method that determines how products are grouped into delivery groups based on their shipping methods and addresses. The shipping integration and the freight integration are integrations that calculate and apply shipping costs and freight charges to a Cart or an Order. Salesforce References: B2B Commerce Developer Guide: Cart Item Object, B2B Commerce Developer Guide: Shipping Integration, B2B Commerce Developer Guide: Freight Integration

Similar to question 198, when custom code compares external prices with sales prices for cart items and finds them to be the same, the appropriate return value should indicate a successful comparison (such assfdc_checkout.IntegrationStatus.Status.SUCCESS). This signifies that the external prices are aligned with the sales prices, and there are no conflicts.