Frequently Asked Questions (FAQ)

Get answers to these common questions about the Standard Cart APIs.

  • What are the steps for migrating to Standard Cart APIs?

    Customers must follow the required migration steps to enable Standard Cart APIs. See Migrate to Standard Cart APIs.

  • Are Standard Cart APIs backward compatible with Classic Cart APIs?

    Yes, they are backward compatible. The API name, input, and response format remain the same unless specified under Changes to Response. However, enabling JSON V2 Attribute Schema may introduce some changes. Also, any customizations or hooks on interfaces and implementations must be ported to the Cart Document.

  • Is there feature parity between original and Standard Cart APIs on Core?

    Refer to the Check Feature Compatibility list to check which features are supported in Standard Cart APIs.

  • Can Standard DC APIs be used with non-standard DC APIs?

    No, this is not possible, as enabling Standard DC APIs is an organization-wide setting.

  • Can Standard DC APIs be used with Classic Cart APIs and vice versa?

    Yes, this is possible. Standard DC APIs and Standard Cart APIs have separate enablement settings.

  • Which interfaces, besides vlocity_cmt.PricingPlanService, need to be replaced during the refactor?

    Implementations must use CpqCartDocument. The PricingPlanService does not need to be replaced. When Standard Cart APIs are enabled, the pricing interface used for non-Standard APIs will no longer be invoked, so no replacement is required.

  • What new interfaces are introduced with Standard APIs, and how should they be set up?

    To configure the new interfaces introduced with Standard APIs

    • Yes, you need to add new records to the Interface Implementations list.

    • Each interface requires a corresponding Active Implementation Class.For details on specific interfaces and their associated Active Implementation Classes.

    These are the new interfaces:

    • CpqPricing
    • CpqValidation
    • CpqPricingHook
    • CpqContextRule
    • CpqPricingEligibility
    • CartResponse
    • CpqTightestMatch
    • CpqTimePolicy
    • CpqPricingVariableCalc

For more information, see Interfaces and Implementations.

  • How do the new interfaces introduced with Standard APIs map to non-standard API interfaces?

    The new interfaces serve as a mapping reference for non-standard API interfaces. The list helps customers identify where to add pre/post-hooks to customize input/output for the corresponding implementation. The active default implementation classes for each interface are provided in the table mentioned above for reference.

  • Can customers replace the default implementation of the new interfaces?

    • Yes, customers can replace the entire default implementation with a custom one to implement their logic.
    • However, it is recommended to use pre/post-hooks on these interfaces instead of replacing the full implementation.
    • These interfaces will not be available in the Interface Implementation tab.
    • To modify them, go to Setup > Custom Settings > Custom Class Implementation.

  • Will the OOTB Attribute Propagation for Relies On related offers work with Standard APIs?

    Yes, OOTB Attribute Propagation works only with Standard Cart APIs. It will not function if Standard Cart APIs are disabled.

  • Is caching calculation matrices still required when moving to Business Rules Engine for pricing calculations?

    Yes, caching calculation matrices is still required to improve performance for pricing calculations, even when using Business Rules Engine.

  • Do we need to increase the size of the CPQPartition platform cache for Standard APIs, or define a new cache partition?

    No, Standard cart APIs rarely depend on the platform cache partition. Instead, compiled data entries for Standard Cart APIs are stored in the CachedAPIResponse__c object table and Scale Cache. No need to increase CPQPartition size or create a new cache partition.

  • How do we replace vlocity_cmt.PricingPlanService.putInPricingContext calls with Standard Cart APIs?

    • Replacing getFromPricingContext: Use cartDocument.getCartFields() and getItemFields() instead, as described in the documentation.
    • Replacing putInPricingContext: Previously, putInPricingContext stored key-value pairs in a static map for retrieval through getFromPricingContext.
    • With Standard Cart APIs enabled, customers can now access the Cart Document object directly from the input map.
    • For retrieving header (order/quote/opp) & line item objects, refer to the Cart Document documentation. Additional pricing-related information is available in the input map.

    Handling Custom Entries: If customers are manually adding and fetching data through putInPricingContext, they can implement the same functionality by creating a custom static map and handling read/write operations independently.