sync: 同步 v1.0.4 并脱敏配置与镜像

server/internal/logic/iot/simcardbatch/allocate/splitter.go

@@ -102,6 +102,7 @@ func createPendingSplit(
 	if err := createAllocateParent(ctx, req, p, parentBatchNo, importOss, chunkSize); err != nil {
 		return nil, err
 	}
+	children := make([]*batchimport.Result, 0)
 
 	if _, err := stream(ctx, func(rows []batchimport.Row) error {
 		if len(rows) == 0 {
@@ -115,16 +116,20 @@ func createPendingSplit(
 				return err
 			}
 		}
-		if err := markAllocateCrossChunkDuplicates(ctx, parentBatchNo, req.Operator.TenantId, rows); err != nil {
+		priorFailures, err := markAllocateCrossChunkDuplicates(ctx, parentBatchNo, req.Operator.TenantId, rows)
+		if err != nil {
 			return err
 		}
+		state.Valid -= priorFailures
+		state.Failed += priorFailures
 
 		state.ChunkCount++
 		result, err := createAllocateChunk(ctx, req, p, parentBatchNo, state.ChunkCount, rows, importOss, state)
 		if err != nil {
 			return err
 		}
-		return common.PublishBatchMessageStrict(ctx, result, consts.QueueBatchExecute, "allocate")
+		children = append(children, result)
+		return nil
 	}); err != nil {
 		markAllocateParentFailed(ctx, parentBatchNo, err.Error())
 		return nil, err
@@ -138,6 +143,12 @@ func createPendingSplit(
 		markAllocateParentFailed(ctx, parentBatchNo, err.Error())
 		return nil, err
 	}
+	for _, child := range children {
+		if err := common.PublishBatchMessageStrict(ctx, child, consts.QueueBatchExecute, "allocate"); err != nil {
+			markAllocateParentFailed(ctx, parentBatchNo, err.Error())
+			return nil, err
+		}
+	}
 
 	parentMessage := &batchimport.Result{
 		BatchNo:   parentBatchNo,
@@ -397,9 +408,9 @@ func countBatchRows(rows []batchimport.Row) (valid, failed int) {
 	return
 }
 
-func markAllocateCrossChunkDuplicates(ctx context.Context, parentBatchNo, tenantID string, rows []batchimport.Row) error {
+func markAllocateCrossChunkDuplicates(ctx context.Context, parentBatchNo, tenantID string, rows []batchimport.Row) (int, error) {
 	if strings.TrimSpace(parentBatchNo) == "" || len(rows) == 0 {
-		return nil
+		return 0, nil
 	}
 	columns := dao.BatchDetail.Columns()
 	itemIDs := make([]string, 0, len(rows))
@@ -420,24 +431,65 @@ func markAllocateCrossChunkDuplicates(ctx context.Context, parentBatchNo, tenant
 		itemIDs = append(itemIDs, itemID)
 	}
 	if len(itemIDs) == 0 {
-		return nil
+		return 0, nil
 	}
 
 	var existing []struct {
-		ItemId string `orm:"item_id"`
+		Id           int64  `orm:"id"`
+		BatchNo      string `orm:"batch_no"`
+		ItemId       string `orm:"item_id"`
+		DetailStatus int    `orm:"detail_status"`
 	}
 	query := g.DB().Model(dao.BatchDetail.Table()).
-		Fields(columns.ItemId).
+		Fields(columns.Id, columns.BatchNo, columns.ItemId, columns.DetailStatus).
 		Where(columns.BatchType, consts.BatchTypeAllocate).
 		Where(columns.TenantId, tenantID).
 		WhereIn(columns.ItemId, itemIDs).
 		Where("batch_no IN (SELECT batch_no FROM batch_main WHERE source_batch_no = ? AND batch_type = ? AND tenant_id = ?)",
 			parentBatchNo, consts.BatchTypeAllocate, tenantID)
 	if err := query.Scan(&existing); err != nil {
-		return gerror.Wrap(err, "check duplicate allocate ICCIDs across chunks failed")
+		return 0, gerror.Wrap(err, "check duplicate allocate ICCIDs across chunks failed")
 	}
 	if len(existing) == 0 {
+		return 0, nil
+	}
+
+	priorFailures := 0
+	err := g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+		for _, detail := range existing {
+			if detail.DetailStatus != consts.BatchDetailStatusPending {
+				continue
+			}
+			result, err := tx.Ctx(ctx).Model(dao.BatchDetail.Table()).
+				Where(columns.Id, detail.Id).
+				Where(columns.TenantId, tenantID).
+				Where(columns.DetailStatus, consts.BatchDetailStatusPending).
+				Data(do.BatchDetail{DetailStatus: consts.BatchDetailStatusFailed, ErrorReason: "ICCID在划拨批次内重复"}).Update()
+			if err != nil {
+				return gerror.Wrap(err, "mark prior duplicate allocation detail failed")
+			}
+			affected, err := result.RowsAffected()
+			if err != nil {
+				return err
+			}
+			if affected == 0 {
+				continue
+			}
+			priorFailures++
+			mainColumns := dao.BatchMain.Columns()
+			for _, batchNo := range []string{detail.BatchNo, parentBatchNo} {
+				if _, err := tx.Ctx(ctx).Model(dao.BatchMain.Table()).
+					Where(mainColumns.BatchNo, batchNo).
+					Where(mainColumns.TenantId, tenantID).
+					Data(do.BatchMain{ValidCount: gdb.Raw("valid_count - 1"), FailCount: gdb.Raw("fail_count + 1")}).Update(); err != nil {
+					return gerror.Wrap(err, "update cross-chunk duplicate counts failed")
+				}
+			}
+		}
 		return nil
+	})
+	if err != nil {
+		return 0, err
 	}
 
 	duplicates := make(map[string]struct{}, len(existing))
@@ -452,10 +504,10 @@ func markAllocateCrossChunkDuplicates(ctx context.Context, parentBatchNo, tenant
 			continue
 		}
 		if _, exists := duplicates[strings.TrimSpace(row.Iccid)]; exists {
-			row.AddErrorReason("ICCID appears in an earlier allocation chunk")
+			row.AddErrorReason("ICCID在划拨批次内重复")
 		}
 	}
-	return nil
+	return priorFailures, nil
 }
 
 func withAllocateInfo(info *gjson.Json, values map[string]any) *gjson.Json {