Usted está aquí:
Prácticas recomendadas para ganchos de precios Apex
Siga estas prácticas recomendadas al implementar ganchos Apex en sus planes de procedimientos de precios para optimizar el rendimiento y evitar resultados inesperados.
Límites reguladores Apex
Apex hooks en planes de procedimiento se ejecutan dentro de la misma transacción Apex, de modo que el temporizador de la unidad de procesamiento central es acumulativo entre todas las operaciones. Tenga en cuenta los límites reguladores cuando escriba lógica de gancho, especialmente para transacciones con muchas partidas.
Para los valores límite actuales, consulte Límites y reguladores de ejecución en la Guía del desarrollador Apex.
Consultar solo las etiquetas que necesita
Evite consultar etiquetas de nivel de entidad amplias como SalesTransactionItem, que devuelven cada atributo para cada elemento. En su lugar, solicite solo las etiquetas específicas que requiere su lógica de gancho.
No se recomienda: Consulta de etiquetas anchas
// BAD: Returns ALL attributes for every SalesTransactionItem
Map<String, Object> input = new Map<String, Object>{
'contextId' => contextId,
'tags' => new List<String>{ 'SalesTransactionItem' }
};
Map<String, Object> output = industriesContext.queryTags(input);
Recomendación: Consultar solo etiquetas específicas
// GOOD: Query only the specific tags (attributes) you need
Map<String, Object> input = new Map<String, Object>{
'contextId' => contextId,
'tags' => new List<String>{ 'LineItem', 'LineItemQuantity', 'ItemProductCode' }
};
Map<String, Object> output = industriesContext.queryTags(input);
Recomendación: Combinar etiquetas específicas con leanerQueryTags
// BETTER: Combine specific tags with leanerQueryTags for maximum efficiency
Map<String, Object> input = new Map<String, Object>{
'contextId' => contextId,
'tags' => new List<String>{ 'LineItem', 'LineItem$DmlStatus',
'LineItemQuantity', 'ItemProductCode' }
};
Map<String, Object> output = industriesContext.leanerQueryTags(input);
Utilizar leanerQueryTags en vez de queryTags
La clase Context.IndustriesContext proporciona dos métodos para consultar datos de contexto. Utilice leanerQueryTags siempre que sea posible para un mejor rendimiento.
queryTags (pesado): Devuelve nodos de contexto completo con mapas de valor de etiqueta anidados y matrices de dataPath. Cada atributo está incluido en un mapa con 6 campos (tagValue, dmlStatus, isDirty, isNodeLevelTag, tagPath, contextDataPathBuilder) por atributo y elemento. Todos los atributos de la etiqueta se devuelven independientemente de lo que necesite.
leanerQueryTags (ligero): Devuelve una estructura compacta con valores de etiqueta plana y referencias de Id. de registro basadas en índice. Los valores de etiqueta solo tienen 3 campos (tagValue, recordIdIndexesForPath, isNodeLevelTag). Los Id. de registro se deduplican en una lista de recordsInfo compartida; los nodos hacen referencia a ellos por índice.
El siguiente ejemplo muestra cómo llamar a leanerQueryTags y procesar su salida.
String contextId = request.ctxInstanceId;
Context.IndustriesContext industriesContext = new Context.IndustriesContext();
Map<String, Object> input = new Map<String, Object>{
'contextId' => contextId,
'tags' => new List<String>{ 'LineItem', 'ItemProductCode', 'LineItemQuantity' }
};
Map<String, Object> output = industriesContext.leanerQueryTags(input);
// Access the leaner result structure
Map<String, Object> queryResult = (Map<String, Object>)
output.get('leanerQueryTagResult');
List<Object> recordsInfo = (List<Object>) output.get('recordsInfo');
List<Object> lineItems = (List<Object>) queryResult.get('LineItem');
// Iterate over tag values — each tag is flat
List<Object> productCodes = (List<Object>) queryResult.get('ItemProductCode');
for (Object obj : productCodes) {
Map<String, Object> tagNode = (Map<String, Object>) obj;
String productCode = (String) tagNode.get('tagValue');
List<Integer> indexes = (List<Integer>) tagNode.get('recordIdIndexesForPath');
// recordsInfo entries are maps with 'recordId' and 'dmlStatusOrdinal'
String itemId = (String) ((Map<String, Object>)
recordsInfo.get(indexes[1])).get('recordId');
}
La estructura de salida de leanerQueryTags tiene este aspecto:
{
"isSuccess": true,
"contextId": "...",
"leanerQueryTagResult": {
"LineItem": [
{ "recordIdIndexesForPath": [0, 1], "tagValue": "0QLVW000001LxvN4AS", "isNodeLevelTag": false },
{ "recordIdIndexesForPath": [0, 2], "tagValue": "0QLVW000001Lxus4AC", "isNodeLevelTag": false }
],
"ItemProductCode": [
{ "recordIdIndexesForPath": [0, 1], "tagValue": "PROD-001", "isNodeLevelTag": false },
{ "recordIdIndexesForPath": [0, 2], "tagValue": "PROD-002", "isNodeLevelTag": false }
]
},
"recordsInfo": [
{ "recordId": "0Q0VW0000011qC50AI", "dmlStatusOrdinal": null },
{ "recordId": "0QLVW000001LxvN4AS", "dmlStatusOrdinal": null },
{ "recordId": "0QLVW000001Lxus4AC", "dmlStatusOrdinal": null }
]
}
Migrar de queryTags a leanerQueryTags
Cuando migre ganchos existentes desde queryTags a leanerQueryTags, aplique estas transformaciones clave.
Entrada: Utilizar etiquetas individuales en vez de etiquetas anchas
// Before (queryTags — broad tag):
Map<String, Object> input = new Map<String, Object>{
'contextId' => contextId,
'tags' => new List<String>{ 'SalesTransactionItem' }
};
Map<String, Object> output = industriesContext.queryTags(input);
// After (leanerQueryTags — specific tags):
Map<String, Object> input = new Map<String, Object>{
'contextId' => contextId,
'tags' => new List<String>{ 'LineItem', 'LineItem$DmlStatus',
'ItemProductCode', 'LineItemQuantity' }
};
Map<String, Object> output = industriesContext.leanerQueryTags(input);
Salida: Clave de nivel superior diferente
// Before:
Map<String, Object> queryResult = (Map<String, Object>) output.get('queryResult');
List<Object> items = (List<Object>) queryResult.get('SalesTransactionItem');
// After:
Map<String, Object> queryResult = (Map<String, Object>)
output.get('leanerQueryTagResult');
List<Object> recordsInfo = (List<Object>) output.get('recordsInfo');
List<Object> lineItems = (List<Object>) queryResult.get('LineItem');
Acceso de nodo: Valores planos en vez de mapas anidados
// Before (queryTags — nested map extraction):
for (Object itemObj : items) {
Map<String, Object> itemNode = (Map<String, Object>) itemObj;
Map<String, Object> tagValueMap = (Map<String, Object>) itemNode.get('tagValue');
String productCode = (String) ((Map<String, Object>)
tagValueMap.get('ItemProductCode')).get('tagValue');
Decimal quantity = (Decimal) ((Map<String, Object>)
tagValueMap.get('LineItemQuantity')).get('tagValue');
}
// After (leanerQueryTags — flat value, iterated per tag):
List<Object> productCodes = (List<Object>) queryResult.get('ItemProductCode');
List<Object> recordsInfo = (List<Object>) output.get('recordsInfo');
for (Object obj : productCodes) {
Map<String, Object> tagNode = (Map<String, Object>) obj;
String productCode = (String) tagNode.get('tagValue');
List<Integer> indexes = (List<Integer>) tagNode.get('recordIdIndexesForPath');
String itemId = (String) ((Map<String, Object>)
recordsInfo.get(indexes[1])).get('recordId');
}
Id. de registro: Referencias de índice en vez de dataPath
// Before (queryTags):
List<Object> dataPath = (List<Object>) itemNode.get('dataPath');
// dataPath = ['contextId', 'txnId', 'itemId'] — 3 elements, first is contextId
dataPath.remove(0);
String transactionId = (String) dataPath.get(0);
// After (leanerQueryTags):
List<Object> recordsInfo = (List<Object>) output.get('recordsInfo');
List<Integer> indexes = (List<Integer>) tagNode.get('recordIdIndexesForPath');
String transactionId = (String) ((Map<String, Object>)
recordsInfo.get(indexes[0])).get('recordId');
String itemId = (String) ((Map<String, Object>)
recordsInfo.get(indexes[1])).get('recordId');
Utilizar el patrón tagIdIndexMap
Cuando procese múltiples etiquetas en un único bucle, utilice un tagIdIndexMap para asignar cada nombre de etiqueta a su posición en la matriz de recordIdIndexesForPath. Esto le permite extraer correctamente identificadores en cada nivel de jerarquía:
Map<String, Integer> tagIdIndexMap = new Map<String, Integer>{
'LineItem' => 1, // item-level tag, ID at index 1
'LineItem$DmlStatus' => 1, // item-level tag, ID at index 1
'LineItemQuantity' => 1, // item-level tag, ID at index 1
'BusinessUnit__c' => 0, // transaction-level tag, ID at index 0
'Contract' => 0 // transaction-level tag, ID at index 0
};
- Índice 0 = nivel de transacción (la ruta tiene un elemento: [
txnId]) - Índice 1 = nivel de elemento (la ruta tiene dos elementos: [
txnId,itemId]) - Índice 2 = nivel de detalle (la ruta tiene tres elementos: [
txnId,itemId,detailId])
Filtrar elementos eliminados
Omita elementos eliminados al inicio de su bucle de iteración para evitar procesamientos innecesarios. Solicite LineItem$DmlStatus como una etiqueta separada en su consulta:
private static final String DML_DELETED = 'DELETED';
for (Map<String, Object> item : salesTransactionInstance.salesTransactionItems) {
String dmlStatus = (String) item.get('LineItem$DmlStatus');
if (dmlStatus == DML_DELETED) {
continue; // Skip deleted items
}
// Process active items...
}
Leer $DmlStatus como una etiqueta separada
Al consultar etiquetas específicas (el enfoque recomendado), el estado DML no se incrusta en los metadatos de la etiqueta. Debe solicitar LineItem$DmlStatus como una etiqueta separada. Esto se aplica tanto a queryTags como a leanerQueryTags.
// Add LineItem$DmlStatus to your tags list
'tags' => new List<String>{ 'LineItem', 'LineItem$DmlStatus', 'ItemProductCode' }
// Access it like any other tag in the result
Map<String, Object> dmlNode = (Map<String, Object>) dmlStatusValues.get(i);
String dmlStatus = String.valueOf(dmlNode.get('tagValue'));
