Salesforce B2B-Commerce-Developer Salesforce Accredited B2B Commerce Developer(SP23) Exam Practice Test

The root cause of why the custom field MyCustomField__c has no values and no column header in the CSV file is that the user does not have access to the field. A user’s access to a field is determined by theirprofile 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 user needs to install a specific Zulu JDK that is recommended by Salesforce is not the root cause of why MyCustomField__c has no values and no column header in the CSV file, as it is not related to field access or Data Loader functionality. A mapping file was not used when the data was loaded in is not the root cause either, as it is not related to field access or Data Loader functionality. A mapping file is an optional file that maps fields between Salesforce objects and CSV files when using Data Loader to import or export data. The user has rights to the field but there are no values in it is not the root cause either, as it contradicts the fact that MyCustomField__c has no column header in the CSV file. If the user had rights to the field but there were no values in it, Data Loader would still include MyCustomField__c as a column header in the CSV file, but leave its values blank. Salesforce References: [Data Loader Guide: Export Data from Salesforce], [Data Loader Guide: Field Mapping], [Salesforce Help: Set Field-Level Security]

The 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

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

• Remove any namespace prefix from the field name, such as ccrz__ or cloudcraze__.
• Remove any underscores from the field name and capitalize the first letter of each word after an underscore, such as MyFieldName.
• Lowercase the first letter of the field name, such as myFieldName. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Query Transformation

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.

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.

Composition is a key pattern in building Lightning Web Components (LWCs). This approach involves creating small, reusable components that can be assembled to form more complex interfaces. This pattern promotes modularity, reusability, and maintainability in the development of web components, aligning with web standards and best practices.

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

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

Three statements that are true about Global API versioning are:

• Calling in with an API version set to lower than 1 will result in an exceptional case where the exception class ccrz.BelowMinAPIVersionException will be returned to callers. This exception indicates that the API version is not supported by the framework and the caller should use a higher API version.
• The API version is scoped at the Class API level and NOT at the method level. This means that all the methods in a class will use the same API version that is specified by the caller. For example, if the caller passes an API version of 4 to ccrz.ccServiceProduct.getProducts(), then all the other methods in ccrz.ccServiceProduct will also use API version 4.
• Calling in with an API version set to more than current maximum will result in exception case where the exception class ccrz.ExceedsMaxAPIVersionException will be returned to callers. This exception indicates that the API version is not supported by the framework and the caller should use a lower API version. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, API Versioning

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

Option B is the correct answer because it describes a way to create a scheduled job in another system to move data into the B2B Commerce org without additional third party tools. The developer can set up an SFTP server as a waystation, drop the files there using the off-platform job and schedule a job in-platform to process the file. This way, the developer can use the built-in integration capabilities of the B2B Commerce platform, such as the Windows Integration Service (WIS) or the Integration Job Definitions, to import the data from the SFTP server into the org. The other options are incorrect because they either require additional third party tools, such as WebDAV or CLI, or they do not create a scheduled job in another system, but rather in the same org. References: Creating and editing integration jobs, Create a B2B Commerce Org and Checkout Flow, B2B Commerce on Lightning Experience Developer Guide, B2B Commerce and D2C Commerce Developer Guide

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

• There is no need to use string concatenation to easily tag log statements with a subject. ccLog allows passing a subject parameter to the log method, which will prepend the subject to the log message. For example, ccLog.log('This is a message', 'Subject') will log [Subject] This is a message.
• There is no need to create a User Trace Flag. ccLog can be enabled by setting the value of CO.logToken to true in CCAdmin, which will activate logging for all users who access the storefront.
• There is no need to manually set a cookie to debug with the Site Guest User. ccLog can be enabled for the Site Guest User by appending #ccLog= to the end of the storefront URL in order to get logs in the inspector console. For example, https://my-storefront.com/#ccLog=debug will enable logging for the Site Guest User with the debug level. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Logging

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

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

To indicate that inventory is available for all items and amounts in the cart, the developer should return sfdc.checkout.InventoryStatus.Status.SUCCESS. The sfdc.checkout.InventoryStatus.Status.SUCCESS is a constant value that represents a successful inventory status. It means that the inventory class has checked the availability of all the products in the cart and confirmed that they are in stock and can be fulfilled. The developer should use this value as the return value of the checkInventory method, which is a method that implements the sfdc.checkout.InventoryCheck interface. The checkInventory method is invoked during the checkout flow to validate the inventory availability of the products in the cart. Returning TRUE is not a valid way to indicate inventory availability, as it is not a valid inventory status value. Returning sfdc_checkout.IntegrationStatus.Status.SUCCESS is not a valid way either, as it is not an inventory status value, but rather an integration status value. Returning sfdc.checkout.InventoryStatus.SUCCESS is not a valid way either, as it is not a valid syntax for accessing the inventory status value. Salesforce References: B2B Commerce Developer Guide: Inventory Integration, B2B Commerce Developer Guide: Inventory Status Enum, B2B Commerce Developer Guide: Inventory Check Interface

Custom labels are text values that can be translated into any language that Salesforce supports. They are useful for displaying language-specific text in Lightning web components. To use custom labels in a LWC, the developer needs to create them in the Setup menu and assign them to a language and a value. Then, the developer can import them in the LWC using the @salesforce/label scoped module. For example, if the developer has a custom label named welcomeHeader, they can import it as follows:

import welcomeHeader from '@salesforce/label/c.welcomeHeader';

Then, they can use it in the HTML template or the JavaScript file of the LWC. For example, in the HTML template, they can use it as follows:

HTMLAI-generated code. Review and use carefully. More info on FAQ.

The custom label will automatically display the translated value based on the user’s language preference. The developer can also use the lightning-formatted-text component to format the custom label value with HTML tags.

The other options are not correct because:

• A. Importing static resources for the text values is not a recommended way to translate text values in a LWC. Static resources are files that are stored in Salesforce and can be referenced by applications. They are not designed for storing language-specific text values and they do not support automatic translation based on the user’s language preference.
• B. Using a CustomLabel xml file in the LWC to add the text values there is not a valid option. Custom labels are not stored in xml files, but in the Setup menu. They cannot be added directly to the LWC, but they need to be imported using the @salesforce/label scoped module.
• D. Creating a custom Metadata object for the text values and querying it in the LWC is not a feasible option. Custom Metadata objects are records that store configuration data that can be deployed and packaged. They are not intended for storing language-specific text values and they do not support automatic translation based on the user’s language preference. Querying them in the LWC would also require an Apex class and a wire service, which would add unnecessary complexity to the solution.

References:

• Use Custom Labels in Lightning Web Components
• Custom Labels
• Internationalizing Your Lightning Web Component (LWC)

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

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

 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

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

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

To have a customized experience for adding items to the cart and also update the mini cart module, the requirement can be fulfilled by triggering the global “cartChange” event after the Add to Cart Action on the custom button. This event will notify all the components that are listening to it that the cart has changed and they should refresh their data accordingly. The mini cart module is one of these components, so it will update its state based on the new cart data. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Events

To override pricing during the checkout process in Salesforce B2B Commerce, a developer must implement a class specifically designed for this purpose, such assfdc_checkout.CartPriceCalculations. This class would provide the necessary framework for custom pricing logic to be applied during checkout, ensuring that any custom pricing requirements are met.

To bring picklist values into a Lightning Web Component (LWC), a developer needs to import specific modules from thelwcandlightning/uiObjectInfoApinamespaces. ThegetPicklistValuesfunction from thelightning/uiObjectInfoApimodule is used to fetch the picklist values based on record type and field metadata. Additionally, importing{ LightningElement, wire }fromlwcis essential for defining the LWC class and using the@wiredecorator to wire thegetPicklistValuesto a property orfunction. Salesforce documentation on LWC and utilizing theuiObjectInfoApiprovides clear guidelines on how to implement this functionality.

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

A cart item with a type of Charge is created with the Cart Delivery Group Method after the shipping integration. A shipping integration is an integration that calculates and applies shipping costs and options to a cart or an order based on various factors, such as product weight, dimensions, quantity, location, and carrier service level. A shipping integration can use either an external shipping service provider or custom Apex code to perform the shipping calculation. The Cart Delivery Group Method is a method that determines how products are grouped into delivery groups based on their shipping methods and addresses. A delivery group is a logical grouping of products that are shipped together using the same shipping method and address. After performing the shipping calculation for each delivery group, the shipping integration creates a cart item with a type of Charge and a charge type of Shipping for each delivery group. These cart items represent the shipping costs and options that are applied to each delivery group. A cart item with a type of Surcharge, Shipping, or Delivery does not exist or is not related to the shipping integration. Salesforce References: [B2B Commerce Developer Guide: Shipping Integration], [B2B Commerce Developer Guide: Cart Delivery Group Method]

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

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

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]

To implement a custom Terms and Conditions checkbox at checkout in the Aura Commerce template, a developer should add a Desired Delivery Date input field during the checkout flow. The Desired Delivery Date input field allows the customer to enter a date when they want their order to be delivered. The developer can use the @api decorator to expose this field as a public property of the Lightning web component and bind it to the ccCheckoutOrder object. The developer can also use the @wire decorator to get the current cart object and use its properties, such as shipping address and shipping method, to calculate and display an estimated delivery date based on the desired delivery date. The developer can also add validation logic to ensure that the desired delivery date is valid and acceptable. Adding the Expected Delivery Date field to the order confirmation email is not a good solution, as it does not allow the customer to choose or see their delivery date before placing their order. Displaying the Expected Delivery Date on the order page with a Lightning web component is not a good solution either, as it does not allow the customer to enter or change their delivery date after placing their order. Configuring an email alert to the customer when the Expected Delivery Date changes is not a good solution either, as it does not provide a consistent or reliable way of informing the customer about their delivery date. Salesforce References: B2B CommerceDeveloper Guide: Checkout Flow, B2B Commerce Developer Guide: Checkout Order Object, Lightning Web Components Developer Guide: Communicate with Properties

 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.

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

• Refetch data (used on some Logic classes): This operation indicates that the data should be refetched from the database instead of using the cached data. For example, ccrz.ccServiceCart.getCart(ccrz.ccAPI.SZ_REFETCH) will refetch the cart data and refresh the cache.
• Related Query to call (sub queries or direct queries): This operation indicates that the related entities should be retrieved by using sub queries or direct queries. For example, ccrz.ccServiceProduct.getProducts(ccrz.ccAPI.SZ_SUBQUERY) will use sub queries to fetch the related entities for each product, while ccrz.ccServiceProduct.getProducts(ccrz.ccAPI.SZ_DIRECTQUERY) will use direct queries to fetch the related entities separately.
• Object type casting: This operation indicates that the data should be cast to a specific object type. For example, ccrz.ccServiceProduct.getProducts(ccrz.ccAPI.SZ_SOBJECT) will cast the data to sObjects instead of transformed objects. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Data Sizing Conventions

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

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

The 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 check user permissions in Lightning web components, a developer should import two scoped modules: @salesforce/permission and @salesforce/customPermission. The @salesforce/permission module allows the developer to check if the user has access to a standard permission, such as View Setup or Modify All Data. The @salesforce/customPermission module allows the developer to check if the user has access to a custom permission, such as Enable Debug Mode or Manage Orders. The other modules do not exist or are not related to user permissions. Salesforce References: Lightning Web Components Developer Guide: Check User Permissions, Lightning Web Components Developer Guide: Import Salesforce Modules

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

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

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

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

You should avoid using ccLog in two scenarios. First, you should avoid using ccLog with System.LoggingLevel.ERROR when passing in a method invocation as the third parameter, such as ccrz.ccLog.log(System.LoggingLevel.ERROR, ‘D:something’, myCallToGetMessage(pl) ). This is because if an exception occurs within the method invocation, it will not be caught by ccLog and will cause an unhandled exception on the page. Instead, you should use a try-catch block around the method invocation and log the exception separately. Second, you should avoid using ccLog with System.LoggingLevel.DEBUG when passing in a large collection or object as the third parameter, such as ccrz.ccLog.log(System.LoggingLevel.DEBUG, ‘D:myOrderList’, myOrderList), where myOrderList is a list of orders. This is because logging large objects can cause performance issues and consume a lot of heap space. Instead, you should use a loop to log only the relevant fields or properties of the object or collection. You can use ccLog with System.LoggingLevel.WARN when passing in a string as the third parameter, such as ccrz.ccLog.log(System.LoggingLevel.WARN, ‘D:something’, ‘Something unexpected occurred: The data we were expecting for pl was not there,’). This is a valid use case for logging a warning message. You can also use ccLog with System.LoggingLevel.DEBUG when passing in a small object as the third parameter, such as ccrz.ccLog.log(System.LoggingLevel.DEBUG, ‘D:myOrder’, myOrder), where myOrder is an order object. This is acceptable as long as the object is not too large or complex. Salesforce References: [B2B Commerce Developer Guide: Logging]

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

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

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

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

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.

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.

To introduce new screen behavior in a checkout flow step, a developer should clone the appropriate subflow and replace the Lightning web components in it. A subflow is a reusable flow that can be invoked from another flow as an element. A checkout flow is a flow that defines the steps and components for the checkout process in the storefront. A checkout flow consists of several subflows, each of which corresponds to a checkout step, such as Cart, Shipping Address, Payment, or Order Summary. To introduce new screen behavior in a checkout flow step, a developer should clone the subflow that matches the checkout step they want to modify and replace the Lightning web components in the cloned subflow with their custom components. The developer can then update the checkoutSteps.xml file to point to the cloned subflow instead of the original subflow. Modifying the property mappings in checkoutSteps.xml is not a valid way to introduce new screen behavior in a checkout flow step, as it only affects how data is passed between subflows, not how screens are displayed or rendered. Editing the default subflow directly is not a valid way either, as it can cause conflicts or errors with other stores or environments that use the same default subflow. Adjusting next-state in previous subflow configuration is not a valid way either, as it only affects how subflows are transitioned or navigated, not how screens are displayed or rendered. Salesforce References: B2B Commerce Developer Guide: Checkout Flow, B2B Commerce Developer Guide: Checkout Subflows, B2B Commerce Developer Guide: Customize Checkout Steps

The fastest route to setting up a B2B Commerce store as a developer is to use sfdx setup scripts. Sfdx setup scripts are scripts that use Salesforce CLI commands to automate the creation and configuration of a B2B Commerce store. The scripts can perform tasks such as creating scratch orgs, installing packages, importing data, assigning permissions, and deploying code. The scripts can save time and effort for developers who need to set up a B2B Commerce store quickly and easily. Setting up B2B Commerce on Lightning Experience manually is not the fastest route to setting up a B2B Commerce store, as it involvesmany steps and actions that can be tedious and error-prone. Creating a new store in the Commerce app is not the fastest route either, as it also requires manual configuration and customization of various settings and features. Importing a previously exported store archive is not the fastest route either, as it depends on the availability and quality of the store archive and may not reflect the latest changes or updates. Salesforce References: [B2B Commerce Developer Guide: Set Up Your Development Environment], [B2B Commerce Developer Guide: Create Your Store]

The conversion flag that allows for sObjects to be returned from the Global API’s when provided as a Boolean parameter with a value of true is ccrz.ccAPI.SZ_SOBJECT. This flag indicates that the API should return the raw sObjects instead of the transformed objects that are usually returned by the API. For example, ccrz.ccServiceProduct.getProducts(ccrz.ccAPI.SZ_SOBJECT,true) will return the Product2 sObjects instead of the ccrz__E_Product__c objects. Salesforce References: B2B Commerce and D2C Commerce Developer Guide, Data Sizing Conventions

In a Lightning Web Component folder, the allowed file extensions include.js-meta.xmlfor the component's metadata,.htmlfor the component's markup, and.jsfor the component's JavaScript class. These files are essential for defining the structure, behavior, and metadata of a LWC. Salesforce LWC documentation provides detailed information on the structure of a LWC bundle and the purpose of each file type within it.

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

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

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

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

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.

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

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

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.

To bulk create product data translations via Data Loader, permissions beyond View Setup and Configuration are necessary. "Import Custom Objects" permission is required to import bulk data into Salesforce, including translations for custom objects. "Manage Translations" permission is essential for managing translation workbench settings and importing/exporting translation files, which is crucial for handling product data translations.

A Lightning Web Component (LWC) consists of a minimum of three core files: the template file (.html), the JavaScript file (.js), and the metadata configuration file (.js-meta.xml). These files are essential for defining the structure, functionality, and configuration of the component. For more information, review the Salesforce LWC documentation:Salesforce LWC Documentation.

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.

 Option B is the correct answer because it describes the fastest route to establishing the data needed for checkout development when setting up a new store. The developer can use sfdx setup scripts to deploy a Lightning B2B testing environment that includes checkout flows, sample products, and a buyer. This way, the developer can quickly and easily test and customize the checkout flow using Experience Builder or Flow Builder. The other options are incorrect because they either require more time, manual steps, or additional tools to set up the data for checkout development. For example, importing a previously exported store archive or using data loader would require the developer to have access to the source data and the target org, and to map the fields and objects correctly. Selecting Add Sample Data when setting up the store would only provide a limited amount of data that may not be sufficient for checkout development. References: Create a B2B Commerce Org and Checkout Flow, B2B Commerce on Lightning Experience Developer Guide, B2B Commerce and D2C Commerce Developer Guide