Files
cmautobuy/admin/service/inner_code_import.go
T

325 lines
11 KiB
Go
Raw Normal View History

package service
import (
"bytes"
"database/sql"
"errors"
"fmt"
"path/filepath"
"regexp"
"strconv"
"strings"
"time"
"unicode/utf8"
"github.com/xuri/excelize/v2"
"cmautobuy/admin/model"
"cmautobuy/admin/repository"
)
const (
MaxInnerCodeUploadBytes = 10 * 1024 * 1024
MaxInnerCodeImportRows = 5000
innerCodeSheetName = "标签入库码映射"
)
var (
ErrInvalidInnerCodeImport = errors.New("档口入库码导入文件无效")
innerCodeXLSXMagic = []byte{0x50, 0x4B, 0x03, 0x04}
innerCodeBracketCN = regexp.MustCompile(`【[^】]*】`)
innerCodeParenthesesCN = regexp.MustCompile(`([^)]*)`)
innerCodeParenthesesASCII = regexp.MustCompile(`\([^)]*\)`)
innerCodeSuggestionTail = regexp.MustCompile(`建議.*$`)
innerCodeSpaces = regexp.MustCompile(`\s+`)
innerCodeStallToken = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9-]*$`)
innerCodeWeightTail = regexp.MustCompile(`(?i)[\d.]+[-~~到至][\d.]+(?:公斤|kg).*$`)
innerCodeSizeTail = regexp.MustCompile(`(?i)((?:[1-9]\d*)?XL|XXL|XS|S|M|L)$`)
)
// InnerCodeImportResult 是一次单表幂等导入的统计。
type InnerCodeImportResult struct {
TotalRows int
CreatedCount int
UpdatedCount int
DuplicateRows int
}
// IsInvalidInnerCodeImport 判断错误是否需要用户修正上传文件。
func IsInvalidInnerCodeImport(err error) bool {
return errors.Is(err, ErrInvalidInnerCodeImport)
}
// ValidateInnerCodeUpload 在落盘前限制 Excel 类型和大小。
func ValidateInnerCodeUpload(filename string, size int64, head []byte) error {
if size <= 0 {
return fmt.Errorf("文件是空的")
}
if size > MaxInnerCodeUploadBytes {
return fmt.Errorf("文件超过 10MB 上限(当前约 %.1fMB)", float64(size)/1024/1024)
}
if !strings.EqualFold(filepath.Ext(filename), ".xlsx") {
return fmt.Errorf("只允许 .xlsx 文件,收到的是 %q", filepath.Ext(filename))
}
if !bytes.HasPrefix(head, innerCodeXLSXMagic) {
return fmt.Errorf("文件内容不像 xlsx,可能只是修改了扩展名")
}
return nil
}
// NormalizeInnerCodeSpecKey 把 Excel/顺运宝规格收敛为可比较的“颜色,尺码”。
// 它只做确定性清洗,解析不出来时保留清洗后的原文,不猜测含义。
func NormalizeInnerCodeSpecKey(value string) string {
text := strings.TrimSpace(value)
if text == "" {
return ""
}
text = innerCodeBracketCN.ReplaceAllString(text, "")
text = innerCodeParenthesesCN.ReplaceAllString(text, "")
text = innerCodeParenthesesASCII.ReplaceAllString(text, "")
text = innerCodeSuggestionTail.ReplaceAllString(text, "")
text = strings.TrimSpace(innerCodeSpaces.ReplaceAllString(text, " "))
color, size, found := strings.Cut(text, ",")
if !found {
return innerCodeSpaces.ReplaceAllString(text, "")
}
colorTokens := strings.Fields(color)
if len(colorTokens) >= 2 && innerCodeStallToken.MatchString(colorTokens[0]) {
color = strings.Join(colorTokens[1:], "")
} else {
color = innerCodeSpaces.ReplaceAllString(color, "")
}
size = innerCodeSpaces.ReplaceAllString(size, "")
size = strings.ReplaceAll(size, "碼", "")
size = innerCodeWeightTail.ReplaceAllString(size, "")
if match := innerCodeSizeTail.FindStringSubmatch(size); len(match) == 2 {
size = strings.ToUpper(match[1])
}
return color + "," + size
}
// ImportInnerCodeExcel 解析工作表并在一个事务中幂等写入业务表。
func ImportInnerCodeExcel(db *sql.DB, path, businessDate, actorUserID string) (*InnerCodeImportResult, error) {
if _, err := time.Parse("2006-01-02", businessDate); err != nil {
return nil, fmt.Errorf("%w:业务日期格式应为 YYYY-MM-DD", ErrInvalidInnerCodeImport)
}
if strings.TrimSpace(actorUserID) == "" {
return nil, fmt.Errorf("导入账号不能为空")
}
book, err := excelize.OpenFile(path, excelize.Options{RawCellValue: true})
if err != nil {
return nil, fmt.Errorf("%w:打开 Excel 失败(%v)", ErrInvalidInnerCodeImport, err)
}
defer book.Close()
result, rows, err := parseInnerCodeWorkbook(book, businessDate, actorUserID)
if err != nil {
return nil, fmt.Errorf("%w:%v", ErrInvalidInnerCodeImport, err)
}
tx, err := db.Begin()
if err != nil {
return nil, fmt.Errorf("开始档口入库码导入事务失败: %w", err)
}
defer tx.Rollback()
now := model.NowISO()
for _, row := range rows {
outcome, err := repository.UpsertInnerCodeImportRow(tx, row, now)
if err != nil {
return nil, fmt.Errorf("导入 Excel 第 %d 行失败: %w", row.SourceRow, err)
}
if outcome == repository.InnerCodeImportCreated {
result.CreatedCount++
} else {
result.UpdatedCount++
}
}
if err := tx.Commit(); err != nil {
return nil, fmt.Errorf("提交档口入库码导入事务失败: %w", err)
}
return result, nil
}
type innerCodeParsedRow struct {
model.InnerCodeImportRow
businessKey string
}
func parseInnerCodeWorkbook(book *excelize.File, businessDate, actorUserID string) (*InnerCodeImportResult, []model.InnerCodeImportRow, error) {
found := false
for _, name := range book.GetSheetList() {
if name != innerCodeSheetName {
continue
}
found = true
rows, err := book.Rows(name)
if err != nil {
return nil, nil, fmt.Errorf("读取工作表 %q 失败: %w", name, err)
}
result, parsed, parseErr := parseInnerCodeRows(rows, businessDate, actorUserID)
closeErr := rows.Close()
if parseErr != nil {
return nil, nil, parseErr
}
if closeErr != nil {
return nil, nil, fmt.Errorf("关闭工作表 %q 失败: %w", name, closeErr)
}
return result, parsed, nil
}
if !found {
return nil, nil, fmt.Errorf("Excel 中没有工作表 %q", innerCodeSheetName)
}
return nil, nil, fmt.Errorf("工作表 %q 无法读取", innerCodeSheetName)
}
func parseInnerCodeRows(rows *excelize.Rows, businessDate, actorUserID string) (*InnerCodeImportResult, []model.InnerCodeImportRow, error) {
var headers map[string]int
var specColumn int
rowNumber := 0
parsed := make([]innerCodeParsedRow, 0, 128)
for rows.Next() {
rowNumber++
columns, err := rows.Columns()
if err != nil {
return nil, nil, fmt.Errorf("读取第 %d 行失败: %w", rowNumber, err)
}
if headers == nil {
if rowNumber > 10 {
break
}
candidate, candidateSpec := innerCodeHeaderMap(columns)
if _, ok := candidate["内部档口入库码"]; ok {
if _, ok = candidate["Shopee订单编号"]; ok && candidateSpec >= 0 {
headers, specColumn = candidate, candidateSpec
}
}
continue
}
orderNumber := innerCodeCell(columns, headers["Shopee订单编号"])
innerCode := innerCodeCell(columns, headers["内部档口入库码"])
if orderNumber == "" && innerCode == "" {
continue
}
if len(parsed) >= MaxInnerCodeImportRows {
return nil, nil, fmt.Errorf("非空数据超过 %d 条上限,请拆成多个文件导入", MaxInnerCodeImportRows)
}
if orderNumber == "" || innerCode == "" {
return nil, nil, fmt.Errorf("第 %d 行缺少 Shopee订单编号或内部档口入库码", rowNumber)
}
specRaw := strings.ReplaceAll(innerCodeCell(columns, specColumn), "\r", " ")
specRaw = strings.TrimSpace(strings.ReplaceAll(specRaw, "\n", " "))
stall := innerCodeStall(columns, headers)
shop := innerCodeNamedCell(columns, headers, "店铺名称")
printSequence := 0
if raw := innerCodeNamedCell(columns, headers, "标签打印序号"); raw != "" {
if value, parseErr := strconv.Atoi(raw); parseErr == nil && value > 0 {
printSequence = value
}
}
if err := validateInnerCodeFields(rowNumber, orderNumber, shop, stall, specRaw, innerCode); err != nil {
return nil, nil, err
}
specKey := NormalizeInnerCodeSpecKey(specRaw)
key := strings.Join([]string{businessDate, orderNumber, stall, specKey}, "\x00")
parsed = append(parsed, innerCodeParsedRow{InnerCodeImportRow: model.InnerCodeImportRow{
BusinessDate: businessDate, SourceRow: rowNumber, PrintSequence: printSequence,
OrderNumber: orderNumber, ShopName: shop, Stall: stall, SpecRaw: specRaw,
SpecKey: specKey, InnerCode: innerCode, SourceDuplicateCount: 1,
CreatedByUserID: actorUserID,
}, businessKey: key})
}
if err := rows.Error(); err != nil {
return nil, nil, fmt.Errorf("遍历工作表失败: %w", err)
}
if headers == nil {
return nil, nil, fmt.Errorf("前 10 行未找到包含内部档口入库码、Shopee订单编号和规格列的表头")
}
if len(parsed) == 0 {
return nil, nil, fmt.Errorf("工作表只有表头,没有可导入数据")
}
groups := make(map[string][]innerCodeParsedRow, len(parsed))
codeKeys := make(map[string]string, len(parsed))
for _, row := range parsed {
groups[row.businessKey] = append(groups[row.businessKey], row)
if oldKey, exists := codeKeys[row.InnerCode]; exists && oldKey != row.businessKey {
return nil, nil, fmt.Errorf("同一业务日期的入库码 %q 对应多组订单/档口/规格", row.InnerCode)
}
codeKeys[row.InnerCode] = row.businessKey
}
result := &InnerCodeImportResult{TotalRows: len(parsed)}
unique := make([]model.InnerCodeImportRow, 0, len(groups))
seen := make(map[string]bool, len(groups))
for _, original := range parsed {
if seen[original.businessKey] {
continue
}
seen[original.businessKey] = true
group := groups[original.businessKey]
for _, duplicate := range group[1:] {
if duplicate.InnerCode != original.InnerCode {
return nil, nil, fmt.Errorf("第 %d 行与第 %d 行业务键相同但入库码不同", original.SourceRow, duplicate.SourceRow)
}
}
row := original.InnerCodeImportRow
row.SourceDuplicateCount = len(group)
unique = append(unique, row)
result.DuplicateRows += len(group) - 1
}
return result, unique, nil
}
func innerCodeHeaderMap(columns []string) (map[string]int, int) {
result := make(map[string]int, len(columns))
specColumn := -1
for index, raw := range columns {
name := strings.TrimSpace(raw)
result[name] = index
if name == "清洗后规格" || (specColumn < 0 && strings.HasPrefix(name, "原始产品规格")) {
specColumn = index
}
}
return result, specColumn
}
func innerCodeStall(columns []string, headers map[string]int) string {
if combined := innerCodeNamedCell(columns, headers, "档口及货号"); combined != "" {
return combined
}
name := innerCodeNamedCell(columns, headers, "档口名称")
article := innerCodeNamedCell(columns, headers, "档口货号")
if name != "" && article != "" {
return name + "#" + article
}
return name + article
}
func innerCodeNamedCell(columns []string, headers map[string]int, name string) string {
index, ok := headers[name]
if !ok {
return ""
}
return innerCodeCell(columns, index)
}
func innerCodeCell(columns []string, index int) string {
if index < 0 || index >= len(columns) {
return ""
}
return strings.TrimSpace(columns[index])
}
func validateInnerCodeFields(row int, order, shop, stall, spec, code string) error {
for _, field := range []struct {
name, value string
max int
}{
{"Shopee订单编号", order, 64}, {"店铺名称", shop, 191}, {"档口及货号", stall, 191},
{"规格", spec, 500}, {"内部档口入库码", code, 128},
} {
if utf8.RuneCountInString(field.value) > field.max {
return fmt.Errorf("第 %d 行%s超过 %d 个字符", row, field.name, field.max)
}
}
return nil
}