diff --git a/models/om/om.go b/models/om/om.go
index f0c8215..e22397a 100644
--- a/models/om/om.go
+++ b/models/om/om.go
@@ -139,12 +139,12 @@ type SerialOrderPOWithProcess struct {
 
 // OrderAUPoData 生成工艺数据时 工单Id对应的
 type OrderAUPoData struct {
-	Config        *meModel.ShipableAUConfig
-	MeOperationLi []baseModel.MeOperation
-	IsMainOrder   bool
-	SFP           *baseModel.Article
-	AllAttributeLi      []baseModel.ArticleAttribute
-	ArtRelMap map[string]int
+	Config         *meModel.ShipableAUConfig
+	MeOperationLi  []baseModel.MeOperation
+	IsMainOrder    bool
+	SFP            *baseModel.Article
+	AllAttributeLi []baseModel.ArticleAttribute
+	ArtRelMap      map[string]int
 }
 
 type ExportItem struct {
@@ -162,9 +162,10 @@ type ProductTraceData struct {
 }
 
 type ProductTracePOData struct {
-	PO     string                 `json:"ProductTracePOData-PO"`
-	PoDesc string                 `json:"ProductTracePOData-PoDesc"`
-	StepLi []ProductTraceStepData `json:"ProductTracePOData-StepLi"`
+	PO       string                 `json:"ProductTracePOData-PO"`
+	PoDesc   string                 `json:"ProductTracePOData-PoDesc"`
+	PoStatus string                 `json:"ProductTracePOData-PoStatus"`
+	StepLi   []ProductTraceStepData `json:"ProductTracePOData-StepLi"`
 }
 
 type ProductTraceStepData struct {
diff --git a/services/om/implments/SerialOrder.service.impl.go b/services/om/implments/SerialOrder.service.impl.go
index 1d311f2..10bcfc6 100644
--- a/services/om/implments/SerialOrder.service.impl.go
+++ b/services/om/implments/SerialOrder.service.impl.go
@@ -18,8 +18,6 @@ import (
 	eolModel "LAPP_ACURA_MOM_BACKEND/models/eol"
 	meModel "LAPP_ACURA_MOM_BACKEND/models/me"
 	model "LAPP_ACURA_MOM_BACKEND/models/om"
-	"LAPP_ACURA_MOM_BACKEND/utils"
-	"fmt"
 	"github.com/go-xorm/xorm"
 	"strconv"
 	"strings"
@@ -3275,132 +3273,6 @@ func (impl *SerialOrderServiceImplement) GetSerialOrderOperationData(user *globa
 	}
 	if needEOL {
 		// 电检 主驾和副驾需要查询EOLDR 和 EOLPA 两张表 后排 查询EOLBR
-		//var poOperationData model.POOperationData
-		//poOperationData.PO = "电检"
-		//poOperationData.Status = "成功"
-		//poOperationData.RecvDataLi = make([]model.RecvDataItem, 0)
-		//eolEngine := db.Eloquent.Slaves()[0]
-		//eolSession := eolEngine.NewSession()
-		//eolDrDao := eolDal.NewEOLDRDAO(eolSession, user.UserId)
-		//eolPaDao := eolDal.NewEOLPADAO(eolSession, user.UserId)
-		//eolBrDao := eolDal.NewEOLBRDAO(eolSession, user.UserId)
-		//productDao := meDal.NewProductDAO(session, user.PlantNr, user.UserId)
-		//// 查询工单是否有返修记录 如果有返修记录 需要在返修记录后有电检数据
-		//var repairFlag bool
-		//var repairTime time.Time
-		//repairInfoDao := baseDal.NewRepairInfoDAO(session, user.UserId)
-		//repairInfoLi, err := repairInfoDao.Select([]grmi.Predicate{
-		//	baseMeta.RepairInfo_SerialOrderId.NewPredicate(grmi.Equal, serialOrderId),
-		//}, []grmi.Field{baseMeta.RepairInfo_CreateTime})
-		//if err != nil {
-		//	return nil, grmi.NewBusinessError("查询工单返修记录失败, 错误:" + err.Error())
-		//}
-		//if len(repairInfoLi) != 0 {
-		//	repairFlag = true
-		//	repairTime = repairInfoLi[len(repairInfoLi)-1].CreateTime.Restore()
-		//}
-		//product, err := productDao.SelectOne(serialOrder.ArtId, serialOrder.ProjectId)
-		//if err != nil {
-		//	return nil, grmi.NewBusinessError("查询工单总成信息失败, 错误:" + err.Error())
-		//}
-		//if product == nil {
-		//	return nil, grmi.NewBusinessError("工单总成数据不存在")
-		//}
-		//eolResultLi := make([]interface{}, 0)
-		//if product.CtrlStr1 == meModel.PRODUCT_TYPE_MS || product.CtrlStr1 == meModel.PRODUCT_TYPE_PS {
-		//
-		//	drLi, err := eolDrDao.Select([]grmi.Predicate{eolMeta.EOLDR_CODE.NewPredicate(grmi.Equal, serialOrderId)}, nil)
-		//	if err != nil {
-		//		return nil, grmi.NewBusinessError("查询电检数据失败, 错误：" + err.Error())
-		//	}
-		//	paLi, err := eolPaDao.Select([]grmi.Predicate{eolMeta.EOLPA_CODE.NewPredicate(grmi.Equal, serialOrderId)}, nil)
-		//	if err != nil {
-		//		return nil, grmi.NewBusinessError("查询电检数据失败, 错误:" + err.Error())
-		//	}
-		//	for _, item := range drLi {
-		//		eolResultLi = append(eolResultLi, item)
-		//	}
-		//	for _, item := range paLi {
-		//		eolResultLi = append(eolResultLi, item)
-		//	}
-		//} else {
-		//	brLi, err := eolBrDao.Select([]grmi.Predicate{eolMeta.EOLBR_CODE.NewPredicate(grmi.Equal, serialOrderId)}, nil)
-		//	if err != nil {
-		//		return nil, grmi.NewBusinessError("查询电检数据失败, 错误:" + err.Error())
-		//	}
-		//	for _, item := range brLi {
-		//		eolResultLi = append(eolResultLi, item)
-		//	}
-		//}
-		//
-		//if len(eolResultLi) == 0 {
-		//	recvData := model.RecvDataItem{
-		//		SerialOrderId: serialOrderId,
-		//		ArtId:         "",
-		//		PO:            "EOL",
-		//		OperationDesc: "电检",
-		//		RecvData:      "",
-		//		Status:        "失败",
-		//		Remark1:       "未查询到电检数据",
-		//	}
-		//	poOperationData.RecvDataLi = append(poOperationData.RecvDataLi, recvData)
-		//	poOperationData.Status = "失败"
-		//} else {
-		//	err = impl.QuickSort(eolResultLi)
-		//	if err != nil {
-		//		return nil, err
-		//	}
-		//	fmt.Println("eolResultLi:", eolResultLi)
-		//	lastRecord := eolResultLi[len(eolResultLi)-1]
-		//	var recordTime time.Time
-		//	var recordResult string
-		//	drData, ok := lastRecord.(eolModel.EOLDR)
-		//	if ok {
-		//		recordTime, _ = time.ParseInLocation("2006/01/02 15:04:05", drData.TESTDATA, utils.TimezoneLocation)
-		//		recordResult = drData.TOTALRESULT
-		//	} else {
-		//		paData, ok := lastRecord.(eolModel.EOLPA)
-		//		if ok {
-		//			recordTime, _ = time.ParseInLocation("2006/01/02 15:04:05", paData.TESTDATA, utils.TimezoneLocation)
-		//			recordResult = paData.TOTALRESULT
-		//		} else {
-		//			brData, ok := lastRecord.(eolModel.EOLBR)
-		//			if ok {
-		//				recordTime, _ = time.ParseInLocation("2006/01/02 15:04:05", brData.TESTDATA, utils.TimezoneLocation)
-		//				recordResult = brData.TOTALRESULT
-		//			} else {
-		//				return nil, grmi.NewBusinessError("电检数据格式错误")
-		//			}
-		//		}
-		//	}
-		//
-		//	var status string = "成功"
-		//	var remark string = "已通过电检"
-		//	if repairFlag {
-		//		if recordTime.Before(repairTime) {
-		//			status = "失败"
-		//			result.Status = false
-		//			remark = "线上返修之后未进行电检"
-		//		}
-		//	}
-		//	if recordResult != "OK" {
-		//		status = "失败"
-		//		result.Status = false
-		//		remark = "电检不合格"
-		//	}
-		//	recvData := model.RecvDataItem{
-		//		SerialOrderId: serialOrderId,
-		//		ArtId:         "",
-		//		PO:            "EOL",
-		//		OperationDesc: "电检",
-		//		RecvData:      "",
-		//		Status:        status,
-		//		Remark1:       remark,
-		//		ExecuteTime:   recordTime.Format(grmi.DateTimeOutFormat),
-		//	}
-		//	poOperationData.RecvDataLi = append(poOperationData.RecvDataLi, recvData)
-		//}
-		//result.TraceDataTraceData = append(result.TraceDataTraceData, poOperationData)
 		eolStatus, remark, recordTime, err := impl.ExtractEOL(session, user, serialOrder)
 		if err != nil {
 			return nil, err
@@ -3531,14 +3403,24 @@ func (impl *SerialOrderServiceImplement) ExtractEOL(session *xorm.Session, user
 
 // GetSerialOrderOperationTraceData 工单数据追溯
 func (impl *SerialOrderServiceImplement) GetSerialOrderOperationTraceData(user *global.User, serialOrderId string) (interface{}, error) {
+	var totalResult = &model.TraceData{
+		BarCode: serialOrderId,
+		Status:  true,
+	}
 	engine := db.Eloquent.Master()
 	session := engine.NewSession()
 	defer session.Close()
+	result := model.ProductTraceData{
+		SerialOrderId: serialOrderId,
+		POLi:          make([]model.ProductTracePOData, 0),
+	}
 	// 1. 查询工单
 	// 2. 通过工单查询生产的产线
 	// 4. 通过工序查询当前工序生成工步结果
 	serialOrderDao := dal.NewSerialOrderDAO(session, user.PlantNr, user.UserId)
 	serialOrderPoDao := dal.NewSerialOrderPOLstDAO(session, user.PlantNr, user.UserId)
+	serialOrderStepDao := dal.NewSerialOrderStepLstDAO(session, user.PlantNr, user.UserId)
+	recvDataDao := dal.NewSerialOrderOPDetailRecvDataLstDAO(session, user.PlantNr, user.UserId)
 	serialOrder, err := serialOrderDao.SelectOne(serialOrderId)
 	if err != nil {
 		return nil, grmi.NewBusinessError("查询工单失败, error:" + err.Error())
@@ -3546,12 +3428,7 @@ func (impl *SerialOrderServiceImplement) GetSerialOrderOperationTraceData(user *
 	if serialOrder == nil {
 		return nil, grmi.NewBusinessError("工单不存在, 工单ID:" + serialOrderId)
 	}
-	var traceOrderId string
-	if serialOrder.OriginSerialOrderId != "" {
-		traceOrderId = serialOrder.OriginSerialOrderId
-	} else {
-		traceOrderId = serialOrder.SerialOrderId
-	}
+
 	articleDao := baseDal.NewArticleDAO(session, user.PlantNr, user.UserId)
 	article, err := articleDao.SelectOne(serialOrder.ArtId, serialOrder.ProjectId)
 	if err != nil {
@@ -3562,7 +3439,6 @@ func (impl *SerialOrderServiceImplement) GetSerialOrderOperationTraceData(user *
 	}
 	articleAtocdDao := baseDal.NewArticleAtcodLstDAO(session, user.PlantNr, user.UserId)
 	var needEOL bool
-	var needSBR bool
 	attributeLi, err := articleAtocdDao.SelectByArtId(serialOrder.ArtId)
 	if err != nil {
 		return nil, grmi.NewBusinessError("查询总成关联属性失败, error:" + err.Error())
@@ -3570,215 +3446,171 @@ func (impl *SerialOrderServiceImplement) GetSerialOrderOperationTraceData(user *
 	for _, attributeItem := range attributeLi {
 		if attributeItem.Attribute.Descr == "EOL" {
 			needEOL = true
-		} else if attributeItem.Attribute.Descr == "SBR检测" {
-			needSBR = true
 		}
 	}
-
-	serialOrderIdLi := make([]string, 0)
+	totalResult.Desc = article.Descr1
+	totalResult.IsFirstPiece = serialOrder.IsFirstPieceToggle
+	// 所有工单ID
+	allOrderIdLi := make([]interface{}, 0)
 	if serialOrder.OriginSerialOrderId != "" {
-		allSerialOrder, err := serialOrderDao.Select([]grmi.Predicate{
+		subSerialOrderLi, err := serialOrderDao.Select([]grmi.Predicate{
+			meta.SerialOrder_SerialOrderId.NewPredicate(grmi.NotEqual, serialOrderId),
 			meta.SerialOrder_OriginSerialOrderId.NewPredicate(grmi.Equal, serialOrder.OriginSerialOrderId),
-		}, []grmi.Field{meta.SerialOrder_CreateTime})
+		}, nil)
 		if err != nil {
-			return nil, grmi.NewBusinessError("查询工单失败, 错误:" + err.Error())
+			return nil, grmi.NewBusinessError("查询工单数据失败, 错误:" + err.Error())
 		}
-		for _, innerOrder := range allSerialOrder {
-			serialOrderIdLi = append(serialOrderIdLi, innerOrder.SerialOrderId)
+		allOrderIdLi = append(allOrderIdLi, serialOrderId, serialOrder.OriginSerialOrderId)
+		for _, subOrder := range subSerialOrderLi {
+			allOrderIdLi = append(allOrderIdLi, subOrder.SerialOrderId)
 		}
+	} else {
+		allOrderIdLi = append(allOrderIdLi, serialOrder.SerialOrderId)
 	}
-	serialOrderIdLi = append(serialOrderIdLi, serialOrderId)
-	poDataLi, err := serialOrderPoDao.SelectWithPO(traceOrderId, serialOrder.UsedResourceId)
+
+	allPoLi, err := serialOrderPoDao.SelectByOrderLi(allOrderIdLi, serialOrder.UsedResourceId)
 	if err != nil {
-		return nil, grmi.NewBusinessError("查询工单工序操作数据失败, error:" + err.Error())
+		return nil, grmi.NewBusinessError("查询工序数据失败, 错误:" + err.Error())
 	}
-	var result model.TraceData
-	result.Status = true
-	result.BarCode = serialOrderId
-	result.Desc = article.Descr1
-	result.IsFirstPiece = serialOrder.IsFirstPieceToggle
-	displayPoLi := make([]string, 0)
-	poStatusMap := make(map[string]string)
-	for _, poData := range poDataLi {
-		displayPoLi = append(displayPoLi, poData.Process.PO)
-		if poData.Status == baseModel.WO_STATUS_FINISHED {
-			poStatusMap[poData.Process.PO] = "成功"
+	poMap := make(map[string]int)
+	for _, poItem := range allPoLi {
+		var status string
+		if poItem.Status == baseModel.ORDER_STATUS_CLOSED {
+			status = "成功"
 		} else {
-			poStatusMap[poData.Process.PO] = "失败"
-			result.Status = false
+			status = "失败"
+		}
+		_, exist := poMap[poItem.Process.PO]
+		if !exist {
+			poMap[poItem.Process.PO] = len(result.POLi)
+			poData := model.ProductTracePOData{
+				PO:     poItem.Process.PO,
+				PoDesc: poItem.Process.Descr,
+				PoStatus: status,
+				StepLi: make([]model.ProductTraceStepData, 0),
+			}
+			result.POLi = append(result.POLi, poData)
+		} else {
+			index := poMap[poItem.Process.PO]
+			originPoData := result.POLi[index]
+			originPoData.PoStatus = status
+			result.POLi[index] = originPoData
 		}
 	}
-	//// 查询工单产线
-	//workLineId := serialOrder.PlanResourceId
-	//// 通过产线查询生产工序
-	//workLineProcessDao := baseDal.NewWorkLineProcessLstDAO(session, user.PlantNr, user.UserId)
-	//poLi, err := workLineProcessDao.SelectProcessByWorkLine(workLineId)
-	//if err != nil {
-	//	return nil, grmi.NewBusinessError("查询产线生产工序失败, error:" + err.Error())
-	//}
-	//if len(poLi) <= 1 {
-	//	return nil, grmi.NewBusinessError("生产工序少于2个")
-	//}
-	//poIdLi := make([]string, 0, len(poLi))
-	//for _, po := range poLi {
-	//	if po.IsLastPO || po.IsLastPOForBK {
-	//		continue
-	//	}
-	//	poIdLi = append(poIdLi, po.PO)
-	//}
-	//displayPoLi := poIdLi
-
-	// 查询工序关联的所有工位
-	processWorkPlaceDao := baseDal.NewProcessWorkPlaceLstDAO(session, user.PlantNr, user.UserId)
-	relateWorkPlaceLi, err := processWorkPlaceDao.SelectByProcess(displayPoLi)
+	stepLi, err := serialOrderStepDao.Select([]grmi.Predicate{
+		meta.SerialOrderStepLst_SerialOrderId.NewPredicate(grmi.Include, allOrderIdLi...),
+	}, []grmi.Field{meta.SerialOrderStepLst_StepNo})
 	if err != nil {
-		return nil, grmi.NewBusinessError("查询工序关联的工位失败, error:" + err.Error())
+		return nil, grmi.NewBusinessError("查询工步数据失败, 错误:" + err.Error())
 	}
-	workPlaceMap := make(map[int]string)
-	ignorePOMap := make(map[string]interface{})
-	for _, relateDate := range relateWorkPlaceLi {
-		if relateDate.WorkPlace.TriggerFrom == baseModel.TRIGGER_FROM_PICKING {
-			ignorePOMap[relateDate.ProcessWorkPlaceLst.PO] = nil
+	stepMap := make(map[string]int)
+	for _, stepItem := range stepLi {
+		mapKey := stepItem.PO + "_" + strconv.Itoa(stepItem.StepNo)
+		_, exist := stepMap[mapKey]
+		if !exist {
+			poIndex := poMap[stepItem.PO]
+			stepMap[mapKey] = len(result.POLi[poIndex].StepLi)
+			stepData := model.ProductTraceStepData{
+				StepNo:     stepItem.StepNo,
+				StepDesc:   stepItem.StepDesc,
+				RecvDataLi: make([]model.SerialOrderOPDetailRecvDataLst, 0),
+			}
+			result.POLi[poIndex].StepLi = append(result.POLi[poIndex].StepLi, stepData)
 		}
-		workPlaceMap[relateDate.WorkPlace.WorkPlaceNr] = relateDate.WorkPlace.WorkPlaceId
 	}
-	//stepDao := dal.NewSerialOrderStepLstDAO(session, user.PlantNr, user.UserId)
-	//poIdLiInterface := make([]interface{}, 0, len(displayPoLi))
-	selectPoIdLi := make([]string, 0, len(displayPoLi))
-	for _, poId := range displayPoLi {
-		_, exist := ignorePOMap[poId]
-		if exist {
+
+	recvDataLi, err := recvDataDao.Select([]grmi.Predicate{
+		meta.SerialOrderOPDetailRecvDataLst_SerialOrderId.NewPredicate(grmi.Include, allOrderIdLi...),
+	}, []grmi.Field{
+		meta.SerialOrderOPDetailRecvDataLst_SerialOrderId,
+		meta.SerialOrderOPDetailRecvDataLst_PO,
+		meta.SerialOrderOPDetailRecvDataLst_StepNo,
+		meta.SerialOrderOPDetailRecvDataLst_OriginRuleId,
+	})
+	if err != nil {
+		return nil, grmi.NewBusinessError("查询生产数据失败, 错误:" + err.Error())
+	}
+	for _, recvData := range recvDataLi {
+		poIndex, exist := poMap[recvData.PO]
+		if !exist {
 			continue
 		}
-		//poIdLiInterface = append(poIdLiInterface, poId)
-		selectPoIdLi = append(selectPoIdLi, poId)
-	}
-
-	//var result model.TraceData
-	//result.BarCode = serialOrderId
-	//result.Desc = article.Descr1
-	//result.Status = true
-	//result.IsFirstPiece = serialOrder.IsFirstPieceToggle
-	//result.TraceDataTraceData = make([]model.POOperationData, 0)
-	//poDataLi, err := serialOrderPoDao.Select([]grmi.Predicate{meta.SerialOrderPOLst_SerialOrderId.NewPredicate(grmi.Equal, serialOrderId), meta.SerialOrderPOLst_PO.NewPredicate(grmi.Include, poIdLiInterface...)}, nil)
-	//if err != nil {
-	//	return nil, grmi.NewBusinessError("查询工单工序操作数据失败, error:" + err.Error())
-	//}
-	//poStatusMap := make(map[string]string)
-	//for _, poData := range poDataLi {
-	//	if poData.Status == baseModel.WO_STATUS_FINISHED {
-	//		poStatusMap[poData.PO] = "成功"
-	//	} else {
-	//		poStatusMap[poData.PO] = "失败"
-	//		result.Status = false
-	//	}
-	//}
-	// 通过工序和工单ID查询工步操作结果
-	opDao := dal.NewSerialOrderOPDetailRecvDataLstDAO(session, user.PlantNr, user.UserId)
+		stepKey := recvData.PO + "_" + strconv.Itoa(recvData.StepNo)
+		stepIndex, exist := stepMap[stepKey]
 
-	for _, poId := range selectPoIdLi {
-		opLi, err := opDao.GetOpRecvDataByPO(traceOrderId, poId)
-		if err != nil {
-			return nil, grmi.NewBusinessError("查询工艺操作数据失败, error:" + err.Error())
-		}
-		var poOperationData model.POOperationData
-		poOperationData.PO = poId
-		poOperationData.Status = poStatusMap[poId]
-		poOperationData.RecvDataLi = make([]model.RecvDataItem, 0)
-		for _, opData := range opLi {
-			var operationDesc string
-			if opData.SerialOrderOPDetail.StepType == baseModel.STEP_OPC_RULE {
-				operationDesc = opData.OPCComRule.DBlockDesc
-			} else if opData.SerialOrderOPDetail.StepType == baseModel.STEP_TW_RULE {
-				operationDesc = opData.TightenWrenchRuleInfo.StepDesc
-			} else {
-				operationDesc = opData.Operation.StepDesc
-			}
-			var status string
-			if opData.SerialOrderOPDetailRecvDataLst.Status == 1 {
-				status = "成功"
-			} else {
-				status = "失败"
-			}
-			recvData := model.RecvDataItem{
-				SerialOrderId: opData.SerialOrderOPDetailRecvDataLst.SerialOrderId,
-				ArtId:         opData.SerialOrderOPDetailRecvDataLst.SubArtId,
-				PO:            opData.SerialOrderOPDetailRecvDataLst.PO,
-				OperationDesc: operationDesc,
-				RecvData:      opData.SerialOrderOPDetailRecvDataLst.RecvData,
-				Status:        status,
-				Remark1:       opData.SerialOrderOPDetailRecvDataLst.Remark1,
-				ExecuteTime:   opData.SerialOrderOPDetailRecvDataLst.CreateTime.ToString(),
-			}
-			poOperationData.RecvDataLi = append(poOperationData.RecvDataLi, recvData)
+		if !exist {
+			continue
 		}
-		result.TraceDataTraceData = append(result.TraceDataTraceData, poOperationData)
+		result.POLi[poIndex].StepLi[stepIndex].RecvDataLi = append(result.POLi[poIndex].StepLi[stepIndex].RecvDataLi, recvData)
 	}
-	if needEOL {
+	for _, poData := range result.POLi {
 		var poOperationData model.POOperationData
-		poOperationData.PO = "电检"
-		poOperationData.Status = "成功"
-		poOperationData.RecvDataLi = make([]model.RecvDataItem, 0)
-		eolEngine := db.Eloquent.Slaves()[0]
-		eolSession := eolEngine.NewSession()
-		eolResult, err := eolSession.SQL(fmt.Sprintf(`select * from Test_Data where 条码 = '%s' order by 测试完成日期, 测试完成时间`, serialOrderId)).QueryString()
-		if err != nil {
-			return nil, grmi.NewBusinessError("查询电检结果失败, error:" + err.Error())
+		poOperationData.PO = poData.PO
+		poOperationData.Status = poData.PoStatus
+		if poData.PoStatus == "失败" {
+			totalResult.Status = false
 		}
-		if len(eolResult) == 0 {
-			recvData := model.RecvDataItem{
-				SerialOrderId: serialOrderId,
-				ArtId:         "",
-				PO:            "EOL",
-				OperationDesc: "电检",
-				RecvData:      "",
-				Status:        "失败",
-				Remark1:       "未查询到电检数据",
-			}
-			poOperationData.RecvDataLi = append(poOperationData.RecvDataLi, recvData)
-		} else {
-			for _, opData := range eolResult {
-				var executeTime time.Time
-				executeTimeStr := opData["测试完成日期"] + " " + opData["测试完成时间"]
-				executeTime, err = time.ParseInLocation(executeTimeStr, grmi.DateTimeOutFormat, utils.TimezoneLocation)
-				if err != nil {
-					executeTime = time.Time{}
-				}
+		for _, stepData := range poData.StepLi {
+			for _, recvItem := range stepData.RecvDataLi {
 				var status string
-				var remark string
-				operateResult, exists := opData["测试结果(P/F)"]
-				if !exists {
-					status = "失败"
-					poOperationData.Status = "失败"
-					remark = "未获取到检测结果"
+				if recvItem.Status == 1 {
+					status = "成功"
 				} else {
-					if operateResult == "P" {
-						status = "成功"
-					} else {
-						status = "失败"
-						poOperationData.Status = "失败"
-						remark = "检测结果未通过"
-					}
+					status = "失败"
 				}
 				recvData := model.RecvDataItem{
-					SerialOrderId: serialOrderId,
-					ArtId:         "",
-					PO:            "EOL",
-					OperationDesc: "电检",
-					RecvData:      operateResult,
+					SerialOrderId: recvItem.SerialOrderId,
+					ArtId:         recvItem.SubArtId,
+					PO:            recvItem.PO,
+					OperationDesc: stepData.StepDesc,
+					RecvData:      recvItem.RecvData,
 					Status:        status,
-					Remark1:       remark,
-					ExecuteTime:   executeTime.Format(grmi.DateTimeOutFormat),
+					Remark1:       recvItem.Remark1,
+					ExecuteTime:   recvItem.CreateTime.ToString(),
 				}
 				poOperationData.RecvDataLi = append(poOperationData.RecvDataLi, recvData)
 			}
 		}
-		result.TraceDataTraceData = append(result.TraceDataTraceData, poOperationData)
+		totalResult.TraceDataTraceData = append(totalResult.TraceDataTraceData, poOperationData)
 	}
-	if needSBR {
+	if needEOL {
+		var poOperationData model.POOperationData
+		poOperationData.PO = "电检"
+		// 电检 主驾和副驾需要查询EOLDR 和 EOLPA 两张表 后排 查询EOLBR
+		eolStatus, remark, recordTime, err := impl.ExtractEOL(session, user, serialOrder)
+		if err != nil {
+			return nil, err
+		}
+		if eolStatus {
+			poOperationData.Status = "成功"
+		} else {
+			poOperationData.Status = "失败"
+			totalResult.Status = false
+		}
+		recvData := model.RecvDataItem{
+			SerialOrderId: serialOrderId,
+			ArtId:         "",
+			PO:            "EOL",
+			OperationDesc: "电检",
+			Status:        poOperationData.Status,
+			RecvData:      "",
+			Remark1:       remark,
+			ExecuteTime:   recordTime.Format(grmi.DateTimeOutFormat),
+		}
 
+		poOperationData.RecvDataLi = append(poOperationData.RecvDataLi, recvData)
+		totalResult.TraceDataTraceData = append(totalResult.TraceDataTraceData, poOperationData)
+		if eolStatus {
+			serialOrder.EOLCheck = model.EOL_STATUS_OK
+		} else {
+			serialOrder.EOLCheck = model.EOL_STATUS_NG
+		}
+		err = serialOrderDao.UpdateOne(serialOrder)
+		if err != nil {
+			return nil, grmi.NewBusinessError("将电检结果保存到工单上失败, 错误:" + err.Error())
+		}
 	}
-	return result, nil
+	return totalResult, nil
 }
 
 /******************************************************************************