#Salesforce CPQ & Billing28 discussing

Hi Rachel,

For the first bundle, I’d be cautious about manually changing the existing Subscription/Asset hierarchy (Root ID, Required By ID, Product Option, etc.). Those relationships are used by CPQ/Billing during amendments, renewals, and asset/subscription management, so manually realigning historical records could introduce issues later. 

A safer approach is generally to keep the existing sold structure intact for historical subscriptions/assets and use the new bundle configuration for future sales. Since you need to retain the existing product codes, I’d validate the impact on amendments and renewals in a full sandbox before changing any existing subscription hierarchy. 

For the second bundle, your approach of using Product Selection Rules for new sales makes sense. For amendments, I’d make the rule criteria aware of whether the quote is an amendment versus a new sale, and whether the bundle already exists on the customer's subscription/assets. That way, the Service product can remain available when amending an existing bundle while being excluded when the bundle is being added for the first time. 

Because this involves existing subscription/asset relationships, I’d test several scenarios—new sale, renewal, amendment of the existing bundle, and adding the bundle for the first time—before deploying the configuration. If you can share the CPQ package version and how your amendment quotes are currently configured, it would help determine the exact rule conditions. 

@Sai T

Thank you for your response. This is the recommendation I gave as how to move forward with this change. 

If you had to have some mechanism to determine the existing current structure versus the new what would you use? For example we have a Year in Contract field for the current structure which is a formula field but that doesn't say whether a contract is new or existing. I wonder if we should create a field on the backend that we update via an upload that flags a contract as "Legacy"/"Existing" new. Just trying to think of the best approach so that the automation will know that a contract is existing or new so we don't accidentally take the interim renewal and try to convert it to the new structure. We do have a field called Upcoming renewal type that says Subscription Renewal or Contract Renewal. I think we can use that to say basically exclude subscription renewal and look at the ones that are contract renewal.

@Rohit paruchuri

- 

I'm open to meet with you if it helps to understand your use case.  

You'll need to add a Screen before the action to warn the rep to save their quote before clicking the button, OR you can add an apex action to save the Quote.  

To refresh the Quote after the action, use this invocable CalculateQuote action I built: 

public with sharing class CPQCalculateQuoteAction {
  public class Input {
    @InvocableVariable(required=true label='CPQ Quote ID')
    public Id quoteId;
  }
  public class Result {
    @InvocableVariable(label='Calculation Request ID')
    public Id requestId;
    @InvocableVariable(label='CPQ Quote ID')
    public Id quoteId;
  }
  public class Status {
    @AuraEnabled
    public String state;
    @AuraEnabled
    public String message;
    @AuraEnabled
    public Id quoteId;
  }
  public class CalculationException extends Exception {
  }
  // Injectable boundary: unit tests never run the managed calculator or create quotes.
  public virtual class Gateway {
    public virtual void checkAccess(Set<Id> quoteIds) {
      if (
        !SBQQ__Quote__c.SObjectType.getDescribe().isAccessible() ||
        !SBQQ__Quote__c.SObjectType.getDescribe().isUpdateable()
      ) {
        throw new CalculationException(
          'Read and edit access to CPQ Quotes is required.'
        );
      }
      Set<Id> editable = new Set<Id>();
      for (UserRecordAccess access : [
        SELECT RecordId, HasEditAccess
        FROM UserRecordAccess
        WHERE UserId = :UserInfo.getUserId() AND RecordId IN :quoteIds
      ]) {
        if (access.HasEditAccess)
          editable.add(access.RecordId);
      }
      if (!editable.containsAll(quoteIds)) {
        throw new CalculationException(
          'A quote does not exist or you cannot edit it.'
        );
      }
    }
    public virtual String readQuote(Id quoteId) {
      return SBQQ.ServiceRouter.read(
        'SBQQ.QuoteAPI.QuoteReader',
        String.valueOf(quoteId)
      );
    }
    public virtual void calculate(String quoteJSON) {
      Map<String, Object> context = new Map<String, Object>{
        'quote' => JSON.deserializeUntyped(quoteJSON),
        'callbackClass' => 'CPQCalculateQuoteCallback'
      };
      SBQQ.ServiceRouter.load(
        'SBQQ.QuoteAPI.QuoteCalculator',
        null,
        JSON.serialize(context)
      );
    }
    public virtual void saveQuote(String quoteJSON) {
      SBQQ.ServiceRouter.save('SBQQ.QuoteAPI.QuoteSaver', quoteJSON);
    }
    public virtual Id launch(Set<Id> requestIds) {
      return Database.executeBatch(new CPQCalculateQuoteBatch(requestIds), 1);
    }
  }
  @TestVisible
  private static Gateway gateway = new Gateway();
  @InvocableMethod(
    label='Calculate CPQ Quote'
    description='Queues CPQ calculation and save. Pass the request ID to the Wait for CPQ Calculation Flow screen component. Completion is asynchronous.'
  )
  public static List<Result> calculateQuotes(List<Input> inputs) {
    if (inputs == null || inputs.isEmpty() || inputs.size() > 200) {
      throw new CalculationException('Supply between 1 and 200 CPQ Quote IDs.');
    }
    Set<Id> quoteIds = new Set<Id>();
    for (Input input : inputs) {
      if (
        input == null ||
        input.quoteId == null ||
        input.quoteId.getSObjectType() != SBQQ__Quote__c.SObjectType
      ) {
        throw new CalculationException(
          'Each input must be an SBQQ__Quote__c record ID.'
        );
      }
      quoteIds.add(input.quoteId);
    }
    gateway.checkAccess(quoteIds);
    List<CPQ_Calculation_Request__c> requests = new List<CPQ_Calculation_Request__c>();
    for (Id quoteId : quoteIds) {
      requests.add(
        new CPQ_Calculation_Request__c(
          Quote_Id__c = String.valueOf(quoteId),
          Active_Quote_Key__c = String.valueOf(quoteId),
          Status__c = 'Queued'
        )
      );
    }
    // The unique active key prevents races across users, not just duplicates in this list.
    Savepoint sp = Database.setSavepoint();
    try {
      insert requests;
      Set<Id> requestIds = new Map<Id, CPQ_Calculation_Request__c>(requests)
        .keySet();
      Id batchId = gateway.launch(requestIds);
      Map<Id, Id> requestByQuote = new Map<Id, Id>();
      for (CPQ_Calculation_Request__c request : requests) {
        request.Batch_Job_Id__c = String.valueOf(batchId);
        requestByQuote.put(Id.valueOf(request.Quote_Id__c), request.Id);
      }
      update requests;
      List<Result> results = new List<Result>();
      for (Input input : inputs) {
        Result result = new Result();
        result.quoteId = input.quoteId;
        result.requestId = requestByQuote.get(input.quoteId);
        results.add(result);
      }
      return results;
    } catch (Exception ex) {
      Database.rollback(sp);
      throw new CalculationException(
        'Could not queue calculation. A quote may already have an active or unresolved request. ' +
        ex.getMessage()
      );
    }
  }
  @AuraEnabled
  public static Status getStatus(Id requestId) {
    if (requestId == null)
      throw new AuraHandledException('Calculation request ID is required.');
    List<CPQ_Calculation_Request__c> requests = [
      SELECT Quote_Id__c, Status__c, Error__c, Batch_Job_Id__c
      FROM CPQ_Calculation_Request__c
      WHERE Id = :requestId
      LIMIT 1
    ];
    if (requests.isEmpty())
      throw new AuraHandledException(
        'Calculation request not found or not accessible.'
      );
    CPQ_Calculation_Request__c request = requests[0];
    Id quoteId = Id.valueOf(request.Quote_Id__c);
    gateway.checkAccess(new Set<Id>{ quoteId });
    Status result = new Status();
    result.quoteId = quoteId;
    result.state = request.Status__c;
    result.message = request.Error__c;
    if (
      result.state != 'Completed' &&
      result.state != 'Failed' &&
      String.isNotBlank(request.Batch_Job_Id__c)
    ) {
      Id batchId = Id.valueOf(request.Batch_Job_Id__c);
      for (AsyncApexJob job : [
        SELECT Status, NumberOfErrors
        FROM AsyncApexJob
        WHERE Id = :batchId
      ]) {
        if (
          job.Status == 'Failed' ||
          job.Status == 'Aborted' ||
          (job.Status == 'Completed' &&
          job.NumberOfErrors > 0)
        ) {
          result.state = 'Failed';
          result.message = 'The calculation batch stopped or reported an unhandled error. An administrator must inspect Apex Jobs before retrying.';
        }
      }
    }
    return result;
  }
  public static void processRequest(Id requestId) {
    CPQ_Calculation_Request__c request = [
      SELECT Quote_Id__c, Status__c
      FROM CPQ_Calculation_Request__c
      WHERE Id = :requestId
    ];
    if (request.Status__c != 'Queued')
      return;
    try {
      Id quoteId = Id.valueOf(request.Quote_Id__c);
      gateway.checkAccess(new Set<Id>{ quoteId });
      String quoteJSON = gateway.readQuote(quoteId);
      // No DML before CPQ: calculation can make callouts or schedule a callback.
      gateway.calculate(quoteJSON);
      request = [
        SELECT Status__c
        FROM CPQ_Calculation_Request__c
        WHERE Id = :requestId
        FOR UPDATE
      ];
      // A synchronous callback may already have saved the quote and completed the request.
      if (request.Status__c == 'Queued') {
        request.Status__c = 'Calculating';
        update request;
      }
    } catch (Exception ex) {
      failRequest(requestId, ex.getMessage());
    }
  }
  public static void saveCalculatedQuote(String quoteJSON) {
    Map<String, Object> model = (Map<String, Object>) JSON.deserializeUntyped(
      quoteJSON
    );
    Map<String, Object> record = (Map<String, Object>) model.get('record');
    Id quoteId = Id.valueOf((String) record.get('Id'));
    String activeKey = String.valueOf(quoteId);
    List<CPQ_Calculation_Request__c> requests = [
      SELECT Status__c
      FROM CPQ_Calculation_Request__c
      WHERE Active_Quote_Key__c = :activeKey
      FOR UPDATE
    ];
    if (requests.isEmpty() || requests[0].Status__c == 'Failed') {
      throw new CalculationException(
        'No active calculation request; the callback was not saved.'
      );
    }
    CPQ_Calculation_Request__c request = requests[0];
    Savepoint sp = Database.setSavepoint();
    try {
      gateway.checkAccess(new Set<Id>{ quoteId });
      gateway.saveQuote(quoteJSON);
      request.Status__c = 'Completed';
      request.Active_Quote_Key__c = null;
      request.Error__c = null;
      update request;
    } catch (Exception ex) {
      Database.rollback(sp);
      failRequest(request.Id, ex.getMessage());
    }
  }
  private static void failRequest(Id requestId, String message) {
    // Keep the active key on errors: an unobserved CPQ callback may still be in flight.
    update new CPQ_Calculation_Request__c(
      Id = requestId,
      Status__c = 'Failed',
      Error__c = message.left(32000)
    );
  }
}
```

Your instinct to delete Price Action 4 is right, and here's why it's likely the actual root cause of the environment difference, not just a cleanup step. 

You have two Product Actions targeting the same product (Product C) within one rule, with directly contradictory outcomes: Action 3 says Enable & Add + Required, Action 4 says Hide. Unlike Product Rules themselves (which have an explicit Evaluation Order field to control which rule "wins" when multiple rules affect the same product), individual Product Actions within a single rule don't have a documented, configurable sequence field in the UI. When two actions in the same rule conflict like this, which one is applied can come down to internal record creation order - and if this rule was built independently in Sandbox and in Production (rather than deployed as a single unit via change set/package that preserves record order), it's entirely plausible the two environments evaluate Action 3 vs. Action 4 in a different order, which would produce exactly the opposite behavior you're seeing on Product C between the two orgs. 

Given the outcome the Sales team actually wants — Product C appearing and checked — the fix is straightforward: delete Price Action 4 (Hide on Product C) entirely, and keep only Price Action 3 (Enable & Add, Required) for Product C. That removes the ambiguity rather than relying on action-order behavior that isn't guaranteed to be consistent across orgs. 

One more thing worth confirming before you conclude it's purely a config issue: since Product A and B's behavior also flipped between environments (not just C), double-check that the Quote.Boost__c field is actually set to TRUE in both orgs during your test — if the condition itself isn't evaluating the same way in both places (e.g., a default value difference on that field between Sandbox and Production data), that alone could explain the whole rule appearing to "not fire" in one environment before you even get to the Product C ordering issue.

@Pawel Wiktorek Please check-

1. If User has access to Search Filter records.

2. If there are multiple "Add Products" custom actions and the other user is looking at a different Add Products custom action.

3. Try executing scripts under CPQ Package Setting -> Additional Settings

4. Try creating another Search Filter with Product Code-contains-blank. If it works, change the Field to HierarchyLocation__c

5. If nothing helps, please create a case with SF CPQ Support.