Ti trovi qui:
Codice di esempio per aggiornare la mappatura dei tipi di contratto non sincronizzati
Se si elimina, si aggiunge o si modifica la mappatura di un tipo di record con un tipo di referente, le modifiche si applicheranno solo ai nuovi contratti. Per aggiornare i contratti non sincronizzati, l'amministratore di sistema può eseguire un codice personalizzato.
L'amministratore di sistema può utilizzare questo codice di esempio per modificare la mappatura dei contratti per i contratti esistenti. Aprire la Developer Console, accedere a DebugOpen Execute Anonymous Window (Apri finestra Esegui anonimo), incollare il codice di esempio e fare clic su Execute (Esegui). Per ulteriori informazioni sull'utilizzo della classe Apex, vedere l'Apex Developer Guide.
Caso d'uso: Il tipo di contratto Salute corrisponde ai tipi di record Assistenza in degenza e Assistenza ambulatoriale. Sono presenti 1000 record contratto con questa mappatura. Si modifica la mappatura per il tipo di record Assistenza in degenza in tipo di contratto Reddito e dei 1000 record esistenti, ci sono 500 tipi di record Assistenza in degenza che puntano a Assistenza in tipo di contratto. Le righe di contratto continueranno a visualizzare il tipo di contratto Assistenza sanitaria e il tipo di record Assistenza in degenza poiché l'applicazione Salesforce Contracts non aggiorna automaticamente i record contratto con tipo di record Assistenza in degenza con tipo di contratto Reddito. Solo l'amministratore di sistema può applicare le modifiche utilizzando un codice di esempio. Tuttavia, quando viene creato un nuovo contratto con un tipo di record Assistenza in degenza, il tipo di contratto sarà Reddito.
Il codice di esempio estrae un elenco di tipi di contratto. È possibile passare qualsiasi numero di tipi di contratto e modificare la mappatura. È possibile modificare la query per apportare modifiche ed estrarre contratti con stati specifici come Bozza, Contratto scaduto, Annullato, ecc.
public class SyncContractTypes {
// use-case1 : sync contracts when existing RecordType that's associated with contracts is newly mapped to a existing ContractType
// use-case2 : sync contracts when existing RecordType that's associated with contracts is removed from ContractType object - ContractType, SubType mapping
// use-case3 : sync contracts when existing RecordType that's associated with contracts is removed from ContractType object - ContractType, SubType mapping and mapped to existing ContractType, SubType
public static void syncOutOfSyncContractTypes(List<String> contractTypes) {
Map<String,String> contractTypeSubtypeMap = new Map<String,String>();
Map<String,String> subtypeContractTypeMap = new Map<String,String>();
if(contractTypes != null && !contractTypes.isEmpty()) {
// Here we are querying all the contractTypes to support a use-case2
// where a SubType is removed from a contractType and mapped to another existing contractType
// If customers don't want to update when existing subType is mapped to another existing contractType they can
// restrict this by adding a where condition, WHERE MasterLabel IN :contractTypes
List<ContractType> contractTypeList = [SELECT MasterLabel,SubTypes FROM ContractType];
if(contractTypeList!= null && !contractTypeList.isEmpty()) {
for( ContractType c : contractTypeList) {
contractTypeSubtypeMap.put(c.MasterLabel, c.SubTypes);
if(c.subTypes != null) {
for(String s : c.subTypes.split(',')) {
subtypeContractTypeMap.put(s, c.MasterLabel);
}
}
}
}
for(String ct : contractTypes) {
String contractType = (contractTypeSubtypeMap.containsKey(ct)) ? ct : '';
List<String> subTypesList = (contractTypeSubtypeMap.get(ct) != null) ? contractTypeSubtypeMap.get(ct).split(',') : new List<String>();
// we are applying basic filters here, please modify them accordingly to your use case
List<Contract> contracts = [
SELECT Id, ContractType, Name, RecordType.Name
FROM Contract
WHERE (ContractType =: contractType OR RecordType.Name IN :subTypesList)
AND IsAssociatedWithCLM = true
AND (NOT (ContractType =: contractType AND RecordType.Name IN : subTypesList))];
List<Contract> contractsToUpdate = new List<Contract>();
// check if any of the contracts are out of sync and update them
for(Contract c : contracts) {
String RecordTypeName = c.RecordType.Name;
if(subTypesList.contains(RecordTypeName) && c.ContractType != contractType) {
c.ContractType = contractType;
contractsToUpdate.add(c);
} else if(!subTypesList.contains(RecordTypeName) ){
// check to see if any other ContractTypes has this RecordType as SubType
c.ContractType = (subtypeContractTypeMap.get(RecordTypeName) != null) ? subtypeContractTypeMap.get(RecordTypeName) : '';
contractsToUpdate.add(c);
}
}
if(contractsToUpdate != null && !contractsToUpdate.isEmpty()) {
Database.SaveResult[] saveResult = Database.Update(contractsToUpdate, false);
for (Database.SaveResult sr : saveResult) {
if (sr.isSuccess()) {
// Operation was successful, so get the ID of the record that was processed
System.debug('Successfully updated contract. Contract ID: ' + sr.getId());
}
else {
// Operation failed, so get all errors
for(Database.Error err : sr.getErrors()) {
System.debug('The following error has occurred.');
System.debug(err.getStatusCode() + ': ' + err.getMessage());
System.debug('Contract fields that affected this error: ' + err.getFields());
}
}
}
}
}
}
}
}
