Explanation:

Promotions and Child Product Discounts in Salesforce CPQ/Vlocity:
Promotions can include time-bound discounts on child products (e.g., "20% off for the first 3 months of a 12-month promotion").
The parent promotion’s end date and child product discount’s end date are independent.

Why "True"?

Example:
Promotion runs for 12 months (Jan–Dec).
Child product discount expires after 3 months (Jan–Mar).

Reference: Salesforce CPQ Promotions

Explanation:

In Salesforce Industries CPQ, the Qualification context rule type is used to determine whether a customer is eligible for a promotion before it’s added to the cart. These rules evaluate conditions such as:

Account type (e.g., B2B vs. B2C)
Customer location
Subscription status
Any custom field or context dimension

By applying Qualification rules, you ensure that promotions are only offered to customers who meet specific criteria—helping maintain pricing integrity and targeting accuracy.

❌ Why not Penalty?
Penalty rules are used to apply consequences (like fees or restrictions) when a customer cancels a promotion or contract early.
They do not determine initial eligibility.

Explanation:

In Salesforce Industries CPQ (formerly Vlocity), Guided Selling uses remote methods (also called remote actions) to:

Create and manage the Cart
Add products
Retrieve cart items
Update configurations
Submit orders

These remote methods live in an Apex class called CpqAppHandler.

CpqAppHandler is the server-side Apex controller that exposes various remote methods used by:

OmniScripts
Lightning components
Guided Selling UI

Examples of remote methods in CpqAppHandler

createCart
getCartsItems
postCartsItems
putCartsItems
checkout
submit

So while names like createCart, getCartsItems, etc. are the individual methods, the class in which they exist is CpqAppHandler.

Hence, the correct answer to:
In Guided Selling, which of these is the class for the remote methods?
is clearly CpqAppHandler.

Why not the other options?
A. done
Not a valid class.

B. vlcCart
Refers to a front-end JavaScript object used in Vlocity UI—not an Apex class.

D. createCart, E. getCartsItems, F. getCartsProducts, etc.
These are method names, not class names.

I. checkout, J. submit
Methods, not classes.

Explanation:

In Salesforce Industries CPQ (Digital Commerce), the dcOffersList component is responsible for using a child catalog code to call the APIs and retrieve the appropriate products. This component is typically used in Guided Selling flows where product offers are dynamically filtered and displayed based on catalog hierarchy and context.

It interacts with the Digital Commerce APIs, passing the child catalog code as part of the request to:

Fetch relevant product offers
Apply context filters (e.g., account type, location)
Display results in a user-friendly format

This makes dcOffersList ideal for scenarios where product selection is driven by nested catalogs or customer-specific eligibility.

❌ Why the other options are incorrect:
A. dcCatalog: This component displays the top-level catalog, not child catalogs or filtered offers.

B. dcChildCatalog: While it may reference child catalogs, it doesn’t directly handle API calls to retrieve filtered product offers like dcOffersList does.

Explanation:

Context Mapping in Vlocity Context Rules
A context mapping connects context dimensions to data sources. It can pull values from:
- sObjects (e.g., Account.Industry)
- Functions (e.g., Apex methods)
- Static values entered during setup

Key Characteristics
- Links dimensions like CustomerTier to real data
- Supports dynamic calculations through functions
- Enables rule flexibility across different contexts

Why This Matters
Context mappings power dynamic pricing and promotions by connecting business rules to actual customer/product data.
Example: Mapping "CustomerTier" to Account.Tier__c field automatically applies tier-specific pricing.

Technical Note
Mappings are configured in OmniScripts or through Vlocity's admin UI, not in code.

Explanation:

In Salesforce Industries CPQ, a pricing element represents a component of the pricing logic used to calculate the final price of a product or service. Each pricing element includes:

C. Pricing Calculation This defines how the price is derived—whether it's a flat rate, percentage, tiered, or based on usage. It’s the logic behind the pricing element.
D. Charge (Amount) This is the actual monetary value applied to the product or service. It’s the result of the pricing calculation and is what appears on the quote or invoice.

These two components are essential to every pricing element: one defines the logic, the other delivers the result.

❌Why the other options are incorrect:
A. Currency Code While important for pricing display and conversion, it’s a metadata attribute, not a core part of the pricing element itself.
B. Price Category This is used to group or classify pricing elements (e.g., recurring vs. one-time), but it’s not a functional part of the pricing calculation or charge.

Explanation:

The createCart method in Salesforce Industries CPQ:

Initializes a new CPQ cart session.
Creates the core sales transaction object (either Quote or Order) depending on the cart’s configuration.
Optionally associates the cart with an Opportunity.

Here’s how each option fits:

✅ A. Order
Can be created by createCart.
If the transaction type is set to Order, the CPQ engine creates an Order record during the cart session.

✅ B. Quote
Can be created by createCart.
If the transaction type is set to Quote, the CPQ engine creates a Quote record to store product selections, prices, etc.

✅ D. Opportunity
Can be created or linked by createCart.
The cart often references an Opportunity record, and some flows allow the creation of a new Opportunity if one does not already exist.

❌ C. Contract
NOT created by createCart.

Contracts result from downstream processes like:

Order activation and fulfillment
Subscription or billing processes
Contracts are not part of the cart creation process. They’re a post-order entity, typically generated after the order is completed and activated.

Hence, the answer to:

Which of the following is NOT created using the createCart method?

is clearly Contract.

Explanation:

Vlocity Object Type Inheritance
Vlocity uses HAS-A (composition) architecture for object relationships.

Key Characteristics
- Objects reference other objects instead of inheriting properties directly
- Example: Product Bundle contains child products without inheriting their attributes
- Enables flexible, modular data structures

Why HAS-A Architecture?
- Avoids rigid class hierarchies of IS-A inheritance
- Better suited for complex product/service configurations
- Matches real-world business relationships

Technical Implementation
Implemented through lookup relationships and reference fields in the Vlocity data model

Comparison
HAS-A (Vlocity) = Composition/Containment
IS-A = Traditional class inheritance (not used)
Hybrid/Private = Not applicable to Vlocity's model

Explanation:

In Salesforce Industries CPQ, the Any context scope is a wildcard scope that supports evaluation across multiple root objects—including Opportunity, Quote, Order, and Asset. This makes it ideal for use cases like Felix’s, where the product spans the entire sales cycle.

By using the Any scope, Felix can:

Avoid creating separate rules for each object type
Ensure consistent rule evaluation across all stages of the sales process
Simplify maintenance and improve scalability

This scope is especially powerful when combined with context mappings that traverse relationships like Any.Account or Any.Opportunity.Account.

❌ Why the other options fall short:
B. Order, Quote, Opportunity and Asset: This isn’t a valid single scope—it’s a list of scopes. You’d need to define separate rules for each.
C. Order and Quote: Too narrow for a full sales cycle that includes Opportunity and Asset.
D. Opportunity: Only covers the early stage of the cycle, missing Quote, Order, and Asset.

Explanation:

In Salesforce Industries CPQ (formerly Vlocity):
Context Rules define conditions such as:

“Country equals France”
“Segment equals Enterprise”

However, you do not assign individual context rules directly to products, prices, or promotions.

Instead, you:

✅ Group one or more context rules into a Context Rule Set.
Then:

You assign the Context Rule Set to:

Products
Promotions
Price Lists
Attributes

This architecture ensures:

Reusability → The same rule set can apply to multiple entities.
Manageability → You don’t have to assign dozens of individual rules separately.
Logical grouping → Complex eligibility can be defined via multiple rules in a set.

Hence, the statement:
“You apply rule sets rather than individual context rules to products or promotions.”

is True.

Example:

Context Rules:
Rule 1 → Country = France
Rule 2 → Segment = Enterprise

Context Rule Set:
Includes both Rule 1 and Rule 2

You assign the Rule Set to:
A Promotion → ensures it only shows for French enterprise customers

Explanation:

In this API call:
vlocity_cmt/v3/catalogs/Phonesyoffers?context={"Status":"Active"}

The parameter being used is context, which passes contextual data to the API. This allows the system to filter offers based on specific conditions—like showing only products or promotions with a status of "Active".

Context parameters are commonly used in Digital Commerce APIs to:

Apply context rules for product eligibility
Filter offers based on user, account, or catalog metadata
Return qualified offers for anonymous or logged-in users

Explanation:

In Salesforce Industries CPQ (Vlocity), the initialization policy is specified within the context mapping. This setting controls how and when the context dimension retrieves data from the associated Salesforce object during rule evaluation.

When configuring a context mapping, you define:

Initialization Policy: e.g., Always Reinitialize, Initialize Once, etc.
Initialization Type: e.g., Source Expression, Function, or Design-Time Value
Source Expression: the field or formula used to pull data from the sObject

This setup ensures that the context dimension is properly populated with real-time or static data, enabling accurate rule evaluation.

❌ Why the other options are incorrect:
A. Context scope: Defines the object path (e.g., Any.Account) but doesn’t control data initialization.
B. Context dimension: Stores the variable or picklist values but doesn’t manage how they’re populated.
D. Rule condition: Uses the context dimension and mapping but doesn’t define how data is initialized.