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

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

Two aspects that are applicable to Page Includes are:

• Standard Visualforce controls such as apex:form should not be used within a page include. This is because the page include is rendered inside an existing Visualforce page that already has a form element. Using another form element inside the page include will cause conflicts and errors. Instead, the page include should use HTML elements or custom components that do not require a form element.
• Page Includes can be configured as Body Includes Begin. This means that the page include will be rendered at the beginning of the body section of the page, before any other content or widgets. This can be useful for adding some custom content or functionality that applies to the whole page, such as a banner, a modal, or a script. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Page Includes

 To implement a custom child checkout component for a B2B or B2C store created with an LWR template, the developer must implement the CheckoutStep interface from the commerce/checkout module. This interface defines the methods and properties that the child component must have to communicate with the parent checkout component and the checkout data provider. The CheckoutStep interface extends the UseCheckoutComponent interface, which provides the common functionality for all checkout components, such as loading and saving data, reporting validity, and handling errors.

The other options are not correct because:

• A. CheckoutSavable is not a valid interface for a custom child checkout component. There is no such interface in the commerce/checkout module or the Lightning web component framework.
• B. Checkoutoutinterface is not a valid interface for a custom child checkout component. There is no such interface in the commerce/checkout module or the Lightning web component framework.
• C. CustomCheckout is not a valid interface for a custom child checkout component. There is no such interface in the commerce/checkout module or the Lightning web component framework.

References:

• Create a Custom Checkout Component for a B2B or B2C Store (LWR)
• CheckoutStep Interface
• UseCheckoutComponent Interface

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

Two advantages of using Lightning Data Service are that it combines and de-duplicates server calls and that it loads record data progressively. Lightning Data Service is a service that provides access to Salesforce data and metadata in Lightning web components. It optimizes performance and minimizes server round trips by caching data on the client side and sharing data across components. It also combines and de-duplicates server calls by batching requests for the same record or object and returning a single response. It also loads record data progressively by returning available cached data first and then fetching updated data from the server asynchronously. Communicating with other components and converting between different data formats are not advantages of using Lightning Data Service, as they are not related to its functionality or features. Salesforce References: Lightning Web Components Developer Guide: Lightning Data Service, Lightning Web Components Developer Guide: Work with Salesforce Data

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

To help troubleshoot and respond to actions in checkout, the developer’s code should listen for CommerceDiagnosticEvents. CommerceDiagnosticEvents is an event that is fired by Salesforce B2B Commerce when an error occurs in the storefront. CommerceDiagnosticEvents contains information about the error, such as error code, error message, error type, and error details. CommerceDiagnosticEvents can be subscribed by other components or services that want to handle or display the error information in different ways. The developer’s code can listen for CommerceDiagnosticEvents using an aura:handler tag in Aura Components or an @wire decorator in Lightning web components. The developer’s code can also use the event information to perform custom logic or actions based on the error, such as logging, reporting, or notifying. CommerceBubbleEvents is not an event that the developer’s code should listen for in checkout, as it is not related to troubleshooting or responding to actions. CommerceBubbleEvents is an event that is fired by Salesforce B2B Commerce when a user interacts with a bubble component in the storefront. A bubble component is a user interface element that displays information or options in a pop-up window when clicked or hovered over. CommerceBubbleEvents contains information about the user interaction, such as bubble name, bubble type, and bubble value. CommerceErrorEvents is not an event that the developer’s code should listen for in checkout either, as it is not related to troubleshooting or responding to actions. CommerceErrorEvents is an event that is fired by Salesforce B2B Commerce when a validation error occurs in the storefront. CommerceErrorEvents contains information about the validation error, such as field name, field label, and error message. CommerceActionEvents is not an event that the developer’s code should listen for in checkout either, as it is not related to troubleshooting or responding to actions. CommerceActionEvents is an event that is fired by Salesforce B2B Commerce when a user performs an action in the storefront. CommerceActionEvents contains information about the user action, such as action name, action type, and action parameters. Salesforce References: B2B Commerce Developer Guide: Handle Errors, B2B Commerce Developer Guide: Handle User Interactions with Bubble Components, B2B Commerce Developer Guide: Handle Validation Errors, B2B Commerce Developer Guide: Handle User Actions

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.

Salesforce documentation clarifies the interoperability between Aura and Lightning Web Components (LWCs). An Aura component can indeed contain another Aura component, as well as a LWC, allowing for a mix of component technologies in a single application. However, due to the architectural and design principles of LWCs, a LWC cannot contain an Aura component. This is because LWCs are designed to be lightweight and leverage web standards, which makes them not fully compatible with the older Aura component framework in terms of containment.

The difference between Gross Layout Overrides and Subscriber Templates is that Subscriber Templates allow for modification of the header and the footer, while Gross Layout Overrides allow for modification everything inside the header and footer. Subscriber Templates are custom Visualforce pages that can replace the standard header and footer components on a page. Gross Layout Overrides are custom Visualforce pages that can replace the default layout of a page, such as the number of columns, theposition of widgets, or the content of sections. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Subscriber Templates, Gross Layout Overrides

To create an event listener on a parent component programmatically, the developer should use the following line of code:

this.template.addEventListener(‘notification’, this.handleNotification);

This line of code adds an event listener to the template element of the parent component, which is the root element that contains all the child elements. The event listener listens for an event named ‘notification’, which is a custom event that can be dispatched by any child component. The event listener invokes a method named handleNotification, which is an arrow function defined in the parent component class. The handleNotification method receives the event object as a parameter and can perform any logic based on the event data. The other lines of code are either incorrect or incomplete. Salesforce References: Lightning Web Components Developer Guide: Communicate with Events, Lightning Web Components Developer Guide: Create and Dispatch Events

Two ways that a developer should configure taxes in B2B Commerce for Ursa Major are: configure a tax engine using third-party software and configure tax rates and rules for each state in Salesforce B2B Commerce. Configuring a tax engine using third-party software allows the developer to integrate with an external tax service provider that can calculate and apply accurate and up-to-date tax rates and rules for different states and jurisdictions. The developer can use the sfdc_checkout.TaxCalculations interface or the RegisteredExternalService object to connect to the third-party tax service provider’s API or service. Configuring tax rates and rules for each state in Salesforce B2B Commerce allows the developer to implement their own custom tax calculation logic using Apex code. The developer can use custom objects, such as TaxRate__c and TaxRule__c, to store and manage tax rates and rules for different states and products. The developer can also use the sfdc_checkout.TaxCalculations interface to define how to retrieve and apply tax rates and rules for a cart or an order. Using a different pricebook for each state is not a good way to configure taxes in B2B Commerce, as it can create complexity and inconsistency in pricing and discounting logic. Using the Salesforce out-of-the-box tax calculator is not a good way either, as it does not support complex or dynamic tax scenarios that may vary by state or jurisdiction. Salesforce References: [B2B Commerce Developer Guide: Tax Integration], [B2B Commerce Developer Guide: Tax Calculations Interface], [B2B Commerce Developer Guide: TaxRate Object], [B2B Commerce Developer Guide: TaxRule Object]

A price group can be dynamically set by extending the cc_hk_pricing hook. This hook allows modifying the price group based on various factors, such as the user, cart, product, or storefront. For example, the hook can apply a different price group for a specific product category or for a specific user segment.

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 function 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 public 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 propertycalled _name. Option D shows the setter 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 property. References:

• Getters and Setters
• Understand getter in Lightning Web component