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

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

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

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]

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.

The correct answer for what is true about mapping custom fields from Cart to Order Summary is that the automatic Cart to Order mapping of custom fields can be disabled. 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 Cart is an object that represents a collection of products and charges that a customer intends to purchase in the storefront. An Order Summary is an object that represents a confirmed purchase of products and charges by a customer in the storefront. A Cart can be converted to an Order Summary when the customer completes the checkout process and confirms their order. By default, Salesforce B2B Commerce automatically maps custom fields from Cart to Order Summary when converting a Cart to an Order Summary. This means that any custom fields that exist on both Cart and Order Summary objects with identical API names and data types will have their values copied from Cart to Order Summary during the conversion. The automatic Cart to Order mapping of custom fields can be disabled by setting the B2BCommerce.CartToOrderMappingEnabled custom setting to false. This will prevent any custom fields from being copied from Cart to Order Summary during the conversion. A custom field must exist in the Cart and Order Summary objects only to be mapped successfully is not true, as it is not the only requirement for mapping custom fields from Cart to Order Summary. The custom fields must also have identical API names and data types, and the automatic Cart to Order mapping of custom fields must be enabled. All data types are supported for custom fields to be mapped from Cart to Order is not true, as some data types are not supported for mapping custom fields from Cart to Order Summary. The supported data types are Boolean, Date, DateTime, Double, Integer, Long, Percent, String, and TextArea. There is a limit of 25 custom fields on a Cart that can be mapped to Order is not true, as there is no such limit for mapping custom fields from Cart to Order Summary. Any number of custom fields that meet the mapping requirements can be mapped from Cart to Order Summary. Salesforce References: [B2B Commerce Developer Guide: Custom Field Mapping], [B2B Commerce Developer Guide: Cart Object], [B2B Commerce Developer Guide: Order Summary Object]

 To make an integration available for selection, a developer must create a RegisteredExternalService record using Workbench and create an Apex class that uses the integration framework. Creating a RegisteredExternalService record using Workbench allows the developer to register their custom integration class as an external service in Salesforce B2B Commerce. The RegisteredExternalService record contains information such as the class name, version, display name, description, and category of the integration class. The category determines where and how the integration class can be used in B2B Commerce, such as ShippingService or TaxService. Creating an Apex class that uses the integration framework allows the developer to define custom logic for integrating with an external service provider’s API or service. The integration framework provides interfaces and classes for various types of integrations, such as shipping, tax, payment, inventory, and freight. The developer can implement these interfaces and classes in their custom Apex class and override their methods with their own logic. Modifying the StoreIntegratedService to map to an Apex class ID using Workbench is not a required step for making an integration available for selection, as it is only used for registering internal services that are provided by Salesforce B2B Commerce out-of-the-box. Entering the integration class name and version in store administration is not a required step either, as it is only used for selecting an existing integration class that has already been registered as an external service. Salesforce References: [B2B Commerce Developer Guide: Integration Framework], [B2B Commerce Developer Guide: RegisteredExternalService Object]

• The correct answer is External Objects. External objects are similar to custom objects, except that they map to data that’s stored outside your Salesforce org12. You can use external objects to access data in real time via web service callouts, without copying the data into your org12. External objects are read-only by default, but you can enable write operations for some data sources12.
• Big Objects are not the correct answer. Big objects allow you to store and manage massive amounts of data on the Salesforce platform. However, big objects are not suitable for referencing historical data in another system, as they require importing the data into the org and incur storage costs.
• Lightning Out is not the correct answer. Lightning Out is a feature that lets you run Lightning components in any container outside the Salesforce platform. However, Lightning Out does not provide a way to reference historical data in another system, as it is mainly used for embedding Lightning components in other web pages or apps.
• External SOQL queries in Apex code are not the correct answer. External SOQL queries are a way to query data from external data sources using SOQL syntax in Apex code. However, external SOQL queries require defining an external data source and an external object first, so they are not a product feature by themselves, but rather a way to use external objects in Apex code. References:
• B2B Commerce on Lightning Experience Developer Guide
• B2B Commerce and D2C Commerce Developer Guide
• Salesforce Accredited B2B Commerce Developer
• Work with External Data Sources
• Access External Data With Salesforce Connect
• Migrate data from one organization to another
• Monitor Login History
• [Big Objects]
• [Lightning Out]
• [External SOQL Queries]

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

 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?

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

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]

The event that is triggered within Salesforce B2B Commerce whenever a cart’s state changes is cartChange. This event is triggered by the updateCart method of the CCRZ.Cart class, which is responsible for updating the cart data and performing any actions that depend on the cart state, such as applying discounts, taxes, or shipping charges. The event can be used to notify all the components that are listening to it that the cart has changed and they should refresh their data accordingly. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Events, Cart Class

To override shipping charges during the checkout process, the developer needs to implement a specific interface, likelysfdc_checkout.CartShippingCharges. This interface would allow for custom logic to calculate and apply shipping charges based on the cart's contents and other criteria, ensuring flexibility and accuracy in handling shipping costs within the checkout flow.

More modules and metadata can be added to Salesforce B2B Commerce by creating custom configuration settings. Configuration settings are custom settings that store various values and parameters that affect the functionality and appearance of the storefront. They are organized into modules, which group related settings together. To create a custom configuration setting, the user needs to create a custom setting record in Salesforce and specify its module, name, value, and description. The custom setting will then appear in CCAdmin under the specified module. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Configuration Settings

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.

A customer can create its own robots.txt file for three valid reasons:

• The customer wants to reference multiple storefront sitemap indexes in a single robots.txt file. This can be useful if the customer has multiple storefronts under the same domain and wants to provide a single entry point for search engines to crawl their sitemaps.
• The customer wants to reference a custom sitemap index. This can be useful if the customer has created their own sitemap index that contains custom sitemaps or sitemaps from other sources.
• The customer’s store is not located at the root of their domain. This can be useful if the customer has their store under a subdirectory or a subdomain and wants to specify a different robots.txt file for their store than for their main domain. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Robots.txt File

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

The Global API Data-Sizing convention flag that prevents an API request from propagating to further requests when provided as a Boolean parameter with a value of true is ccrz.ccAPI.SZ_ASSC. This flag indicates that only one API request should be executed with the specified sizing block, and any subsequent requests should use their own default sizing blocks. For example, ccrz.ccServiceCart.getCart(ccrz.ccAPI.SZ_L,true) will use the SZ_L sizing block for retrieving the cart data, but any other requests that are triggered by this method will use their own default sizing blocks. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Data Sizing Conventions

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

• The correct answer is A and C. To use a sophisticated pricing engine hosted as a service outside the org, the developer must make a call to the service and implement the sfdc_checkout.PriceCalculations interface12. The sfdc_checkout.PriceCalculations interface is a standard interface that defines the methods for calculating prices for a cart or an order1. The developer can use this interface to override the default pricing logic and integrate with an external pricing service12. The developer must also make a call to the external service using Apex REST or SOAP callouts3 and handle the response data accordingly.
• Use External Objects and Implement the sfdc_checkout.CartPriceCalculations are not the correct answers. External objects are a way to access data from external data sources in real time, but they are not suitable for integrating with a pricing service that requires dynamic calculations . The sfdc_checkout.CartPriceCalculations interface is a deprecated interface that was used for calculating prices for a cart only1. It has been replaced by the sfdc_checkout.PriceCalculations interface, which supports both carts and orders1. References:
• B2B Commerce on Lightning Experience Developer Guide
• B2B Commerce and D2C Commerce Developer Guide
• Salesforce Accredited B2B Commerce Developer
• sfdc_checkout.PriceCalculations Interface
• Integrate with Lightning B2B Commerce
• Apex REST Callouts
• [Apex Web Services and Callouts]
• [Work with External Data Sources]
• [Access External Data With Salesforce Connect]

To persist payment information data in the Checkout flow for Salesforce B2B Commerce version 4.2 and beyond, the project needs to trigger the processPayment event and pass in the payment information object as an argument. This event will invoke the processPayment method of the ccServicePayment class, which will validate and process the payment information and return a payment result object. The payment result object will contain the status and details of the payment transaction.

Browser dev tools are a set of web authoring and debugging tools built into most modern browsers. They allow developers to inspect, edit, and debug the HTML, CSS, JavaScript, and network activity of a web page. They can also provide useful information about errors, warnings, performance, and accessibility issues. Browser dev tools are especially helpful for developing and testing Lightning web components, as they can display the component hierarchy, attributes, events, and slots.

The other options are not correct because:

• A. Commerce Diagnostics Event Logging is a feature that enables developers to capture and analyze events that occur during the execution of B2C Commerce code. It can help identify performance bottlenecks, memory leaks, and unexpected behavior. However, it is not a tool that can be used directly by the developer, but rather a service that requires a support request to enable and access.
• B. Checkout Flow Log is a log file that shows the details of the checkout flow execution, such as the input and output parameters, the pipeline steps, and the errors and warnings. It can help troubleshoot issues related to the checkout process, such as payment, shipping, or tax calculation. However, it is not a tool that can be used during development, but rather a log file that can be accessed after the checkout flow has run.
• C. Support cases are requests for assistance from the Salesforce support team. They can help resolve technical issues, provide guidance, or escalate bugs. However, they are not a tool that can be used to investigate errors during development, but rather a communication channel that can be used after the developer has exhausted other resources.

References:

• Browser Dev Tools
• Debug Your Lightning Web Components
• Commerce Diagnostics Event Logging
• [Checkout Flow Log]

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]

The default Global API Data-Sizing convention flag that is used by the API’s unless otherwise specified is CCRZ.ccAPI.SZ_M. This flag indicates that the medium sizing block should be used for retrieving data, which includes the most commonly used fields and related entities. For example, ccrz.ccServiceProduct.getProducts() will use the SZ_M sizing block by default, unless another sizing block is specified as a parameter. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Data Sizing Conventions

The correct syntax for looping through a series of child components which are tiles is option A. Option A uses the for:each directive to iterate over a collection of items and render a template block for each item. The for:each directive requires an expression that evaluates to an array or an iterable object and an item alias that represents the current item in the iteration. The item alias can be used to access the item’s properties or pass them to child components. In option A, the expression is appTiles, which is an array of objects that represent app tiles, and the item alias is appTile, which represents the current app tile object in the iteration. The appTile object’s properties, such as name, description, and icon, are passed to the app-tile child component using attributes. Option B is incorrect because it uses an invalid syntax for the for:each directive. The for:each directive requires a colon (:) after the for keyword, not an equal sign (=). Option C is incorrect because it uses an invalid syntax for the for:each directive. The for:each directive requires an item alias that represents the current item in the iteration, not a key alias that represents the current index in the iteration. Option D is incorrect because it uses an invalid syntax for the template tag. The template tag requires a closing tag (), not a self-closing tag (