chore: 初始开源发布

iotlcm-worker-svr：异步执行中枢（RabbitMQ 消费者 + 全量同步编排）。 - Go module：iotlcm-worker-svr → git.5iot.com/iotlcm-public/iotlcm-worker-svr（214 文件） - 凭据与内部标识脱敏：MySQL/Redis 凭据、私网与生产 IP、内网域名、库名 xiujie_admin → iotlcm、哨兵名占位 - 159 处真实手机号 → 合法 11 位编造号（保留号段与后 4 位，维持互异，不破坏「校验 MSISDN 格式」等测试断言） - 移除内部资产：CI 触发器、Jenkins 触发测试文档、预演门禁与镜像 digest 记录 - Dockerfile 改用公共基础镜像（golang:1.25-alpine → alpine:3.23），移除写死的 git 凭据 - README 重写（架构/全量同步模型/配置/已知失败），补 Apache-2.0 LICENSE，LF 行尾 + .gitattributes 已知：3 个测试包在源仓同一提交上同样失败（client/upstream、 service/allocate、service/inbound），属既有缺陷，本仓未引入亦未修复。
2026-10-22 16:37:56 +08:00
commit 2bec257289
361 changed files with 71524 additions and 0 deletions
@@ -0,0 +1,865 @@
+package inbound
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/encoding/gjson"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gtime"
+
+	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/consts"
+	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/dao"
+	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model/do"
+	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model/entity"
+	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/service/batchresult"
+	inbound "git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/service/inbound"
+)
+
+const stockTable = "t_sim_card_stock"
+const (
+	inboundStockQueryBatchSizeConfigKey = "batch.inbound.stockQueryBatchSize"
+	inboundWriteBatchSizeConfigKey      = "batch.inbound.writeBatchSize"
+	defaultInboundStockQueryBatchSize   = 1000
+	defaultInboundWriteBatchSize        = 1000
+)
+
+type Repository struct {
+	db          gdb.DB
+	resultFiles batchresult.Generator
+}
+
+type stockDO struct {
+	g.Meta      `orm:"table:t_sim_card_stock, do:true"`
+	BatchNo     any `orm:"batch_no"`
+	ICCID       any `orm:"iccid"`
+	MSISDN      any `orm:"msisdn"`
+	IMSI        any `orm:"imsi"`
+	IMEI        any `orm:"imei"`
+	ChanKey     any `orm:"chan_key"`
+	TenantID    any `orm:"tenant_id"`
+	CreatedDept any `orm:"created_dept"`
+	CreatedBy   any `orm:"created_by"`
+	UpdatedBy   any `orm:"updated_by"`
+}
+
+func New() *Repository {
+	return &Repository{db: dao.BatchMain.DB(), resultFiles: batchresult.New()}
+}
+
+func (r *Repository) database() gdb.DB {
+	if r.db != nil {
+		return r.db
+	}
+	return g.DB()
+}
+
+func (r *Repository) Load(ctx context.Context, batchNo string) (*inbound.Task, error) {
+	if batchNo == "" {
+		return nil, gerror.New("inbound batch number is empty")
+	}
+	var batch entity.BatchMain
+	if err := r.database().Model(dao.BatchMain.Table()).Safe().Ctx(ctx).
+		Where(dao.BatchMain.Columns().BatchNo, batchNo).
+		Where(dao.BatchMain.Columns().BatchType, consts.BatchTypeInbound).
+		Where(dao.BatchMain.Columns().BatchAsyncStatus, consts.BatchAsyncStatusProcessing).
+		Scan(&batch); err != nil {
+		return nil, gerror.Wrap(err, "query inbound batch")
+	}
+	if batch.Id == 0 {
+		return nil, gerror.New("processing inbound batch does not exist")
+	}
+	task := &inbound.Task{
+		Batch: inbound.Batch{
+			ID:          batch.Id,
+			BatchNo:     batch.BatchNo,
+			BatchType:   batch.BatchType,
+			SourceType:  batch.SourceType,
+			TenantID:    batch.TenantId,
+			CreatedDept: batch.CreatedDept,
+			CreatedBy:   batch.CreatedBy,
+			StartTime:   batch.StartTime,
+			BatchInfo:   batch.BatchInfo,
+		},
+	}
+	task.Source = parseSource(batch.BatchInfo, batch.SourceOssId, batch.SourceType)
+	task.Options = parseOptions(batch.BatchInfo)
+	return task, nil
+}
+
+func (r *Repository) ReadOssFile(ctx context.Context, ossID int64) ([]byte, string, error) {
+	if ossID <= 0 {
+		return nil, "", gerror.New("oss id is empty")
+	}
+	var oss entity.SysOss
+	if err := r.database().Model(dao.SysOss.Table()).Safe().Ctx(ctx).
+		Where(dao.SysOss.Columns().OssId, ossID).
+		Scan(&oss); err != nil {
+		return nil, "", gerror.Wrap(err, "query OSS file")
+	}
+	if oss.OssId == 0 {
+		return nil, "", gerror.Newf("OSS file %d does not exist", ossID)
+	}
+	if oss.Service != "local" {
+		return nil, "", gerror.Newf("OSS file %d is not a local file: service=%q", ossID, oss.Service)
+	}
+	uploadRoot := g.Cfg().MustGet(ctx, "system.upload.local.path").String()
+	localPath, attempts, err := resolveReadableLocalOssPath(uploadRoot, oss.TenantId, oss.Path)
+	if err != nil {
+		return nil, fileDisplayName(oss, ""), gerror.Wrapf(err, "resolve OSS file %d local path from %q, attempted paths: %s", ossID, oss.Path, strings.Join(attempts, "; "))
+	}
+	content, err := os.ReadFile(localPath)
+	if err != nil {
+		return nil, fileDisplayName(oss, localPath), gerror.Wrapf(err, "OSS file %d local path is unreadable: original path=%q, resolved path=%q", ossID, oss.Path, localPath)
+	}
+	return content, fileDisplayName(oss, localPath), nil
+}
+
+func resolveLocalOssPath(uploadRoot, tenantID, storedPath string) (string, error) {
+	uploadRoot = strings.TrimSpace(uploadRoot)
+	if uploadRoot == "" {
+		return "", gerror.New("system.upload.local.path is empty")
+	}
+	tenantID = strings.TrimSpace(tenantID)
+	if tenantID == "" {
+		tenantID = "default"
+	}
+	storedPath = strings.TrimSpace(storedPath)
+	if storedPath == "" {
+		return "", gerror.New("OSS path is empty")
+	}
+
+	objectSegments, err := ossObjectSegments(tenantID, storedPath)
+	if err != nil {
+		return "", err
+	}
+	objectPath := filepath.Join(objectSegments...)
+	localPath := filepath.Join(uploadRoot, objectPath)
+	relativePath, err := filepath.Rel(uploadRoot, localPath)
+	if err != nil {
+		return "", gerror.Wrap(err, "resolve local OSS path")
+	}
+	if relativePath == ".." || strings.HasPrefix(relativePath, ".."+string(filepath.Separator)) {
+		return "", gerror.New("resolved OSS path escapes upload root")
+	}
+	return localPath, nil
+}
+
+func resolveReadableLocalOssPath(uploadRoot, tenantID, storedPath string) (string, []string, error) {
+	var attempts []string
+	var firstErr error
+	for _, root := range uploadRootCandidates(uploadRoot) {
+		localPath, err := resolveLocalOssPath(root, tenantID, storedPath)
+		if err != nil {
+			if firstErr == nil {
+				firstErr = err
+			}
+			continue
+		}
+		attempts = appendUniqueString(attempts, localPath)
+		if isReadableFile(localPath) {
+			return localPath, attempts, nil
+		}
+	}
+
+	if _, err := ossObjectSegments(strings.TrimSpace(defaultTenant(tenantID)), storedPath); err != nil {
+		if firstErr == nil {
+			firstErr = err
+		}
+	} else {
+		for _, candidate := range storedPathCandidates(storedPath) {
+			attempts = appendUniqueString(attempts, candidate)
+			if isReadableFile(candidate) {
+				return candidate, attempts, nil
+			}
+		}
+	}
+	if firstErr != nil && len(attempts) == 0 {
+		return "", attempts, firstErr
+	}
+	return "", attempts, gerror.New("OSS local file does not exist")
+}
+
+func uploadRootCandidates(uploadRoot string) []string {
+	var candidates []string
+	for _, root := range []string{
+		os.Getenv("IOTLCM_WORKER_UPLOAD_ROOT"),
+		os.Getenv("IOTLCM_UPLOAD_ROOT"),
+		uploadRoot,
+	} {
+		root = strings.TrimSpace(root)
+		if root == "" {
+			continue
+		}
+		candidates = appendUploadRootCandidate(candidates, root)
+	}
+	return candidates
+}
+
+func appendUploadRootCandidate(candidates []string, root string) []string {
+	for _, candidate := range uploadRootEquivalentCandidates(root) {
+		if filepath.IsAbs(candidate) {
+			candidates = appendUniqueString(candidates, candidate)
+		} else {
+			for _, base := range localBaseDirs() {
+				candidates = appendUniqueString(candidates, filepath.Join(base, candidate))
+			}
+			candidates = appendUniqueString(candidates, candidate)
+		}
+	}
+	return candidates
+}
+
+func uploadRootEquivalentCandidates(root string) []string {
+	root = strings.TrimSpace(root)
+	if root == "" {
+		return nil
+	}
+	candidates := []string{root}
+	normalized := filepath.ToSlash(filepath.Clean(root))
+	if normalized == "resource/upload" || strings.HasSuffix(normalized, "/resource/upload") {
+		prefix := strings.TrimSuffix(normalized, "resource/upload")
+		candidates = appendUniqueString(candidates, filepath.FromSlash(prefix+"upload"))
+	}
+	return candidates
+}
+
+func storedPathCandidates(storedPath string) []string {
+	storedPath = strings.TrimSpace(storedPath)
+	if storedPath == "" {
+		return nil
+	}
+	var candidates []string
+	candidates = appendUniqueString(candidates, storedPath)
+	if !filepath.IsAbs(storedPath) {
+		for _, base := range localBaseDirs() {
+			candidates = appendUniqueString(candidates, filepath.Join(base, storedPath))
+		}
+	}
+	return candidates
+}
+
+func localBaseDirs() []string {
+	var dirs []string
+	if wd, err := os.Getwd(); err == nil && strings.TrimSpace(wd) != "" {
+		dirs = appendUniqueString(dirs, wd)
+	}
+	if exe, err := os.Executable(); err == nil && strings.TrimSpace(exe) != "" {
+		dirs = appendUniqueString(dirs, filepath.Dir(exe))
+	}
+	return dirs
+}
+
+func ossObjectSegments(tenantID, storedPath string) ([]string, error) {
+	tenantID = defaultTenant(tenantID)
+	segments := strings.FieldsFunc(strings.ReplaceAll(storedPath, "\\", "/"), func(r rune) bool {
+		return r == '/'
+	})
+	for index, segment := range segments {
+		if segment != tenantID {
+			continue
+		}
+		objectSegments := segments[index:]
+		for _, objectSegment := range objectSegments {
+			if objectSegment == "." || objectSegment == ".." {
+				return nil, gerror.Newf("invalid OSS object path segment %q", objectSegment)
+			}
+		}
+		return objectSegments, nil
+	}
+	return nil, gerror.Newf("OSS path does not contain tenant %q", tenantID)
+}
+
+func defaultTenant(tenantID string) string {
+	tenantID = strings.TrimSpace(tenantID)
+	if tenantID == "" {
+		return "default"
+	}
+	return tenantID
+}
+
+func isReadableFile(path string) bool {
+	info, err := os.Stat(path)
+	return err == nil && !info.IsDir()
+}
+
+func appendUniqueString(values []string, value string) []string {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return values
+	}
+	for _, existing := range values {
+		if existing == value {
+			return values
+		}
+	}
+	return append(values, value)
+}
+
+func uniqueStrings(values []string) []string {
+	if len(values) == 0 {
+		return nil
+	}
+	uniq := make([]string, 0, len(values))
+	seen := make(map[string]struct{}, len(values))
+	for _, value := range values {
+		value = strings.TrimSpace(value)
+		if value == "" {
+			continue
+		}
+		if _, ok := seen[value]; ok {
+			continue
+		}
+		seen[value] = struct{}{}
+		uniq = append(uniq, value)
+	}
+	return uniq
+}
+
+func (r *Repository) FindExistingStocks(ctx context.Context, _ string, iccids, msisdns, imsis []string) ([]inbound.Stock, error) {
+	if len(iccids) == 0 && len(msisdns) == 0 && len(imsis) == 0 {
+		return nil, nil
+	}
+	type queryResult struct {
+		stocks []inbound.Stock
+		err    error
+	}
+	results := make(chan queryResult, 3)
+	queries := 0
+	if len(iccids) > 0 {
+		queries++
+		go func() {
+			stocks, err := r.findExistingStocksByField(ctx, "iccid", "ICCID", iccids)
+			results <- queryResult{stocks: stocks, err: err}
+		}()
+	}
+	if len(msisdns) > 0 {
+		queries++
+		go func() {
+			stocks, err := r.findExistingStocksByField(ctx, "msisdn", "MSISDN", msisdns)
+			results <- queryResult{stocks: stocks, err: err}
+		}()
+	}
+	if len(imsis) > 0 {
+		queries++
+		go func() {
+			stocks, err := r.findExistingStocksByField(ctx, "imsi", "IMSI", imsis)
+			results <- queryResult{stocks: stocks, err: err}
+		}()
+	}
+	stocks := make([]inbound.Stock, 0)
+	for i := 0; i < queries; i++ {
+		result := <-results
+		if result.err != nil {
+			return nil, result.err
+		}
+		stocks = append(stocks, result.stocks...)
+	}
+	return stocks, nil
+}
+
+func (r *Repository) stockQuery(ctx context.Context) *gdb.Model {
+	return r.database().Model(stockTable).Safe().Ctx(ctx)
+}
+
+func (r *Repository) findExistingStocksByField(ctx context.Context, field, label string, values []string) ([]inbound.Stock, error) {
+	uniq := uniqueStrings(values)
+	if len(uniq) == 0 {
+		return nil, nil
+	}
+	batchSize := inboundStockQueryBatchSize(ctx)
+	stocks := make([]inbound.Stock, 0)
+	for _, chunk := range chunkStrings(uniq, batchSize) {
+		var chunkStocks []inbound.Stock
+		model := r.stockQuery(ctx).WhereIn(field, chunk)
+		if err := model.Fields("iccid", "msisdn", "imsi").Scan(&chunkStocks); err != nil {
+			return nil, gerror.Wrapf(err, "query inbound stock %s duplicates", label)
+		}
+		stocks = append(stocks, chunkStocks...)
+	}
+	return stocks, nil
+}
+
+func (r *Repository) SaveValidationFailure(ctx context.Context, task *inbound.Task) error {
+	return r.database().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+		batchInfo := buildInboundBatchInfo(task)
+		task.Batch.BatchInfo = batchInfo
+		details := buildBatchDetails(task, consts.BatchDetailStatusFailed)
+		if err := insertChunkedRows(ctx, tx, dao.BatchDetail.Table(), "inbound detail", details, inboundWriteBatchSize(ctx)); err != nil {
+			return err
+		}
+		return updateBatchMain(ctx, tx, task, do.BatchMain{
+			BatchAsyncStatus: consts.BatchAsyncStatusFailed,
+			TotalCount:       len(task.Rows),
+			ValidCount:       task.ValidCount,
+			SuccessCount:     0,
+			FailCount:        len(task.Rows),
+			RunResult:        consts.BatchRunResultFailed,
+			FailReason:       task.FailureReason,
+			BatchInfo:        batchInfo,
+			EndTime:          gtime.Now(),
+			UpdatedBy:        task.Batch.CreatedBy,
+		})
+	})
+}
+
+func (r *Repository) SaveSuccess(ctx context.Context, task *inbound.Task) error {
+	return r.database().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+		batchInfo := buildInboundBatchInfo(task)
+		task.Batch.BatchInfo = batchInfo
+		stocks := make([]stockDO, 0, len(task.Rows))
+		details := make([]do.BatchDetail, 0, len(task.Rows))
+		for _, row := range task.Rows {
+			if row == nil {
+				continue
+			}
+			stocks = append(stocks, stockDO{
+				BatchNo:     task.Batch.BatchNo,
+				ICCID:       row.ICCID,
+				MSISDN:      nullableString(row.MSISDN),
+				IMSI:        nullableString(row.IMSI),
+				IMEI:        nullableString(row.IMEI),
+				ChanKey:     row.ChanKey,
+				TenantID:    task.Batch.TenantID,
+				CreatedDept: task.Batch.CreatedDept,
+				CreatedBy:   task.Batch.CreatedBy,
+				UpdatedBy:   task.Batch.CreatedBy,
+			})
+			details = append(details, batchDetailRow(task, row, consts.BatchDetailStatusSuccess))
+		}
+		if err := insertChunkedRows(ctx, tx, stockTable, "inbound stock", stocks, inboundWriteBatchSize(ctx)); err != nil {
+			return err
+		}
+		if err := insertChunkedRows(ctx, tx, dao.BatchDetail.Table(), "inbound detail", details, inboundWriteBatchSize(ctx)); err != nil {
+			return err
+		}
+		return updateBatchMain(ctx, tx, task, do.BatchMain{
+			BatchAsyncStatus: consts.BatchAsyncStatusSuccess,
+			TotalCount:       len(task.Rows),
+			ValidCount:       len(task.Rows),
+			SuccessCount:     len(task.Rows),
+			FailCount:        0,
+			RunResult:        consts.BatchRunResultSuccess,
+			FailReason:       "",
+			BatchInfo:        batchInfo,
+			EndTime:          gtime.Now(),
+			UpdatedBy:        task.Batch.CreatedBy,
+		})
+	})
+}
+
+func (r *Repository) SaveBusinessFailure(ctx context.Context, task *inbound.Task, reason string) error {
+	task.ValidCount = countRowsWithoutReason(task.Rows)
+	for _, row := range task.Rows {
+		if row != nil {
+			row.Reason = reason
+		}
+	}
+	task.FailureReason = reason
+	return r.SaveValidationFailure(ctx, task)
+}
+
+func buildBatchDetails(task *inbound.Task, status int) []do.BatchDetail {
+	details := make([]do.BatchDetail, 0, len(task.Rows))
+	for _, row := range task.Rows {
+		if row == nil {
+			continue
+		}
+		details = append(details, batchDetailRow(task, row, status))
+	}
+	return details
+}
+
+func batchDetailRow(task *inbound.Task, row *inbound.Row, status int) do.BatchDetail {
+	return do.BatchDetail{
+		BatchNo:        task.Batch.BatchNo,
+		BatchType:      task.Batch.BatchType,
+		DetailStatus:   status,
+		BlankOutStatus: 1,
+		RowNo:          row.RowNo,
+		ItemId:         row.ICCID,
+		ErrorReason:    row.Reason,
+		Snapshot:       rowSnapshot(row),
+		TenantId:       task.Batch.TenantID,
+		CreatedDept:    task.Batch.CreatedDept,
+		CreatedBy:      task.Batch.CreatedBy,
+		UpdatedBy:      task.Batch.CreatedBy,
+	}
+}
+
+func (r *Repository) SaveResultFile(ctx context.Context, task *inbound.Task, request batchresult.Request) error {
+	artifact, err := r.artifactGenerator().Create(ctx, request)
+	if err != nil {
+		return r.updateResultFileStatus(ctx, task, "failed", 0, 0, err.Error())
+	}
+	var (
+		ossID      int64
+		downloadID int64
+	)
+	err = r.database().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+		var insertErr error
+		ossID, insertErr = tx.Ctx(ctx).Model(dao.SysOss.Table()).Data(do.SysOss{
+			TenantId:     task.Batch.TenantID,
+			FileName:     artifact.FileName,
+			OriginalName: artifact.OriginalName,
+			FileSuffix:   artifact.FileSuffix,
+			Path:         artifact.Path,
+			Url:          artifact.URL,
+			CreatedDept:  task.Batch.CreatedDept,
+			CreatedBy:    task.Batch.CreatedBy,
+			UpdatedBy:    task.Batch.CreatedBy,
+			Service:      "local",
+			Md5:          artifact.MD5,
+			FileSize:     artifact.Size,
+		}).InsertAndGetId()
+		if insertErr != nil {
+			return gerror.Wrap(insertErr, "insert inbound result OSS")
+		}
+		downloadID, insertErr = tx.Ctx(ctx).Model(dao.TResourceBatchDownload.Table()).Data(do.TResourceBatchDownload{
+			BatchNo:          task.Batch.BatchNo,
+			TaskName:         batchresult.TaskName(task.Batch.BatchType),
+			ResourceType:     consts.ResourceTypeExcel,
+			ExportScene:      task.Batch.BatchType,
+			TotalCount:       len(task.Rows),
+			SuccessCount:     successRows(task.Rows),
+			FailCount:        len(task.Rows) - successRows(task.Rows),
+			DownloadStatus:   consts.DownloadStatusGenerated,
+			OssId:            ossID,
+			FileName:         artifact.FileName,
+			FileExt:          artifact.FileSuffix,
+			FileUrl:          artifact.URL,
+			FilePath:         artifact.Path,
+			FileSize:         artifact.Size,
+			FileMd5:          artifact.MD5,
+			DownloadCount:    0,
+			MaxDownloadCount: 0,
+			DeptId:           task.Batch.CreatedDept,
+			StartTime:        task.Batch.StartTime,
+			FinishTime:       gtime.Now(),
+			TenantId:         task.Batch.TenantID,
+			CreatedDept:      task.Batch.CreatedDept,
+			CreatedBy:        task.Batch.CreatedBy,
+			UpdatedBy:        task.Batch.CreatedBy,
+		}).InsertAndGetId()
+		if insertErr != nil {
+			return gerror.Wrap(insertErr, "insert inbound result download")
+		}
+		return updateBatchInfoOnly(ctx, tx, task, buildResultBatchInfo(task, "success", ossID, downloadID, ""), ossID)
+	})
+	if err != nil {
+		batchresult.RemoveLocalFile(artifact)
+		return r.updateResultFileStatus(ctx, task, "failed", 0, 0, err.Error())
+	}
+	return nil
+}
+
+func (r *Repository) artifactGenerator() batchresult.Generator {
+	if r.resultFiles != nil {
+		return r.resultFiles
+	}
+	return batchresult.New()
+}
+
+func (r *Repository) updateResultFileStatus(ctx context.Context, task *inbound.Task, status string, ossID, downloadID int64, reason string) error {
+	return r.database().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+		return updateBatchInfoOnly(ctx, tx, task, buildResultBatchInfo(task, status, ossID, downloadID, reason), ossID)
+	})
+}
+
+func insertChunkedRows[T any](ctx context.Context, tx gdb.TX, table, label string, rows []T, batchSize int) error {
+	if len(rows) == 0 {
+		return nil
+	}
+	if batchSize <= 0 {
+		batchSize = defaultInboundWriteBatchSize
+	}
+	for start := 0; start < len(rows); start += batchSize {
+		end := start + batchSize
+		if end > len(rows) {
+			end = len(rows)
+		}
+		if _, err := tx.Ctx(ctx).Model(table).Data(rows[start:end]).Insert(); err != nil {
+			return gerror.Wrapf(err, "insert %s chunk", label)
+		}
+	}
+	return nil
+}
+
+func chunkStrings(values []string, batchSize int) [][]string {
+	if batchSize <= 0 {
+		batchSize = defaultInboundStockQueryBatchSize
+	}
+	if len(values) == 0 {
+		return nil
+	}
+	chunks := make([][]string, 0, (len(values)+batchSize-1)/batchSize)
+	for start := 0; start < len(values); start += batchSize {
+		end := start + batchSize
+		if end > len(values) {
+			end = len(values)
+		}
+		chunks = append(chunks, values[start:end])
+	}
+	return chunks
+}
+
+func inboundStockQueryBatchSize(ctx context.Context) int {
+	value := g.Cfg().MustGet(ctx, inboundStockQueryBatchSizeConfigKey, defaultInboundStockQueryBatchSize).Int()
+	if value <= 0 {
+		return defaultInboundStockQueryBatchSize
+	}
+	return value
+}
+
+func inboundWriteBatchSize(ctx context.Context) int {
+	value := g.Cfg().MustGet(ctx, inboundWriteBatchSizeConfigKey, defaultInboundWriteBatchSize).Int()
+	if value <= 0 {
+		return defaultInboundWriteBatchSize
+	}
+	return value
+}
+
+func updateBatchMain(ctx context.Context, tx gdb.TX, task *inbound.Task, data do.BatchMain) error {
+	result, err := tx.Ctx(ctx).Model(dao.BatchMain.Table()).
+		Where(dao.BatchMain.Columns().BatchNo, task.Batch.BatchNo).
+		Where(dao.BatchMain.Columns().BatchType, task.Batch.BatchType).
+		Where(dao.BatchMain.Columns().BatchAsyncStatus, consts.BatchAsyncStatusProcessing).
+		Data(data).
+		Update()
+	if err != nil {
+		return gerror.Wrap(err, "update inbound batch main")
+	}
+	affected, err := result.RowsAffected()
+	if err != nil {
+		return gerror.Wrap(err, "read inbound batch main update result")
+	}
+	if affected != 1 {
+		return gerror.New("inbound batch is no longer processing")
+	}
+	return nil
+}
+
+func updateBatchInfoOnly(ctx context.Context, tx gdb.TX, task *inbound.Task, info *gjson.Json, resultOssID int64) error {
+	result, err := tx.Ctx(ctx).Model(dao.BatchMain.Table()).
+		Where(dao.BatchMain.Columns().BatchNo, task.Batch.BatchNo).
+		Where(dao.BatchMain.Columns().BatchType, task.Batch.BatchType).
+		Data(do.BatchMain{
+			ResultOssId: workerOssIDValue(resultOssID),
+			BatchInfo:   info,
+			UpdatedBy:   task.Batch.CreatedBy,
+		}).
+		Update()
+	if err != nil {
+		return gerror.Wrap(err, "update inbound result file status")
+	}
+	affected, err := result.RowsAffected()
+	if err != nil {
+		return gerror.Wrap(err, "read inbound result file update result")
+	}
+	if affected != 1 {
+		return gerror.New("inbound batch disappeared while saving result file")
+	}
+	task.Batch.BatchInfo = info
+	return nil
+}
+
+func workerOssIDValue(ossID int64) any {
+	if ossID <= 0 {
+		return nil
+	}
+	return ossID
+}
+
+func parseSource(info *gjson.Json, sourceOssID int64, sourceType int) inbound.Source {
+	source := inbound.Source{
+		ImportFileOssID: jsonInt64(info, "source.importFileOssId", "importFileOssId"),
+		InputText:       jsonString(info, "source.inputText", "inputText"),
+		InputFileOssID:  jsonInt64(info, "source.inputFileOssId", "inputFileOssId"),
+		Range: inbound.Range{
+			RangeType:   jsonString(info, "source.range.rangeType", "range.rangeType", "rangeType"),
+			StartICCID:  jsonString(info, "source.range.startIccid", "range.startIccid", "startIccid"),
+			EndICCID:    jsonString(info, "source.range.endIccid", "range.endIccid", "endIccid"),
+			StartMSISDN: jsonString(info, "source.range.startMsisdn", "range.startMsisdn", "startMsisdn"),
+			EndMSISDN:   jsonString(info, "source.range.endMsisdn", "range.endMsisdn", "endMsisdn"),
+			StartIMSI:   jsonString(info, "source.range.startImsi", "range.startImsi", "startImsi"),
+			EndIMSI:     jsonString(info, "source.range.endImsi", "range.endImsi", "endImsi"),
+		},
+	}
+	if sourceOssID > 0 {
+		switch sourceType {
+		case consts.BatchSourceTypeBatchInput:
+			source.InputFileOssID = sourceOssID
+		default:
+			source.ImportFileOssID = sourceOssID
+		}
+	}
+	return source
+}
+
+func parseOptions(info *gjson.Json) inbound.Options {
+	return inbound.Options{
+		ChanKey:                      jsonString(info, "inboundOptions.chanKey", "chanKey"),
+		ValidateUpstreamBasicInfo:    jsonString(info, "inboundOptions.validateUpstreamBasicInfo", "validateUpstreamBasicInfo"),
+		CardType:                     jsonString(info, "inboundOptions.cardType", "cardType"),
+		UpPkgCode:                    jsonString(info, "inboundOptions.upPkgCode", "upPkgCode"),
+		SuppliersCode:                jsonString(info, "inboundOptions.suppliersCode", "suppliersCode"),
+		UpstreamActivationTime:       jsonString(info, "inboundOptions.upstreamActivationTime", "upstreamActivationTime"),
+		InsertToPlugEnabled:          jsonString(info, "inboundOptions.insertToPlugEnabled", "insertToPlugEnabled"),
+		CarrierTrafficCutoffEnabled:  jsonString(info, "inboundOptions.carrierTrafficCutoffEnabled", "carrierTrafficCutoffEnabled"),
+		AgreementExpiryDate:          jsonString(info, "inboundOptions.agreementExpiryDate", "agreementExpiryDate"),
+		HasTestPeriod:                jsonString(info, "inboundOptions.hasTestPeriod", "hasTestPeriod"),
+		TestPeriodDays:               jsonString(info, "inboundOptions.testPeriodDays", "testPeriodDays"),
+		TestPeriodLatestExpiryDate:   jsonString(info, "inboundOptions.testPeriodLatestExpiryDate", "testPeriodLatestExpiryDate"),
+		HasSilentPeriod:              jsonString(info, "inboundOptions.hasSilentPeriod", "hasSilentPeriod"),
+		SilentPeriodDays:             jsonString(info, "inboundOptions.silentPeriodDays", "silentPeriodDays"),
+		SilentPeriodLatestExpiryDate: jsonString(info, "inboundOptions.silentPeriodLatestExpiryDate", "silentPeriodLatestExpiryDate"),
+	}
+}
+
+func jsonString(info *gjson.Json, paths ...string) string {
+	if info == nil {
+		return ""
+	}
+	for _, path := range paths {
+		value := strings.TrimSpace(info.Get(path).String())
+		if value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
+func jsonInt64(info *gjson.Json, paths ...string) int64 {
+	if info == nil {
+		return 0
+	}
+	for _, path := range paths {
+		value := info.Get(path).Int64()
+		if value > 0 {
+			return value
+		}
+	}
+	return 0
+}
+
+func rowSnapshot(row *inbound.Row) *gjson.Json {
+	raw := map[string]any{}
+	for key, value := range row.Raw {
+		raw[key] = value
+	}
+	return gjson.New(map[string]any{
+		"rowNo":                        row.RowNo,
+		"inputCode":                    row.InputCode,
+		"ICCID":                        row.ICCID,
+		"MSISDN":                       row.MSISDN,
+		"IMSI":                         row.IMSI,
+		"IMEI":                         row.IMEI,
+		"chanKey":                      row.ChanKey,
+		"cardType":                     row.CardType,
+		"upPkgCode":                    row.UpPkgCode,
+		"suppliersCode":                row.SuppliersCode,
+		"upstreamActivationTime":       row.UpstreamActivationTime,
+		"insertToPlugEnabled":          row.InsertToPlugEnabled,
+		"carrierTrafficCutoffEnabled":  row.CarrierTrafficCutoffEnabled,
+		"agreementExpiryDate":          row.AgreementExpiryDate,
+		"hasTestPeriod":                row.HasTestPeriod,
+		"testPeriodDays":               row.TestPeriodDays,
+		"testPeriodLatestExpiryDate":   row.TestPeriodLatestExpiryDate,
+		"hasSilentPeriod":              row.HasSilentPeriod,
+		"silentPeriodDays":             row.SilentPeriodDays,
+		"silentPeriodLatestExpiryDate": row.SilentPeriodLatestExpiryDate,
+		"rawFields":                    raw,
+	})
+}
+
+func buildInboundBatchInfo(task *inbound.Task) *gjson.Json {
+	if task == nil {
+		return gjson.New(map[string]any{})
+	}
+	info := make(map[string]any)
+	if task != nil && task.Batch.BatchInfo != nil {
+		for key, value := range task.Batch.BatchInfo.Map() {
+			info[key] = value
+		}
+	}
+	info["inboundOptions"] = map[string]any{
+		"chanKey":                      task.Options.ChanKey,
+		"validateUpstreamBasicInfo":    task.Options.ValidateUpstreamBasicInfo,
+		"cardType":                     task.Options.CardType,
+		"upPkgCode":                    task.Options.UpPkgCode,
+		"suppliersCode":                task.Options.SuppliersCode,
+		"upstreamActivationTime":       task.Options.UpstreamActivationTime,
+		"insertToPlugEnabled":          task.Options.InsertToPlugEnabled,
+		"carrierTrafficCutoffEnabled":  task.Options.CarrierTrafficCutoffEnabled,
+		"agreementExpiryDate":          task.Options.AgreementExpiryDate,
+		"hasTestPeriod":                task.Options.HasTestPeriod,
+		"testPeriodDays":               task.Options.TestPeriodDays,
+		"testPeriodLatestExpiryDate":   task.Options.TestPeriodLatestExpiryDate,
+		"hasSilentPeriod":              task.Options.HasSilentPeriod,
+		"silentPeriodDays":             task.Options.SilentPeriodDays,
+		"silentPeriodLatestExpiryDate": task.Options.SilentPeriodLatestExpiryDate,
+	}
+	return gjson.New(info)
+}
+
+func buildResultBatchInfo(task *inbound.Task, status string, ossID, downloadID int64, reason string) *gjson.Json {
+	info := make(map[string]any)
+	if task.Batch.BatchInfo != nil {
+		for key, value := range task.Batch.BatchInfo.Map() {
+			info[key] = value
+		}
+	}
+	resultFile := map[string]any{"status": status}
+	if ossID > 0 {
+		resultFile["ossId"] = ossID
+	}
+	if downloadID > 0 {
+		resultFile["downloadId"] = downloadID
+	}
+	if reason != "" {
+		resultFile["error"] = reason
+	}
+	info["resultFile"] = resultFile
+	return gjson.New(info)
+}
+
+func fileDisplayName(oss entity.SysOss, fallback string) string {
+	for _, value := range []string{oss.OriginalName, oss.FileName, fallback} {
+		if strings.TrimSpace(value) != "" {
+			return strings.TrimSpace(value)
+		}
+	}
+	return "unknown"
+}
+
+func nullableString(value string) any {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return nil
+	}
+	return value
+}
+
+func countRowsWithoutReason(rows []*inbound.Row) int {
+	count := 0
+	for _, row := range rows {
+		if row != nil && row.Reason == "" {
+			count++
+		}
+	}
+	return count
+}
+
+func successRows(rows []*inbound.Row) int {
+	count := 0
+	for _, row := range rows {
+		if row != nil && row.Reason == "" {
+			count++
+		}
+	}
+	return count
+}