#Salesforce CPQ & Billing30 personnes en discutent

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

Hi Rachel - yes, this is very doable with the QCP, and since Year 1 comes in at list you actually have a clean shortcut. Two approaches, depending on exactly what you're upflifting from: 

Common setup for both: order your Quote Line Groups by the group's Start Date so you always know which is Year 1, 2, 3, and match lines across groups by Product (add any configuration attributes to the match key if the same product is configured differently across years). 

Option A - uplift off list (simplest, and it fits your description): because every year holds the same product at the same list price, a compounding 5% is just a per-group markup. The simplest lever is a negative Additional Discount (%), which acts as a markup in CPQ - set it by group in onBeforeCalculate: Year 2 = -5, Year 3 = -10.25. The formula per group is -(1.05^(year-1) - 1) x 100. That lands Year 2 at list x 1.05 and Year 3 at list x 1.1025 - true compounding - and you never have to read another line's calculated price. (Just confirm negative discounts are allowed in your CPQ package settings; if they aren't, set the target Unit Price directly instead.) 

Option B - compound off the prior year's actual (discounted) price: if Year 1 might carry negotiated discounts and you want 5% on the real Year 1 price, do it in onAfterCalculate instead. Build a map of each product's Customer Price (or Net Price) from the prior group, then set this line's price to priorPrice x 1.05. One gotcha worth knowing: CPQ re-derives List Price from the price book during calculation, so don't try to override List - apply your value at the Customer/Net price stage, which is exactly why onAfterCalculate is the right hook here. 

For a straight 'Year 1 at list, +5% each year' setup, Option A is far less code and less fragile, so I'd start there and only move to B if you need to compound off discounted prices. 

(A CPQ Price Rule can handle a flat per-group uplift too, but the compounding across three groups is cleaner to express in the QCP - so your instinct is right.) 

Happy to sketch the grouping/ordering loop if you go with Option A!