Usted está aquí:
Código de muestra para actualizar la asignación de tipos de contratos no sincronizados
Si elimina, agrega o modifica una asignación de tipo de registro con un tipo de contacto, los cambios solo se aplicarán a los nuevos contratos. Para actualizar los contratos no sincronizados, el administrador del sistema puede ejecutar un código personalizado.
El administrador del sistema puede utilizar este código de muestra para modificar la asignación de contratos para contratos existentes. Abra Developer Console, vaya a Depurar. Abra Ventana Ejecutar anónima, pegue el código de muestra y haga clic en Ejecutar. Para obtener más información sobre el uso de Apex Class, consulte la Guía del desarrollador.
Caso de uso: Tipo de contrato Salud corresponde a los tipos de registro Cuidados hospitalarios y Cuidados ambulatorios. Existen 1000 registros de contrato que tienen esta asignación. Cambie la asignación para el tipo de registro Cuidados de pacientes a Ingresos de tipo de contrato y de los 1000 registros existentes, hay 500 tipos de registro Cuidados de pacientes hospitalizados apuntando a Tipo de contrato Salud. Las filas de contratos seguirán mostrando el tipo de contrato como Salud y el tipo de registro como Cuidados de pacientes hospitalizados porque la aplicación Salesforce Contracts no actualiza automáticamente los registros de contratos que tienen el tipo de registro Cuidados de pacientes hospitalizados con el tipo de contrato Ingresos. Solo el administrador del sistema puede aplicar los cambios utilizando un código de muestra. Sin embargo, cuando se crea un nuevo contrato con un tipo de registro Cuidados de pacientes hospitalizados, el tipo de contrato será Ingresos.
El código de muestra extrae una lista de Tipos de contrato. Puede pasar cualquier número de Tipos de contrato y ajustar la asignación. Puede modificar la consulta para realizar cambios y extraer contratos con estados específicos como Borrador, Contrato vencido, Cancelado, etc.
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());
}
}
}
}
}
}
}
}
