iotlcm/server/internal/logic/iot/simcardbatch/addpackage/processor.go

package addpackage

import (
	"context"
	"fmt"
	"strings"

	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/consts"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/batchimport"
	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"

	"github.com/gogf/gf/v2/encoding/gjson"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
)

type Processor struct {
	config  Config
	options SubmitOptions
}

func NewProcessor(operation Operation, options SubmitOptions) (*Processor, error) {
	cfg, err := operation.Config()
	if err != nil {
		return nil, err
	}
	options, err = normalizeOptions(options)
	if err != nil {
		return nil, err
	}
	return &Processor{config: cfg, options: options}, nil
}

func (p *Processor) Config() batchimport.ProcessorConfig {
	maxFileSize := consts.SimCardAddPackageMaxFileSize
	if p.config.Operation == OperationPool {
		maxFileSize = consts.SimPoolAddPackageMaxFileSize
	}
	return batchimport.ProcessorConfig{
		Code:            p.config.Code,
		BatchType:       p.config.BatchType,
		BatchNoPrefix:   p.config.BatchPrefix,
		TaskName:        p.config.TaskName,
		ExportScene:     p.config.ExportScene,
		ImportDir:       p.config.ImportDir,
		ResultDir:       p.config.ResultDir,
		MaxFileSize:     int64(maxFileSize),
		TemplateHeaders: p.TemplateHeaders(),
		RequiredHeaders: []string{p.config.TargetHeader, headerPackageCode},
	}
}

func (p *Processor) TemplateHeaders() []string {
	return []string{p.config.TargetHeader, headerPackageCode, headerRemark}
}

func (p *Processor) ParseRows(ctx context.Context, filePath string) ([]batchimport.Row, error) {
	return parseExcelRows(ctx, filePath, p.config, p.options)
}

func (p *Processor) ValidateRows(_ context.Context, rows []batchimport.Row) error {
	firstByTarget := make(map[string]*Row, len(rows))
	for _, item := range rows {
		row, ok := item.(*Row)
		if !ok || row == nil {
			return gerror.New("加油包批次行类型错误")
		}
		row.TargetCode = strings.TrimSpace(row.TargetCode)
		row.PackageCode = strings.TrimSpace(row.PackageCode)
		row.Remark = strings.TrimSpace(row.Remark)
		row.EffectiveMode = strings.TrimSpace(row.EffectiveMode)
		if row.TargetCode == "" {
			row.AddErrorReason(p.config.TargetLabel + "不能为空")
			continue
		}
		if first, exists := firstByTarget[row.TargetCode]; exists {
			row.AddErrorReason(fmt.Sprintf("%s与第%d行重复", p.config.TargetLabel, first.RowNo))
			first.AddErrorReason(p.config.TargetLabel + "重复")
			continue
		}
		firstByTarget[row.TargetCode] = row
		if row.PackageCode == "" {
			row.AddErrorReason("加油包编码不能为空")
			continue
		}
		if _, err := NormalizeEffectiveMode(row.EffectiveMode); err != nil {
			row.AddErrorReason(err.Error())
			continue
		}
	}
	return rowsValidationError(rows, "加油包批次基础校验失败")
}

func (p *Processor) BuildBatchInfo(_ context.Context, _ batchimport.SubmitRequest, result *batchimport.Result, importOss *model.SysOssSaveContentModel, resultOss *model.SysOssSaveContentModel, downloadId int64) *gjson.Json {
	info := g.Map{
		"operation":                p.config.Code,
		"batchMode":                string(p.config.Operation),
		"batchType":                p.config.BatchType,
		"targetLabel":              p.config.TargetLabel,
		"packageCode":              p.options.PackageCode,
		"remark":                   p.options.Remark,
		"paymentMode":              p.options.PaymentMode,
		"offlineContractCompleted": p.options.OfflineContractCompleted,
		"effectiveMode":            p.options.EffectiveMode,
		"effectiveModeText":        EffectiveModeText(p.options.EffectiveMode),
		"autoConfirm":              p.options.AutoConfirm,
		"resultFile":               g.Map{"status": "pending"},
	}
	if result != nil && result.ImportFileOssId > 0 {
		info["importFileOssId"] = result.ImportFileOssId
	} else if importOss != nil && importOss.OssId > 0 {
		info["importFileOssId"] = importOss.OssId
	}
	if resultOss != nil && resultOss.OssId > 0 {
		info["resultFileOssId"] = resultOss.OssId
	}
	if downloadId > 0 {
		info["resultDownloadId"] = downloadId
	}
	return gjson.New(info)
}

func rowsValidationError(rows []batchimport.Row, prefix string) error {
	reasons := make([]string, 0)
	for _, item := range rows {
		if item == nil {
			continue
		}
		rowReasons := item.GetErrorReasons()
		if len(rowReasons) == 0 {
			continue
		}
		reasons = append(reasons, fmt.Sprintf("第%d行：%s", item.GetRowNo(), strings.Join(rowReasons, "；")))
		if len(reasons) >= 5 {
			break
		}
	}
	if len(reasons) == 0 {
		return nil
	}
	return gerror.New(prefix + "：" + strings.Join(reasons, "；"))
}