Salesforce Trailhead Superbadge逻辑用于创建连接对象

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

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

（设备维护项目对象是连接对象）

使用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;   
}

public与共享类MaintenanceRequestThelper{
公共静态无效更新工作订单（列表案例列表）{
整数i=0；
List NewCaseList=新列表（）；
列表列表=[选择Id、维护请求、设备、数量
来自设备维护项目c
维护请求（在：案例列表中）的位置；
List mindue=新列表（[选择最小值（设备维护周期）最小值
来自设备维护项目，其中维护请求（在：案例列表中））；
整数k=0；
List newEmi=新列表（）；
（案例c：案例清单）{
如果（c.Status=='Closed'&&（c.type=='Repair'| | c.type=='Routine Maintenance'））{
案例c1=新案例(
状态='新'，
车辆c=c。车辆c，
类型=‘日常维护’，
主题='例行检查'，
Date_Reported__c=日期。今天（），
产品c=c。产品c，
AccountId=c.AccountId，
ContactId=c.ContactId，
原点=c.原点
//Date\u Due\uu c=日期。今天（）
);
新增病例表（c1）；
用于（设备维护项目电磁干扰：列表）{
如果（c.Id==电磁干扰维护请求）{
新增（新设备维护项目）(
设备c=电磁干扰设备c，
维护请求c=c.Id，
数量=emi.数量（c））；
}
}
对于（聚合结果r:mindue）{
if（r.get（'MinimumValue'）！=NULL）{
NewCaseList[i].Date_Due__c=system.today（）+integer.valueof（r.get（'MinimumValue'）；
}
i++；
}
}
}
如果（NewCaseList.size（）>0）{
插入新的案件清单；
}
对于（案例c2：新案例列表）{
用于（设备维护项目电磁干扰2：新电磁干扰）{
emi2.维护请求=c2.id；
}
}
插入newEmi；
}

---

}

您的代码是正确的，但没有臃肿。它只适用于一条记录，如果一组记录同时关闭，它将失败。我通过在案例对象上创建一个字段来解决这个问题，该字段将存储克隆的案例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);    
        }     
    }        
}
    
     

触发案例维护请求（更新前、更新后）{
//ToDo:呼叫MaintenanceRequestsHelper.updateWorkOrders
if（trigger.isAfter）{
MaintenanceRequestSelper.updateWorkOrders（触发器.new）；
}
}
公共与共享类维护请求管理员{
公共静态void updateWorkOrders（列表newList）{
//TODO:完成更新工作单的方法
List CreateMaintReqLst=新列表（）；
Set caseidset=new Set（）；
List newEMI=新列表（）；
对于（案例记录：新列表）
{
如果（caseRec.Status==‘已关闭’&&
（caseRec.Type==‘修理’| | caseRec.Type==‘日常维护’）
{
caseidset.add（caseRec.Id）；
}
}
列表案例列表=[选择Id、类型、状态、车辆、主题、报告日期、到期日期、产品Id、产品c、，
（从设备维护项目中选择Id、维护周期、设备、数量）
从案例
其中Id位于：caseidset]；
对于（案例记录：案例列表）{
整数minMaintCycle=0；
列表设备维护列表=案例记录设备维护项目；
如果（EqpMaintList.size（）>0）{
用于（设备维护项目设备维护：设备维护列表）{
新增（新设备维护项目）(
设备c=设备维护。设备c，
维护请求=caseRec.Id，
数量c=设备维护数量c）；
if（整型值of（设备维护周期）