Trailhead Superbadge Logic 来创建连接对象

如何解决Trailhead Superbadge Logic 来创建连接对象

我有一个挑战要完成。要求是自动创建新案例记录（重命名的维护请求）。当维修或例行维护类型的现有维护请求（案例记录）关闭时，创建新的维护请求（案例记录）以备将来例行检查。这个新的维护请求与原始关闭请求相同的车辆和设备（产品 2 - 标准对象重命名）记录相关联。截止日期字段有一个逻辑。与维修请求相关的设备记录的所有维修周期相比，应有最小日期。

我在触发器的辅助类中分离了逻辑。我相信“设备维护项目”记录创建的助手类代码逻辑不是正确的方法，但小道已经接受了它并给了我 500 分。请帮我找到新的“设备维护项目”记录创建逻辑的正确方法。

（“设备维护项目”对象是一个连接对象） image

使用了 2 个标准对象： 维修请求（更名案例）和设备（更名产品）

使用了 2 个自定义对象： 车辆及设备维修项目

触发器：

trigger MaintenanceRequest on Case (before update,after update) {
if(Trigger.isAfter){
    MaintenanceRequestHelper.updateWorkOrders(Trigger.New);
}} 

助手类：

public with sharing class MaintenanceRequestHelper {

public static void updateWorkOrders(List<Case> CaseList) {
    integer i=0;
    List<Case> NewCaseList = new List<Case>();
    List<Equipment_Maintenance_Item__c> eList = [SELECT Id,Maintenance_Request__c,Equipment__c,Quantity__c 
                                                FROM Equipment_Maintenance_Item__c 
                                                WHERE Maintenance_Request__c IN: CaseList];
    List<Aggregateresult> mindue = new List<Aggregateresult>([SELECT MIN(Equipment__r.Maintenance_Cycle__c)MinimumValue 
                                                              FROM Equipment_Maintenance_Item__c WHERE Maintenance_Request__c IN: CaseList]);
    integer k=0;
    List<Equipment_Maintenance_Item__c> newEmi = new List<Equipment_Maintenance_Item__c>();
    for(Case c : CaseList){
        if(c.Status == 'Closed' && (c.type =='Repair' || c.type =='Routine Maintenance')){
            Case c1 = new Case(
            Status = 'New',Vehicle__c = c.Vehicle__c,Type = 'Routine Maintenance',Subject = 'Routine Checkup',Date_Reported__c = Date.today(),Product__c = c.Product__c,AccountId = c.AccountId,ContactId = c.ContactId,Origin = c.Origin
            //Date_Due__c = Date.today()
            );
            NewCaseList.add(c1);
            for(Equipment_Maintenance_Item__c emi : eList){
               if(c.Id == emi.Maintenance_Request__c){
                 newEmi.add(new Equipment_Maintenance_Item__c(
                              Equipment__c = emi.Equipment__c,Maintenance_Request__c = c.Id,Quantity__c = emi.Quantity__c));
                  }
             }
             for(Aggregateresult r:mindue){          
                if(r.get('MinimumValue')!=NULL){
                   NewCaseList[i].Date_Due__c=system.today()+integer.valueof(r.get('MinimumValue'));
                }
             i++;
             }
        }
        
    }
    if(NewCaseList.size()>0){
        insert NewCaseList;     
    }

    for(Case c2: NewCaseList){
        for(Equipment_Maintenance_Item__c emi2 : newEmi){
            emi2.Maintenance_Request__c = c2.id;
       }
    }
          
     insert newEmi;   
}

}

解决方法

您的代码正确但未批量化。它适用于单个记录，如果一堆记录同时关闭，它将失败。我通过在 Case 对象上创建一个字段来解决这个问题，该字段将存储克隆的 Case Id，即创建新案例的旧案例。

请参考以下代码示例：

    trigger MaintenanceRequest on Case (before update,after update) {
        //ToDo: Call MaintenanceRequestHelper.updateWorkOrders
        if(trigger.isAfter){
            MaintenanceRequestHelper.updateWorkOrders(trigger.new);    
        }
    }

public with sharing class MaintenanceRequestHelper {
    
    public static void updateWorkOrders(List<Case> newList) {
        // TODO: Complete the method to update workorders
        List<Case> CreateMaintReqLst = new List<Case>();
        Set<Id> caseIdsSet = new Set<Id>();
        List<Equipment_Maintenance_Item__c> newEMI = new List<Equipment_Maintenance_Item__c>();
        for (Case caseRec : newList)
        {
            if(caseRec.Status == 'Closed' &&
               (caseRec.Type =='Repair' || caseRec.Type =='Routine Maintenance'))
            {
                caseIdsSet.add(caseRec.Id);    
            }
        }
        List<Case> CaseList = [SELECT Id,Type,Status,Vehicle__c,Subject,Date_Reported__c,Date_Due__c,ProductId,Product__c,(select Id,Maintenance_Cycle__c,Equipment__c,Quantity__c FROM Equipment_Maintenance_Items__r)
                               FROM Case
                               WHERE Id in:caseIdsSet];        
        
        for(Case caseRec:CaseList){
            Integer minMaintCycle = 0;
            List<Equipment_Maintenance_Item__c> EqpMaintList = caseRec.Equipment_Maintenance_Items__r;
            if(EqpMaintList.size()>0){
                for(Equipment_Maintenance_Item__c EquipMaint:EqpMaintList){
                    newEMI.add(new Equipment_Maintenance_Item__c(
                        Equipment__c = EquipMaint.Equipment__c,Maintenance_Request__c = caseRec.Id,Quantity__c = EquipMaint.Quantity__c));
                    if(Integer.valueOf(EquipMaint.Maintenance_Cycle__c) < minMaintCycle || minMaintCycle == 0){
                        minMaintCycle =Integer.valueOf(EquipMaint.Maintenance_Cycle__c);
                    }       
                }
            }
            Case newCase = new Case();
            newCase.Type = 'Routine Maintenance';
            newCase.Status = 'New';
            newCase.Vehicle__c = caseRec.Vehicle__c;
            newCase.Subject =  String.isBlank(caseRec.Subject) ? 'Routine Maintenance Request' : caseRec.Subject;
            newCase.Date_Reported__c = Date.today();
            newCase.Date_Due__c = Date.today().addDays(minMaintCycle);
            newCase.ProductId = caseRec.ProductId;
            newCase.Product__c = caseRec.Product__c;
            newCase.Cloned_Closed_Case_Id__c = caseRec.Id;
            CreateMaintReqLst.add(newCase);
        }
        
        if(CreateMaintReqLst.size()>0){
            Database.insert(CreateMaintReqLst);    
        }
        
        for(Case c2: CreateMaintReqLst){
            for(Equipment_Maintenance_Item__c emi2 : newEmi){
                if(c2.Cloned_Closed_Case_Id__c == emi2.Maintenance_Request__c){
                    emi2.Maintenance_Request__c = c2.id;    
                }
            }
        }
        
        if(newEmi.size()>0){
            Database.insert(newEmi);    
        }     
    }        
}