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

When implementing an Inventory class for checkout and indicating that inventory is available for all items and amounts in the cart, the correct step is to returnsfdc_checkout.InventoryStatus.Status.SUCCESS. This indicates to the checkout process that the inventory check has passed and the items are available. Salesforce documentation on customizing inventory validation in the checkout process would detail the expected return types and values, ensuring that developers implement the inventory checks in a manner consistent with the platform's requirements.

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?

To handle the subscription 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 should 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 valid 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 lifecycle of a message channel. There is no such method in the lightning/messageService module or the Lightning web component framework.

References:

• Subscribe and Unsubscribe from a Message Channel
• Lifecycle Hooks
• Use message channel in both direction

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

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

 A developer needs to make a call to a long running web service which is critical to finalizing their checkout process. The developer should consider the following items in their implementation:

• A new CORS entry may need to be created in Setup. CORS stands for Cross-Origin Resource Sharing, which is a mechanism that allows web browsers to make requests to servers on different domains. If the web service is hosted on a different domain than the B2B Commerce site, the developer may need to add a CORS entry in Setup to allow the browser to access the web service. This entry specifies the origin, path, and method of the request, as well as any headers or cookies that are allowed1.
• A new Named Credential may need to be created in Setup. A Named Credential is a type of metadata that stores the URL and authentication settings of a web service. By using a Named Credential, the developer can avoid hardcoding the web service URL and credentials in their code, and instead reference the Named Credential by name. This makes the code more secure and easier to maintain2.
• An Apex method returning a Continuation will need to be created. A Continuation is a special type of Apex object that allows the developer to make asynchronous calls to long running web services. By using a Continuation, the developer can avoid blocking the main thread and improve the user experience. A Continuation method must return a Continuation object, specify the web service URL and parameters, and register a callback method that handles the response3.

Option D and Option E are incorrect because they are not relevant to the scenario. Option D suggests that the developer should broker the requests to the web service, which means to use an intermediary service that manages the requests and responses. This may be useful for some scenarios, but it is not required for making a call to a long running web service. Option E suggests that the developer shouldcreate a new Remote Site in Setup, which is a way to whitelist the domains that can be accessed from Apex code. However, this is not necessary if the developer uses a Named Credential, which automatically handles the Remote Site setting2. References:

• Set Up CORS
• Named Credentials
• Continuation Class

Lightning Web Components (LWC) use<slot>elements to define areas within the component's template where content can be inserted dynamically. This feature, part of the Web Components standard, allows for the creation of customizable and reusable components. Salesforce developer documentation on LWC outlines the use of slots to build flexible component interfaces, enabling developers to design components that can adapt to various content structures and layouts.

Two different types of services that Salesforce B2B Commerce APIs leverage are:

• Logic services which are responsible for implementing business logic associated with entities. These services are defined in the logic classes, such as ccrz.ccLogicCart, ccrz.ccLogicOrder, or ccrz.ccLogicProduct. These classes provide methods for validating inputs, performing calculations, applying rules, or updating data for each entity.
• Data services which are responsible for querying and transforming data from entities. These services are defined in the service classes, such as ccrz.ccServiceCart, ccrz.ccServiceOrder, or ccrz.ccServiceProduct. These classes provide methods for creating, reading, updating, and deleting data for each entity. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Service Classes, Logic Classes

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]

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]

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 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 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 pageMessage event and display an error message on the page. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Events, Util Class

 To debug a flow and watch all the variables changing as the checkout process is executed, the developer needs to enable two features: show the details of what is executed and render flow in either Lightning Runtime or Lightning Experience. These features are available in the debug options in Flow Builder, and they allow the developer to see real-time details of the flow actions, inputs, outputs, and outcomes in a panel on the right. The developer can also set input variables, restart the flow, and convert the debug run to a test. Option A is incorrect because there is no such thing as a debug tog in Flow Builder. Option C is incorrect because running the latest version of each flow called by subflow elements is not a feature that the developer can enable or disable, but rather a default behavior of Flow Builder. References: Debug a Flow in Flow Builder, B2B Commerce Checkout Flow (Aura), B2B Commerce Checkout Flow Core Actions

In the context of Salesforce debug logs, code units represent discrete units of work within a transaction. Apex classes (B), Web service invocations (C), and Workflow invocations (E) are considered code units as they encapsulate specific operations or sets of logic that can be executed as part of a transaction. Validation rules (A) and the loading of Lightning components (D) are not considered discrete units of work in the same way, as they are part of the declarative interface and front-end framework, respectively. For more details on how Salesforce handles transactions and debug logs, refer to the Salesforce Developer Documentation:Salesforce Developer Documentation on Transactions and Debug Logs.

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

To make an API call in a Lightning web component (LWC), a developer should use the connectedCallback lifecycle hook. The connectedCallback lifecycle hook is invoked when the component is inserted into the DOM. This is the ideal time to make an API call, as the component is ready to receive and display data. Thedeveloper can use the fetch API or a third-party library, such as axios, to make the API call and handle the response. The renderedCallback lifecycle hook is not a good choice for making an API call, as it is invoked every time the component is rendered or rerendered. This can cause unnecessary or repeated API calls and affect performance. The errorCallback lifecycle hook is not a good choice either, as it is invoked when an error occurs in the component or in one of its children. This is not related to making an API call, but rather to handling errors. The disconnectedCallback lifecycle hook is not a good choice either, as it is invoked when the component is removed from the DOM. This is not a suitable time to make an API call, as the component is no longer visible or active. Salesforce References: Lightning Web Components Developer Guide: Lifecycle Hooks, Lightning Web Components Developer Guide: Call an Apex Method Imperatively

To debug a specific block of Apex code, the Execute Anonymous window in the Salesforce Developer Console or an Integrated Development Environment (IDE) like Visual Studio Code with the Salesforce Extension Pack can be used. This tool allows developers to run Apex code snippets in isolation and observe the results immediately, which is valuable for identifying and resolving defects within specific code blocks.

In a Lightning Web Component's HTML file, using<article>,<body>, or<html>as the first (root) element would produce an error because the LWC framework requires<template>as the root tag. The<template>tag is necessary for defining the component's structure and supports the framework's reactive and rendering capabilities. The use of other HTML tags as the root element is not supported and will result in an error during component compilation or runtime. Refer to the Salesforce LWC documentation for proper component structure:Salesforce LWC Component Structure Documentation.

Three data types that are supported for custom fields while using CSV file format for importing data for a store are Text Area(Long), Lookup Relationship, and Currency. A custom field is a field that is added by a developer or an administrator to an object to store additional information or data. A data type is a property that defines the type, format, and validation rules of a field. A CSV file is a file format that stores tabular data in plain text using commas to separate values. A store is a record that represents a B2B or B2C storefront in Salesforce. Text Area(Long) is a data type that allows users to enter up to 131,072 characters on separate lines. Text Area(Long) is supported for custom fields while using CSV file format for importing data for a store. Lookup Relationship is a data type that allows users to create a relationship between two objects and select a value from another record. Lookup Relationship is supported for custom fields while using CSV file format for importing data for a store. Currency is a data type that allows users to enter currency values and automatically convert them based on the user’s locale and currency settings. Currency is supported for custom fields while using CSV file format for importing data for a store. Picklist (Multi-Select) is a data type that allows users to select one or more values from a predefined list of values. Picklist (Multi-Select) is not supported for custom fields while using CSV file format for importing data for a store. Address is a data type that allows users to enter address values and automatically format them based on the user’s locale settings. Address is not supported for custom fields while using CSV file format for importing data for a store. Salesforce References: [Salesforce Help: Custom Field Attributes], [Salesforce Help: Data Types], [Data Loader Guide: Import Data into Salesforce], [B2B Commerce Developer Guide: Store Object]

Two components in a B2B store template that a developer can use to customize a storefront page are My Lists and Product List. My Lists is a standard component that displays and manages lists of products that customers can create, save, or share in the storefront. A developer can use this component to enable customers to organize their favorite or frequently purchased products into lists and access them easily. Product List is a standard component that displays and filters products from one or more product lists in the storefront. A developer can use this component to showcase products from different categories or collections and allow customers to browse or search for products based on various criteria. Order List is not a component in a B2B store template, but rather an object that stores information about orders placed by customers in the storefront. Address List is not a component either, but rather an object that stores information about addresses associated with customers in the storefront. Salesforce References: [B2B Commerce Developer Guide: My Lists Component], [B2B Commerce Developer Guide: Product List Component], [B2B Commerce Developer Guide: Order List Object], [B2B Commerce Developer Guide: Address List Object]

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

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

The method 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

An essential requirement for a Salesforce B2B Commerce theme to show up in the theme section in CC Admin is that the theme needs to have “theme” in the name of the Static Resource. For example, a theme named “MyTheme” will not appear in CC Admin, but a theme named “MyTheme_theme” will. This is how the framework identifies which static resources are themes and which are not. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Themes

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

Option 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 plugins4. Salesforce CLI is a command line interface that allows the developer to create, deploy, and manage Lightning web components projects5. 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]

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 value 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 aclosing tag (</template>), not a self-closing tag (<template/>). Salesforce References: Lightning Web Components Developer Guide: Conditional Rendering, Lightning Web Components Developer Guide: Template Syntax

The Salesforce B2B Commerce object that needs to have a record added when defining a new Subscriber Page to be rendered in a CC Page is CC Subscriber Pages. This is a custom object that stores information about the Subscriber Pages, such as the name, description, URL, and Visualforce page. To create a new Subscriber Page, the user needs to create a new record in this object and specify the required fields. The user can then select the Subscriber Page from the CC Page Settings configuration in CCAdmin. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Subscriber Pages

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.

To modify the out-of-the-box checkout flow template in Salesforce B2B Commerce, a developer should clone the existing template, make the necessary modifications, activate the modified template, and then reference it in the Experience Builder. This approach ensures that the original template remains intact and provides a fallback option. Salesforce documentation on customizing the checkout flow in B2B Commerce emphasizes the importance of using the Experience Builder for such customizations, providing a visual interface to manage and reference different checkout flow templates.

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.

A theme can be enabled in Salesforce B2B Commerce in three different ways:

• A Storefront setting: The theme can be specified in the Storefront Configuration settings in CCAdmin. This will apply the theme to all users who access the storefront.
• An Account Group field value: The theme can be specified in the Theme field of an Account Group record in Salesforce. This will apply the theme to all users who belong to that account group.
• Dynamically through a hook: The theme can be specified dynamically by extending the cc_hk_theme hook. This hook allows changing the theme based on various factors, such as the user, cart, product, or storefront. For example, the hook can apply a different theme for a specific product category or for a specific user segment.

When a developer configures a tax integration for a store, the previously calculated tax entries during the checkout flow are deleted from the Cart. A tax integration is an integration that calculates and applies tax rates and amounts to a Cart or an Order based on various factors, such as product type, price, quantity, location, and tax rules. A tax integration can use either an external tax service provider or custom Apex code to perform the tax calculation. When a developer configures a tax integration for a store, any existing tax entries in the Cart are deleted before calling the tax integration service or method. This ensures that the tax calculation is accurate and up-to-date based on the current state of the Cart and avoids any conflicts or inconsistencies with previous tax entries. The previously calculated tax entries are not ignored during recalculation, saved prior to recalculation, or modified with the new tax calculation, as these are not valid actions for handling existing tax entries. Salesforce References: B2B Commerce Developer Guide: Tax Integration, B2B Commerce Developer Guide: Tax Calculation Flow

To investigate a suspected bug in a checkout flow, comparing previous versions of the flow with the current one can help identify changes that might have introduced the bug. Additionally, Salesforce provides debugging capabilities within the Flow Builder, where a developer can select the debug option, provide input values known to trigger the issue, and execute the flow to observe its behavior, aiding in pinpointing the source of the problem.

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]

In Lightning Web Components, wire adapters are used to retrieve and manipulate Salesforce data. Wire adapters abstract the underlying data access mechanism, providing a declarative way to access Salesforce data and metadata. Salesforce documentation on LWC and the@wiredecorator details how wire adapters can be used to connect components to Salesforce data sources, including standard and custom objects, facilitating reactive data binding and efficient data retrieval.

In Salesforce, developers can subscribe to platform events using both Flows and Apex Triggers. This allows for the execution of automated processes in response to the events. Apex Triggers can be written to respond to event messages in the same way they respond to DML events. Similarly, Flows can be configured to trigger upon the receipt of a platform event. This functionality is documented in Salesforce's developer guides and best practices, which emphasize the versatility and power of combining declarative and programmatic approaches to respond to platform events.

The use of a standard Visualforce control such as apex:form is discouraged 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 properties, 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 the 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 References: B2B Commerce Developer Guide: CCRZ JavaScript Object, B2B Commerce Developer Guide: Page Includes

For a deployable Lightning Web Component likedisplayMyData, 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 file (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 deployment requirements:Salesforce LWC Deployment Documentation.

When creating a tax provider in Salesforce B2B Commerce, developers should consider the data format (JSON or XML) for interoperability with the tax service, define clear success criteria to ensure accurate tax calculations, and implement robust error handling to manage exceptions and failures gracefully. Salesforce B2B Commerce documentation emphasizes the importance of these considerations for integrating external services, ensuring reliability and consistency in tax calculations across different jurisdictions and scenarios.

To bring some historical data into an org, the data must reside in the org, but cannot be populated in standard or custom objects, and the customer is fine with developers building UI components to surface this data on a case-by-case basis, the option that allows a developer to meet all of these requirements is big objects. Big objects are a type of object that can store and manage massive amounts of data on the Salesforce platform. Big objects can store up to billions of records and are accessible through a subset of SOQL or custom user interfaces. Big objects are not subject to the same storage limits or performance issues as standard or custom objects and are suitable for storing historical or archived data that does not need to be updated frequently. Big objects can be defined using Metadata API or declaratively in Setup. Lightning Canvas is not an option that allows a developer to meet all of these requirements, as it is a framework that allows developers to integrate third-party applications into Salesforce. Lightning Canvas does not store data in the org, but rather displays data from external sources using an iframe. External objects are not an option either, as they are a type of object that map to data stored outside Salesforce. External objects do not store data in the org, but rather access data from external systems using OData services. Lightning Out is not an option either, as it is a feature that allows developers to use Lightning components outside Salesforce. Lightning Out does not store data in the org, but rather renders components on external web pages or applications. Salesforce References: Salesforce Help: Define BigObjects, Salesforce Help: Lightning Canvas Developer’s Guide, Salesforce Help: External Objects, Salesforce Developer Blog: Lightning Out

To override tax in checkout, a developer must implement the sfdc_checkout.TaxCalculations interface. The sfdc_checkout.TaxCalculations interface is an Apex interface that provides methods for customizing the tax calculation logic for a cart or an order. The interface allows the developer to define how to retrieve tax rates and rules, how to apply tax amounts and adjustments, and how to handle tax errors and exceptions. The developer can use the sfdc_checkout.TaxCalculations interface to integrate with a third-party tax service provider or to implement their own tax calculation logic. The other interfaces do not exist or are not related to tax calculation. Salesforce References: B2B Commerce Developer Guide: Tax Integration, B2B Commerce Developer Guide: Tax Calculations Interface

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 correct syntax to render a property in a Lightning web component template is to surround the property with curly braces: {property}. This syntax allows you to access the property value from the JavaScript class of the component and display it in the HTML template. The other options are incorrect because they either use invalid characters or do not follow the standard syntax for rendering a property in a Lightning web component template. References: Use JavaScript Properties in Templates | Lightning Web Components Developer Guide

The equivalent of this code in a Lightning web component is option B. Option B uses the @api decorator to expose firstName as a public property of the Lightning web component and communicate it with other components or services. The @api decorator is a decorator that marks a property or method as public, which means that it can be accessed by other components or services that use or consume this component. The @api decorator also makes the property reactive, which means that it can track changes and update the component accordingly. In option B, firstName is exposed as a public property using the @api decorator and passed to the child element using an attribute. Option A is incorrect because it uses an invalid syntax for exposing firstName as a public property. The @api decorator should be used before the property declaration, not after it. Option C is incorrect because it uses an invalid syntax for exposing firstName as a public property. The @api decorator should be used with parentheses, not without them. Option D is incorrect because it uses an invalid syntax for exposing firstName as a public property. The @api decorator should be used with camel case, not with hyphens. Salesforce References: Lightning Web Components Developer Guide: Communicate with Properties, Lightning Web Components Developer Guide: Decorators

 The connectedCallback is a lifecycle hook that is invoked when a Lightning web component is inserted into the DOM. It is used to perform any initialization tasks that depend on the component being rendered, such as fetching data, setting up event listeners, or creating timers. The connectedCallback can fire more than once, for example, when a component is moved or rerendered. The connectedCallback should not be used to change the state of a component, such as loading values or setting properties. Use getters and setters instead. The other options are incorrect because they do not describe the purpose of the connectedCallback. References: Lifecycle Hooks | Lightning Web Components Developer Guide, connectedCallback() in Lightning Web Component - Salesforce Diaries, Chapter 23: connnectedCallback() in Lightning Web Component

In Salesforce B2B Commerce, to reorder a checkout flow step within a sequence, a developer must adjust the 'next-state' attribute in the configuration of the preceding subflow. This approach allows for dynamic control over the sequence of checkout steps without needing to modify the structure of the main checkout flow itself. The Salesforce B2B Commerce documentation outlines how checkout flows are constructed and how subflows can be managed and resequenced through configuration adjustments, providing a flexible and maintainable way to customize the checkout experience.

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

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.

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.

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

Three ways to implement custom post Order processing are:

• Extend cc_hk_invoice to handle custom business logic post Order processing. This hook allows modifying the invoice data or performing additional actions after an Order is placed. For example, the hook can send an email notification or update a custom field on the invoice record.
• Use cc_hk_Order.placeTarget to define a new Order Confirmation page which executes additional business logic. This hook allows specifying a custom Visualforce page that will be displayed after an Order is placed. The custom page can include additional business logic or user interface elements.
• Use Process Builder to implement business processes that execute when an Order record is created. Process Builder is a tool that allows creating workflows and actions based on criteria and conditions. For example, Process Builder can create a task, send an email, or update a record when an Order record is created. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Hooks, Process Builder

The service method that should be overridden in order to allow “without sharing” queries is ccrz.ccService.initSVCDAO. This method is responsible for initializing the service data access object (SVCDAO) that is used by the service class to perform queries. By overriding this method, the user can specify the sharing mode of the SVCDAO, which will determine whether the queries respect or ignore the sharing rules of the current user. For example, ccrz.ccService.initSVCDAO(ccrz.ccAPI.SZ_WITHOUTSHARING) will initialize the SVCDAO with the without sharing mode. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Service Classes, ccService Class

The ccrz.ccUtil.defVal (Map mp, String key, Object ob) method will return the value in the given Map if found or a default value in the event that the Map is null, empty, or an object is not found for that key. This method is useful for providing fallback values for configuration settings or input parameters that may be missing or invalid. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, ccUtil Class

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

To establish communication between components that are not in the same DOM (Document Object Model) tree, a developer can use the publish-subscribe pattern. The publish-subscribe pattern is a messaging pattern that allows components to communicate with each other without being directly connected or aware of each other. The components can publish events to a common channel and subscribe to events from that channel. The channel acts as a mediator that delivers the events to the subscribers. The developer can use a custom library or a Salesforce platform service, such as Lightning Message Service or Platform Events, to implement the publish-subscribe pattern. Configuring the targets property is not a way to communicate between components that are not in the same DOM tree, as it only defines where a component can be used in an app. Using dispatch events is not a way either, as it only works for components that are in the same DOM tree or have a parent-child relationship. Using @api decorators is not a way either, as it only exposes public properties or methods of a component to other components that use it. Salesforce References: Lightning Web Components Developer Guide: Communicate AcrossSalesforce UI Technologies, Lightning Web Components Developer Guide: Communicate with Events, [Lightning Web Components Developer Guide: Communicate with Properties]

When creating a custom Lightning Web Component (LWC) for use in the Checkout Flow, a developer must set the target in the js-meta.xml file tolwc__FlowComponent. This target specifies that the LWC is intended for use within the flow component framework, allowing it to be utilized specifically in the context of Salesforce Flows, including those used in the checkout process. Salesforce documentation on developing custom LWCs for various targets would detail this requirement, ensuring that developers understand how to correctly package and deploy their components for the intended use case.

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.

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

To view the fields available for the Product Detail Page, the developer should type CCRZ.productDetailModel in the Developer Tools Console in the browser. This will display the product detail model object, which contains the product data and attributes that are rendered on the page. The other options are either not valid or not relevant for the Product Detail Page.

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