feat: 支持批量导入 PDD 商品链接 (#104)

This commit is contained in:
chengma
2026-08-10 16:14:24 +08:00
parent 7bd75510b2
commit 188725ff64
15 changed files with 911 additions and 32 deletions
+13
View File
@@ -7,6 +7,8 @@ import (
"net/http"
"github.com/gin-gonic/gin"
"cmautobuy/admin/service"
)
// CSRF 防护,用的是「双提交 Cookie」这个最简单的方案:
@@ -57,6 +59,17 @@ func CSRFMiddleware() gin.HandlerFunc {
return
}
// multipart 表单会在下面 PostForm 时被解析,所以请求体上限必须在它之前设置。
// 放到具体上传 Handler 里已经太晚:那时文件可能已经被读进临时目录。
switch c.Request.URL.Path {
case "/pdd/import":
c.Request.Body = http.MaxBytesReader(
c.Writer, c.Request.Body, service.MaxPddUploadBytes+1<<20)
case "/shopee/import":
c.Request.Body = http.MaxBytesReader(
c.Writer, c.Request.Body, service.MaxShopeeUploadBytes+1<<20)
}
submitted := c.PostForm(csrfFieldName)
if submitted == "" {
submitted = c.GetHeader("X-CSRF-Token")
+83 -5
View File
@@ -2,12 +2,15 @@ package web
import (
"fmt"
"io"
"net/http"
"net/url"
"os"
"strconv"
"github.com/gin-gonic/gin"
"cmautobuy/admin/config"
"cmautobuy/admin/service"
)
@@ -18,9 +21,13 @@ import (
// PddList 渲染 PDD 商品列表页。
func (h *Handler) PddList(c *gin.Context) {
keyword := c.Query("q")
status := service.ParseCollectStatus(c.Query("status"))
pageNum := service.ParsePage(c.Query("page"))
h.renderPddList(c, c.Query("q"), c.Query("status"), c.Query("page"), "", nil)
}
// renderPddList 统一渲染普通列表和导入结果页,避免两条入口逐渐长成两套页面。
func (h *Handler) renderPddList(c *gin.Context, keyword, statusRaw, pageRaw, message string, importResult *service.PddImportResult) {
status := service.ParseCollectStatus(statusRaw)
pageNum := service.ParsePage(pageRaw)
result, err := service.ListPddProducts(h.db, keyword, status, pageNum)
if err != nil {
@@ -38,8 +45,11 @@ func (h *Handler) PddList(c *gin.Context) {
// 底部状态条平时显示统计,刚做完操作时先显示操作结果。
// 操作结果是通过跳转带过来的 msg 参数传的(见 pddRedirect)。
statusLine := result.StatusLine()
if msg := c.Query("msg"); msg != "" {
statusLine = msg + " · " + statusLine
if msg := c.Query("msg"); msg != "" && message == "" {
message = msg
}
if message != "" {
statusLine = message + " · " + statusLine
}
values := url.Values{}
@@ -66,6 +76,7 @@ func (h *Handler) PddList(c *gin.Context) {
"Pagination": service.NewPaginationView(result.Page, result.TotalPages, values.Encode()),
"DetailURL": "/pdd/detail?" + detailValues.Encode(),
"AssignableClients": assignableClients,
"ImportResult": importResult,
}))
}
@@ -112,6 +123,73 @@ func (h *Handler) PddCreate(c *gin.Context) {
h.pddRedirect(c, fmt.Sprintf("已保存商品 %s,现在可以勾选它创建采集任务", goodsID))
}
// PddImport 把一列式 xlsx 中的完整 PDD 链接批量导入商品档案。
// 上传只建档,不会自动创建采集任务;导入结果页提供单独的确认入口。
func (h *Handler) PddImport(c *gin.Context) {
fileHeader, err := c.FormFile("file")
if err != nil {
fail(c, http.StatusBadRequest,
"没有收到文件(也可能是文件超过了 10MB 上限)。请重新选择 Excel;没有写入任何商品。")
return
}
src, err := fileHeader.Open()
if err != nil {
fail(c, http.StatusBadRequest, "无法打开上传文件,请重新选择;没有写入任何商品。")
return
}
defer src.Close()
head := make([]byte, 8)
n, _ := io.ReadFull(src, head)
if err := service.ValidatePddUpload(fileHeader.Filename, fileHeader.Size, head[:n]); err != nil {
fail(c, http.StatusBadRequest, err.Error()+"。请按模板选择文件;没有写入任何商品。")
return
}
if _, err := src.Seek(0, io.SeekStart); err != nil {
fail(c, http.StatusInternalServerError, "读取上传文件失败,请重试;没有写入任何商品。")
return
}
uploadDir, err := config.SubDir("uploads")
if err != nil {
fail(c, http.StatusInternalServerError, "无法准备临时上传目录,请重试;没有写入任何商品。")
return
}
tmp, err := os.CreateTemp(uploadDir, "pdd-*.xlsx")
if err != nil {
fail(c, http.StatusInternalServerError, "无法保存临时上传文件,请重试;没有写入任何商品。")
return
}
tmpPath := tmp.Name()
defer os.Remove(tmpPath)
if _, err := io.Copy(tmp, src); err != nil {
tmp.Close()
fail(c, http.StatusInternalServerError, "保存临时上传文件失败,请重试;没有写入任何商品。")
return
}
if err := tmp.Close(); err != nil {
fail(c, http.StatusInternalServerError, "保存临时上传文件失败,请重试;没有写入任何商品。")
return
}
result, err := service.ImportPddExcel(h.db, tmpPath)
if err != nil {
if service.IsInvalidPddImport(err) {
fail(c, http.StatusBadRequest, err.Error()+"。请修正文件后重新导入;没有写入任何商品。")
return
}
fail(c, http.StatusInternalServerError,
"PDD 商品导入时数据库写入失败,本批合法行已经整体回滚。请稍后重试;一直失败请联系维护者。")
return
}
message := fmt.Sprintf(
"批量导入完成:总行数 %d,新建 %d,已存在 %d,恢复 %d,文件内重复 %d,失败 %d",
result.TotalRows, result.CreatedCount, result.ExistingCount, result.RevivedCount,
result.DuplicateCount, len(result.Failures))
h.renderPddList(c, "", "", "1", message, result)
}
// PddSave 保存弹窗里改过的链接。
func (h *Handler) PddSave(c *gin.Context) {
id, err := strconv.ParseInt(c.PostForm("id"), 10, 64)
+1
View File
@@ -65,6 +65,7 @@ func Register(r *gin.Engine, db *sql.DB, onlineThreshold time.Duration) {
pages.GET("/pdd", h.PddList)
pages.GET("/pdd/detail", h.PddDetail) // 双击行时前端来取弹窗内容
pages.POST("/pdd/create", h.PddCreate)
pages.POST("/pdd/import", h.PddImport)
pages.POST("/pdd/save", h.PddSave)
pages.POST("/pdd/collect", h.PddCollect)
pages.POST("/pdd/delete", h.PddDelete)
+20
View File
@@ -36,6 +36,12 @@ func TestPaginationCSS_桌面右对齐且窄窗口不遮挡内容(t *testing.T)
}
}
func TestTemplatesAndRoutesCanBeBuiltWithoutDatabaseConnection(t *testing.T) {
if _, err := newRouter(nil); err != nil {
t.Fatalf("模板或路由组装失败: %v", err)
}
}
// 六个主页面都走一次真实路由和模板渲染。
// 这样模板字段写错或新增列漏接时,测试阶段就会失败,不必等人工点页面。
func TestMainPagesReturnOK(t *testing.T) {
@@ -85,6 +91,20 @@ func TestMainPagesReturnOK(t *testing.T) {
})
}
pddRequest := httptest.NewRequest(http.MethodGet, "/pdd", nil)
addAuth(pddRequest)
pddResponse := httptest.NewRecorder()
router.ServeHTTP(pddResponse, pddRequest)
for _, want := range []string{
"批量导入", `action="/pdd/import"`, `enctype="multipart/form-data"`,
`id="pdd-import-file"`, `aria-describedby="pdd-import-help"`,
"拼多多链接", "最多 5000 条", `data-upload-form`,
} {
if !strings.Contains(pddResponse.Body.String(), want) {
t.Errorf("PDD 页面缺少批量导入界面 %q", want)
}
}
if err := service.CreatePurchaser(db, adminUser, "buyer", "buyer-password", "buyer-password", time.Now()); err != nil {
t.Fatalf("准备测试采购员失败: %v", err)
}
+46
View File
@@ -0,0 +1,46 @@
package main
import (
"bytes"
"html/template"
"strings"
"testing"
"cmautobuy/admin/service"
)
func TestPddImportResultTemplate_完整集合和失败明细安全渲染(t *testing.T) {
tmpl, err := template.ParseFS(templateFS, "templates/*/*.html")
if err != nil {
t.Fatal(err)
}
var output bytes.Buffer
data := map[string]any{
"Title": "PDD 商品", "Active": "pdd", "CSRFToken": "test-csrf",
"ImportResult": &service.PddImportResult{
TotalRows: 25, CreatedCount: 2, ExistingCount: 1, DuplicateCount: 1,
GoodsIDs: []string{"737116531267", "647453710994"},
Failures: []service.PddImportFailure{{
Row: 5, Raw: "<script>alert(1)</script>", Reason: "不是拼多多网址",
}},
},
}
if err := tmpl.ExecuteTemplate(&output, "pdd/list", data); err != nil {
t.Fatalf("渲染 PDD 导入结果失败: %v", err)
}
body := output.String()
for _, want := range []string{
"本次导入结果", "总行数 <strong>25</strong>",
`data-collect-form="pdd-import-collect-form"`,
`name="ids" value="737116531267"`,
`name="ids" value="647453710994"`,
"Excel 行号", "不是拼多多网址", "&lt;script&gt;alert(1)&lt;/script&gt;",
} {
if !strings.Contains(body, want) {
t.Errorf("导入结果页面缺少 %q", want)
}
}
if strings.Contains(body, "<script>alert(1)</script>") {
t.Error("Excel 原始内容没有经过 html/template 自动转义")
}
}
+27 -9
View File
@@ -47,6 +47,16 @@ func scanPddProduct(s rowScanner, extra ...any) (*model.PddProduct, error) {
return &p, nil
}
// EnsurePddProductOutcome 说明 EnsurePddProductWithOutcome 实际做了什么。
// 批量导入用它给采购员显示准确统计;普通单条创建只关心最终商品。
type EnsurePddProductOutcome string
const (
PddProductCreated EnsurePddProductOutcome = "created"
PddProductExisting EnsurePddProductOutcome = "existing"
PddProductRevived EnsurePddProductOutcome = "revived"
)
// EnsurePddProduct 保证 goods_id 对应的 PDD 商品存在,返回它。
//
// 操作员在货运单或蝦皮商品上填 PDD 链接、点保存时调它。三种情况:
@@ -58,16 +68,23 @@ func scanPddProduct(s rowScanner, extra ...any) (*model.PddProduct, error) {
// 复活是必要的:goods_id 上有 UNIQUE 约束,软删除的行还占着那个值,
// 不复活就会插入冲突,操作员会看到一个莫名其妙的错误。
func EnsurePddProduct(q Execer, goodsID, url string) (*model.PddProduct, error) {
p, _, err := EnsurePddProductWithOutcome(q, goodsID, url)
return p, err
}
// EnsurePddProductWithOutcome 与 EnsurePddProduct 使用完全相同的建档规则,
// 额外返回新建、复用或复活分类,供批量导入统计使用。
func EnsurePddProductWithOutcome(q Execer, goodsID, url string) (*model.PddProduct, EnsurePddProductOutcome, error) {
if goodsID == "" {
return nil, fmt.Errorf("goods_id 不能为空")
return nil, "", fmt.Errorf("goods_id 不能为空")
}
if url == "" {
return nil, fmt.Errorf("url 不能为空")
return nil, "", fmt.Errorf("url 不能为空")
}
existing, err := GetPddProductByGoodsID(q, goodsID)
if err != nil {
return nil, err
return nil, "", err
}
now := model.NowISO()
@@ -78,14 +95,14 @@ func EnsurePddProduct(q Execer, goodsID, url string) (*model.PddProduct, error)
VALUES (?, ?, 'pending', ?, ?)`,
goodsID, url, now, now)
if err != nil {
return nil, fmt.Errorf("新建 PDD 商品 %s 失败: %w", goodsID, err)
return nil, "", fmt.Errorf("新建 PDD 商品 %s 失败: %w", goodsID, err)
}
id, _ := res.LastInsertId()
return &model.PddProduct{
ID: id, GoodsID: goodsID, URL: url,
CollectStatus: model.CollectPending,
CreatedAt: now, UpdatedAt: now,
}, nil
}, PddProductCreated, nil
}
if existing.IsDeleted() {
@@ -103,9 +120,10 @@ func EnsurePddProduct(q Execer, goodsID, url string) (*model.PddProduct, error)
WHERE goods_id = ?`,
url, now, goodsID)
if err != nil {
return nil, fmt.Errorf("复活 PDD 商品 %s 失败: %w", goodsID, err)
return nil, "", fmt.Errorf("复活 PDD 商品 %s 失败: %w", goodsID, err)
}
return GetPddProductByGoodsID(q, goodsID)
p, err := GetPddProductByGoodsID(q, goodsID)
return p, PddProductRevived, err
}
// 已存在且有效:链接可能写法不同(带不带参数),更新一下原文,
@@ -114,11 +132,11 @@ func EnsurePddProduct(q Execer, goodsID, url string) (*model.PddProduct, error)
if _, err := q.Exec(
`UPDATE pdd_products SET url = ?, updated_at = ? WHERE goods_id = ?`,
url, now, goodsID); err != nil {
return nil, fmt.Errorf("更新 PDD 商品 %s 链接失败: %w", goodsID, err)
return nil, "", fmt.Errorf("更新 PDD 商品 %s 链接失败: %w", goodsID, err)
}
existing.URL = url
}
return existing, nil
return existing, PddProductExisting, nil
}
// GetPddProductByGoodsID 按 goods_id 查,**包括已软删除的**。
+228
View File
@@ -0,0 +1,228 @@
// PDD 商品链接 Excel 批量导入。
//
// 本文件只负责文件校验、逐行解析、业务去重和事务编排;SQL 仍然全部在
// repository,HTTP 上传细节仍然全部在 handler/web。
package service
import (
"bytes"
"database/sql"
"errors"
"fmt"
"path/filepath"
"strings"
"github.com/xuri/excelize/v2"
"cmautobuy/admin/repository"
)
const (
// MaxPddUploadBytes 足够容纳 5000 条单列链接,同时限制误传大文件。
MaxPddUploadBytes = 10 * 1024 * 1024
// MaxPddImportRows 限制一次导入的非空数据行,避免误发超大批次。
MaxPddImportRows = 5000
pddLinkHeader = "拼多多链接"
)
var pddXLSXMagic = []byte{0x50, 0x4B, 0x03, 0x04}
// ErrInvalidPddImport 区分“文件需要采购员修正”和“服务器写库失败”。
// Handler 据此选择 400 或 500,避免把数据库内部错误直接显示到页面。
var ErrInvalidPddImport = errors.New("PDD 导入文件无效")
// IsInvalidPddImport 判断错误是否来自上传文件内容或结构。
func IsInvalidPddImport(err error) bool {
return errors.Is(err, ErrInvalidPddImport)
}
// PddImportFailure 是一条不能导入的 Excel 数据行。
type PddImportFailure struct {
Row int
Raw string
Reason string
}
// PddImportResult 是本次导入的完整统计。
// GoodsIDs 保存全部合法且去重后的商品,供页面显式创建本批采集任务。
type PddImportResult struct {
TotalRows int
CreatedCount int
ExistingCount int
RevivedCount int
DuplicateCount int
Failures []PddImportFailure
GoodsIDs []string
}
// ValidatePddUpload 在落盘和解析前校验上传文件的基本安全边界。
func ValidatePddUpload(filename string, size int64, head []byte) error {
if size <= 0 {
return fmt.Errorf("文件是空的")
}
if size > MaxPddUploadBytes {
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, pddXLSXMagic) {
return fmt.Errorf("文件内容不像一个 xlsx(zip 格式)文件,可能是改了扩展名的其他文件")
}
return nil
}
type pddImportEntry struct {
GoodsID string
URL string
}
// ImportPddExcel 导入第一个非空工作表的“拼多多链接”列。
//
// 格式错误只影响对应行,合法行仍会进入同一个数据库事务;数据库写入任一步
// 失败则整体回滚,避免留下无法解释的半批数据。
func ImportPddExcel(db *sql.DB, path string) (*PddImportResult, error) {
book, err := excelize.OpenFile(path)
if err != nil {
return nil, fmt.Errorf("%w:打开 Excel 失败(%v)", ErrInvalidPddImport, err)
}
defer book.Close()
result, entries, err := parsePddImportWorkbook(book)
if err != nil {
return nil, fmt.Errorf("%w:%v", ErrInvalidPddImport, err)
}
if len(entries) == 0 {
return result, nil
}
tx, err := db.Begin()
if err != nil {
return nil, fmt.Errorf("开始 PDD 导入事务失败: %w", err)
}
defer tx.Rollback()
for _, entry := range entries {
_, outcome, err := repository.EnsurePddProductWithOutcome(tx, entry.GoodsID, entry.URL)
if err != nil {
return nil, fmt.Errorf("写入 PDD 商品 %s 失败: %w", entry.GoodsID, err)
}
switch outcome {
case repository.PddProductCreated:
result.CreatedCount++
case repository.PddProductExisting:
result.ExistingCount++
case repository.PddProductRevived:
result.RevivedCount++
default:
return nil, fmt.Errorf("PDD 商品 %s 返回了未知导入结果 %q", entry.GoodsID, outcome)
}
}
if err := tx.Commit(); err != nil {
return nil, fmt.Errorf("提交 PDD 导入事务失败: %w", err)
}
return result, nil
}
func parsePddImportWorkbook(book *excelize.File) (*PddImportResult, []pddImportEntry, error) {
for _, sheet := range book.GetSheetList() {
rows, err := book.Rows(sheet)
if err != nil {
return nil, nil, fmt.Errorf("读取工作表 %q 失败: %w", sheet, err)
}
result, entries, found, parseErr := parsePddImportRows(rows, sheet)
closeErr := rows.Close()
if parseErr != nil {
return nil, nil, parseErr
}
if closeErr != nil {
return nil, nil, fmt.Errorf("关闭工作表 %q 失败: %w", sheet, closeErr)
}
if found {
return result, entries, nil
}
}
return nil, nil, fmt.Errorf("Excel 中没有非空工作表,请把链接填在第一列并使用表头“%s”", pddLinkHeader)
}
func parsePddImportRows(rows *excelize.Rows, sheet string) (*PddImportResult, []pddImportEntry, bool, error) {
result := &PddImportResult{}
entries := make([]pddImportEntry, 0, 64)
seen := make(map[string]struct{}, 64)
foundHeader := false
rowNumber := 0
for rows.Next() {
rowNumber++
columns, err := rows.Columns()
if err != nil {
return nil, nil, false, fmt.Errorf("读取工作表 %q 第 %d 行失败: %w", sheet, rowNumber, err)
}
if rowIsBlank(columns) {
continue
}
if !foundHeader {
foundHeader = true
header := firstColumn(columns)
if header != pddLinkHeader {
return nil, nil, false, fmt.Errorf(
"工作表 %q 第一个非空行的第一列应为“%s”,实际是 %q",
sheet, pddLinkHeader, header)
}
continue
}
result.TotalRows++
if result.TotalRows > MaxPddImportRows {
return nil, nil, false, fmt.Errorf(
"非空数据超过 %d 条上限(在工作表 %q 第 %d 行发现超限),请拆成多个文件导入",
MaxPddImportRows, sheet, rowNumber)
}
raw := firstColumn(columns)
if raw == "" {
result.Failures = append(result.Failures, PddImportFailure{
Row: rowNumber, Raw: "(空)", Reason: "第一列“拼多多链接”不能为空",
})
continue
}
goodsID, err := ParsePddGoodsID(raw)
if err != nil {
result.Failures = append(result.Failures, PddImportFailure{
Row: rowNumber, Raw: raw, Reason: err.Error(),
})
continue
}
if _, duplicate := seen[goodsID]; duplicate {
result.DuplicateCount++
continue
}
seen[goodsID] = struct{}{}
entries = append(entries, pddImportEntry{GoodsID: goodsID, URL: raw})
result.GoodsIDs = append(result.GoodsIDs, goodsID)
}
if err := rows.Error(); err != nil {
return nil, nil, false, fmt.Errorf("遍历工作表 %q 失败: %w", sheet, err)
}
if foundHeader && result.TotalRows == 0 {
return nil, nil, false, fmt.Errorf(
"工作表 %q 只有表头,下面没有 PDD 商品链接", sheet)
}
return result, entries, foundHeader, nil
}
func rowIsBlank(columns []string) bool {
for _, value := range columns {
if strings.TrimSpace(value) != "" {
return false
}
}
return true
}
func firstColumn(columns []string) string {
if len(columns) == 0 {
return ""
}
return strings.TrimSpace(columns[0])
}
+264
View File
@@ -0,0 +1,264 @@
package service
import (
"database/sql"
"fmt"
"path/filepath"
"strings"
"testing"
"github.com/xuri/excelize/v2"
"cmautobuy/admin/model"
"cmautobuy/admin/repository"
)
func TestValidatePddUpload(t *testing.T) {
validHead := []byte{0x50, 0x4B, 0x03, 0x04, 0x14}
for _, tc := range []struct {
name string
filename string
size int64
head []byte
wantErr bool
}{
{"合法文件", "pdd.xlsx", 1024, validHead, false},
{"扩展名大小写", "pdd.XLSX", 1024, validHead, false},
{"空文件", "pdd.xlsx", 0, validHead, true},
{"超过上限", "pdd.xlsx", MaxPddUploadBytes + 1, validHead, true},
{"错误扩展名", "pdd.xls", 1024, validHead, true},
{"伪造扩展名", "pdd.xlsx", 1024, []byte("not zip"), true},
} {
t.Run(tc.name, func(t *testing.T) {
err := ValidatePddUpload(tc.filename, tc.size, tc.head)
if (err != nil) != tc.wantErr {
t.Fatalf("ValidatePddUpload() err=%v, wantErr=%t", err, tc.wantErr)
}
})
}
}
func TestParsePddImportWorkbook_忽略空表并逐行反馈(t *testing.T) {
book := excelize.NewFile()
t.Cleanup(func() { book.Close() })
if err := book.SetSheetName("Sheet1", "空表"); err != nil {
t.Fatal(err)
}
dataSheet, err := book.NewSheet("链接")
if err != nil {
t.Fatal(err)
}
book.SetActiveSheet(dataSheet)
rows := [][]string{
{pddLinkHeader},
{"https://mobile.yangkeduo.com/goods.html?goods_id=737116531267"},
{"https://mobile.pinduoduo.com/goods.html?goods_id=647453710994"},
{"https://mobile.yangkeduo.com/goods.html?goods_id=737116531267&from=duplicate"},
{"https://p.pinduoduo.com/short"},
{"", "第二列误填内容"},
}
setWorkbookRows(t, book, "链接", rows)
result, entries, err := parsePddImportWorkbook(book)
if err != nil {
t.Fatalf("解析失败: %v", err)
}
if result.TotalRows != 5 || result.DuplicateCount != 1 || len(result.Failures) != 2 {
t.Fatalf("统计不对: %+v", result)
}
if len(entries) != 2 || len(result.GoodsIDs) != 2 {
t.Fatalf("合法商品应为 2 条: entries=%d ids=%v", len(entries), result.GoodsIDs)
}
if result.Failures[0].Row != 5 || result.Failures[1].Row != 6 {
t.Fatalf("失败行号不对: %+v", result.Failures)
}
if !strings.Contains(result.Failures[0].Reason, "goods_id") ||
!strings.Contains(result.Failures[1].Reason, "不能为空") {
t.Fatalf("失败原因不可操作: %+v", result.Failures)
}
}
func TestParsePddImportWorkbook_脱敏固定样本(t *testing.T) {
book, err := excelize.OpenFile(filepath.Join("..", "testdata", "pdd_links.xlsx"))
if err != nil {
t.Fatal(err)
}
defer book.Close()
result, entries, err := parsePddImportWorkbook(book)
if err != nil {
t.Fatalf("解析脱敏样本失败: %v", err)
}
if result.TotalRows != 5 || len(entries) != 3 || result.DuplicateCount != 1 || len(result.Failures) != 1 {
t.Fatalf("脱敏样本统计不对: result=%+v entries=%d", result, len(entries))
}
}
func TestParsePddImportWorkbook_错误表头和行数上限整体拒绝(t *testing.T) {
t.Run("错误表头", func(t *testing.T) {
book := excelize.NewFile()
defer book.Close()
setWorkbookRows(t, book, "Sheet1", [][]string{{"链接"}, {pddURL("737116531267")}})
_, _, err := parsePddImportWorkbook(book)
if err == nil || !strings.Contains(err.Error(), pddLinkHeader) {
t.Fatalf("应明确提示正确表头,实际 %v", err)
}
})
t.Run("只有表头", func(t *testing.T) {
book := excelize.NewFile()
defer book.Close()
setWorkbookRows(t, book, "Sheet1", [][]string{{pddLinkHeader}})
_, _, err := parsePddImportWorkbook(book)
if err == nil || !strings.Contains(err.Error(), "只有表头") {
t.Fatalf("应提示没有商品链接,实际 %v", err)
}
})
t.Run("超过5000条", func(t *testing.T) {
book := excelize.NewFile()
defer book.Close()
rows := make([][]string, 0, MaxPddImportRows+2)
rows = append(rows, []string{pddLinkHeader})
for i := 0; i <= MaxPddImportRows; i++ {
rows = append(rows, []string{pddURL(fmt.Sprintf("%012d", 100000000000+i))})
}
setWorkbookRows(t, book, "Sheet1", rows)
_, _, err := parsePddImportWorkbook(book)
if err == nil || !strings.Contains(err.Error(), "5000") || !strings.Contains(err.Error(), "拆成多个文件") {
t.Fatalf("超限提示不明确: %v", err)
}
})
}
func TestImportPddExcel_新建复用复活重复和失败可同时统计(t *testing.T) {
db := newPddImportSQLiteDB(t, false)
existingID := "647453710994"
revivedID := "753136429979"
if _, err := repository.EnsurePddProduct(db, existingID, pddURL(existingID)); err != nil {
t.Fatal(err)
}
if err := repository.SetCollectResult(db, existingID, "已采集商品", "测试店铺", `{"skus":[1]}`); err != nil {
t.Fatal(err)
}
if _, err := repository.EnsurePddProduct(db, revivedID, pddURL(revivedID)); err != nil {
t.Fatal(err)
}
if err := repository.SetCollectResult(db, revivedID, "删除前商品", "旧店铺", `{"skus":[1]}`); err != nil {
t.Fatal(err)
}
if _, err := repository.SoftDeletePddProducts(db, []string{revivedID}); err != nil {
t.Fatal(err)
}
path := filepath.Join("..", "testdata", "pdd_links.xlsx")
result, err := ImportPddExcel(db, path)
if err != nil {
t.Fatalf("导入失败: %v", err)
}
if result.TotalRows != 5 || result.CreatedCount != 1 || result.ExistingCount != 1 ||
result.RevivedCount != 1 || result.DuplicateCount != 1 || len(result.Failures) != 1 {
t.Fatalf("导入统计不对: %+v", result)
}
if len(result.GoodsIDs) != 3 {
t.Fatalf("本次导入集合应跨分页保留全部 3 个 ID,实际 %v", result.GoodsIDs)
}
existing, _ := repository.GetPddProductByGoodsID(db, existingID)
if existing.CollectStatus != model.CollectCollected || existing.SkusJSON == "" || existing.Title != "已采集商品" {
t.Fatalf("已存在商品的采集结果被覆盖: %+v", existing)
}
if !strings.Contains(existing.URL, "from=excel") {
t.Errorf("已存在商品应更新同 goods_id 的链接原文,实际 %q", existing.URL)
}
revived, _ := repository.GetPddProductByGoodsID(db, revivedID)
if revived.IsDeleted() || revived.CollectStatus != model.CollectPending || revived.SkusJSON != "" || revived.Title != "" {
t.Fatalf("复活商品未沿用现有清理规则: %+v", revived)
}
second, err := ImportPddExcel(db, path)
if err != nil {
t.Fatalf("重复导入失败: %v", err)
}
if second.CreatedCount != 0 || second.ExistingCount != 3 || second.RevivedCount != 0 {
t.Fatalf("重复导入应全部复用,实际 %+v", second)
}
var count int
if err := db.QueryRow(`SELECT COUNT(*) FROM pdd_products`).Scan(&count); err != nil || count != 3 {
t.Fatalf("重复导入产生重复商品: count=%d err=%v", count, err)
}
var taskCount int
if err := db.QueryRow(`SELECT COUNT(*) FROM tasks`).Scan(&taskCount); err != nil || taskCount != 0 {
t.Fatalf("上传不应自动创建采集任务: count=%d err=%v", taskCount, err)
}
}
func TestImportPddExcel_数据库中途失败时合法行整体回滚(t *testing.T) {
db := newPddImportSQLiteDB(t, true)
_, err := ImportPddExcel(db, filepath.Join("..", "testdata", "pdd_links.xlsx"))
if err == nil || IsInvalidPddImport(err) {
t.Fatalf("应返回数据库写入错误,实际 %v", err)
}
var count int
if err := db.QueryRow(`SELECT COUNT(*) FROM pdd_products`).Scan(&count); err != nil {
t.Fatal(err)
}
if count != 0 {
t.Fatalf("第一条合法商品没有随第二条失败回滚,仍有 %d 条", count)
}
}
func newPddImportSQLiteDB(t *testing.T, failSecondInsert bool) *sql.DB {
t.Helper()
dsn := fmt.Sprintf("file:pdd_import_%s?mode=memory&cache=shared", strings.ReplaceAll(t.Name(), "/", "_"))
db, err := sql.Open("sqlite", dsn)
if err != nil {
t.Fatal(err)
}
db.SetMaxOpenConns(1)
t.Cleanup(func() { db.Close() })
if _, err := db.Exec(`
CREATE TABLE pdd_products (
id INTEGER PRIMARY KEY AUTOINCREMENT,
goods_id TEXT NOT NULL UNIQUE,
url TEXT NOT NULL,
title TEXT, shop_name TEXT, skus_json TEXT,
collect_status TEXT NOT NULL,
collect_msg TEXT, artifact_ref TEXT, collected_at TEXT,
deleted_at TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL
);
CREATE TABLE tasks (task_id TEXT PRIMARY KEY);
`); err != nil {
t.Fatal(err)
}
if failSecondInsert {
if _, err := db.Exec(`
CREATE TRIGGER fail_second_pdd BEFORE INSERT ON pdd_products
WHEN NEW.goods_id = '647453710994'
BEGIN SELECT RAISE(ABORT, 'simulated write failure'); END;
`); err != nil {
t.Fatal(err)
}
}
return db
}
func setWorkbookRows(t *testing.T, book *excelize.File, sheet string, rows [][]string) {
t.Helper()
for rowIndex, row := range rows {
for columnIndex, value := range row {
cell, err := excelize.CoordinatesToCellName(columnIndex+1, rowIndex+1)
if err != nil {
t.Fatal(err)
}
if err := book.SetCellValue(sheet, cell, value); err != nil {
t.Fatal(err)
}
}
}
}
func pddURL(goodsID string) string {
return "https://mobile.yangkeduo.com/goods.html?goods_id=" + goodsID
}
+35
View File
@@ -175,6 +175,41 @@ tr.empty small { color: #aaa; }
margin: 12px 2px;
}
/* PDD 批量导入结果:统计、下一步和失败明细放在同一区域,
采购员不需要从底部状态条猜本批数据发生了什么。 */
.import-result {
margin-bottom: 12px;
padding: 12px;
background: #fff;
border: 1px solid #c9d8ee;
border-left: 4px solid #1f6feb;
border-radius: 4px;
}
.import-result-head {
display: flex;
align-items: center;
justify-content: space-between;
gap: 12px;
}
.import-result h2 { margin: 0 0 6px; font-size: 16px; }
.import-result p { margin: 0; }
.import-result .hint { margin-top: 8px; }
.import-success { color: #176b36; font-weight: 600; }
.import-failure-table {
max-height: 280px;
margin-top: 10px;
}
.import-failure-table .import-raw,
.import-failure-table .import-reason {
min-width: 260px;
max-width: 520px;
white-space: normal;
overflow-wrap: anywhere;
}
@media (max-width: 760px) {
.import-result-head { align-items: flex-start; flex-direction: column; }
}
/* ── 第三段:底部状态条 ───────────────── */
.statusbar {
position: fixed;
+34 -14
View File
@@ -189,21 +189,40 @@
/* PDD 批量采集弹窗只同步已选数量并提供提交反馈。
客户端权限和任务初始状态始终由服务端决定。 */
function setupCollectModal() {
var openButton = document.querySelector("[data-collect-open]");
var count = document.querySelector("[data-collect-count]");
var form = document.getElementById("pdd-form");
var submitButton = document.querySelector("[data-collect-submit]");
if (!openButton || !count || !form || !submitButton) return;
function setupCollectModals() {
document.querySelectorAll("[data-collect-open]").forEach(function (openButton) {
var formID = openButton.getAttribute("data-collect-form") || "pdd-form";
var form = document.getElementById(formID);
var modal = document.getElementById(openButton.getAttribute("data-modal-open"));
if (!form || !modal) return;
var count = modal.querySelector("[data-collect-count]");
var submitButton = modal.querySelector("[data-collect-submit]");
if (!count || !submitButton) return;
openButton.addEventListener("click", function () {
count.textContent = checkedCount();
openButton.addEventListener("click", function () {
var fixedCount = openButton.getAttribute("data-collect-count-value");
count.textContent = fixedCount === null ? checkedCount() : fixedCount;
});
form.addEventListener("submit", function (event) {
if (event.submitter !== submitButton) return;
submitButton.disabled = true;
submitButton.setAttribute("aria-busy", "true");
submitButton.textContent = "创建中…";
});
});
form.addEventListener("submit", function (event) {
if (event.submitter !== submitButton) return;
submitButton.disabled = true;
submitButton.setAttribute("aria-busy", "true");
submitButton.textContent = "创建中…";
}
/* Excel 解析可能需要几秒。浏览器校验通过并开始上传后立即锁住提交按钮,
防止采购员因为没有反馈而重复提交同一批文件。 */
function setupUploadFeedback() {
document.querySelectorAll("[data-upload-form]").forEach(function (form) {
var button = form.querySelector("[data-upload-submit]");
if (!button) return;
form.addEventListener("submit", function () {
button.disabled = true;
button.setAttribute("aria-busy", "true");
button.textContent = "导入中…";
});
});
}
@@ -423,7 +442,8 @@
setupUserResetModal();
setupClientAssignmentModal();
setupPurchaseModal();
setupCollectModal();
setupCollectModals();
setupUploadFeedback();
setupModals();
setupRowDetail();
setupCaptchaRefresh();
+120 -1
View File
@@ -7,6 +7,7 @@
{{/* 文案写全「添加 PDD 商品」:这条工具条上还有「创建采集任务」,
两个都以「创建」开头的话,第一次用的人分不清哪个是加商品、哪个是发起采集。 */}}
<button type="button" data-modal-open="create-modal">添加 PDD 商品</button>
<button type="button" data-modal-open="import-modal">批量导入</button>
{{/* 「创建采集任务」和「删除」用的是**同一个表单**,靠按钮上的
formaction 决定提交到哪个地址。这样表格里的勾选框只需要挂一份,
@@ -21,6 +22,7 @@
{{/* 文案是「创建采集任务」不是「采集」:点完只是排了个队,
真正去手机上采要等客户端来领,可能几秒也可能几分钟 */}}
<button type="button" data-modal-open="collect-modal" data-collect-open
data-collect-form="pdd-form"
data-need-checked>创建采集任务</button>
<form class="inline grow" method="get" action="/pdd">
@@ -44,6 +46,61 @@
>删除</button>
</div>
{{/* 导入结果紧跟工具条:采购员上传后先核对统计和错误,再决定是否发采集任务。 */}}
{{with .ImportResult}}
<section class="import-result" aria-labelledby="pdd-import-result-title" aria-live="polite">
<div class="import-result-head">
<div>
<h2 id="pdd-import-result-title">本次导入结果</h2>
<p>
总行数 <strong>{{.TotalRows}}</strong> ·
新建 <strong>{{.CreatedCount}}</strong> ·
已存在 <strong>{{.ExistingCount}}</strong> ·
恢复 <strong>{{.RevivedCount}}</strong> ·
文件内重复 <strong>{{.DuplicateCount}}</strong> ·
失败 <strong>{{len .Failures}}</strong>
</p>
</div>
{{if .GoodsIDs}}
<button type="button" class="primary" data-modal-open="import-collect-modal"
data-collect-open data-collect-form="pdd-import-collect-form"
data-collect-count-value="{{len .GoodsIDs}}">
为本次导入商品创建采集任务
</button>
{{end}}
</div>
<p class="hint">
上传只建立商品档案,不会自动采集。创建任务时,已采集或正在采集的商品仍按现有规则跳过。
</p>
<form id="pdd-import-collect-form" method="post" action="/pdd/collect" hidden>
<input type="hidden" name="csrf_token" value="{{$.CSRFToken}}">
{{range .GoodsIDs}}<input type="hidden" name="ids" value="{{.}}">{{end}}
</form>
{{if .Failures}}
<div class="table-wrap import-failure-table" role="region" aria-label="PDD 导入失败明细" tabindex="0">
<table>
<thead>
<tr><th>Excel 行号</th><th>原始内容</th><th>失败原因与处理建议</th></tr>
</thead>
<tbody>
{{range .Failures}}
<tr class="row-warn">
<td>{{.Row}}</td>
<td class="import-raw">{{.Raw}}</td>
<td class="import-reason">{{.Reason}}</td>
</tr>
{{end}}
</tbody>
</table>
</div>
{{else}}
<p class="import-success">所有非空数据行均已处理,没有失败行。</p>
{{end}}
</section>
{{end}}
{{/* 第二段:表格。双击一行打开弹窗,见 static/js/app.js */}}
<div class="table-wrap" id="pddProductPage">
<table>
@@ -92,7 +149,7 @@
<small>换个采集状态或清空搜索词再试。<a href="/pdd">查看全部</a></small>
{{else}}
还没有 PDD 商品。<br>
<small>点左上角「创建」,粘贴一个拼多多商品链接就行,其余信息采集后自动回填。</small>
<small>点左上角「添加 PDD 商品」粘贴单条链接,或用「批量导入」上传 Excel。</small>
{{end}}
</td>
</tr>
@@ -139,6 +196,35 @@
</div>
</div>
{{/* ── 批量导入弹窗 ─────────────────────────────── */}}
<div class="modal-backdrop" id="import-modal" hidden>
<div class="modal modal-narrow" role="dialog" aria-modal="true" aria-labelledby="import-modal-title">
<div class="modal-head">
<h2 id="import-modal-title">批量导入 PDD 链接</h2>
<button type="button" class="modal-x" data-modal-close aria-label="关闭">×</button>
</div>
<form method="post" action="/pdd/import" enctype="multipart/form-data" data-upload-form>
<input type="hidden" name="csrf_token" value="{{.CSRFToken}}">
<div class="modal-body">
<div class="field">
<label for="pdd-import-file">Excel 文件</label>
<input id="pdd-import-file" type="file" name="file" accept=".xlsx" required autofocus
aria-describedby="pdd-import-help">
</div>
<p class="hint" id="pdd-import-help">
仅支持不超过 10MB 的 <code>.xlsx</code>。第一个非空工作表第一列的表头必须是
“拼多多链接”,每行填写一个带 <code>goods_id=</code> 的完整链接,最多 5000 条;
空工作表和空行会自动忽略。
</p>
</div>
<div class="modal-foot">
<button type="button" data-modal-close>取消</button>
<button type="submit" class="primary" data-upload-submit>开始导入</button>
</div>
</form>
</div>
</div>
{{/* ── 批量采集确认弹窗 ─────────────────────────
客户端是可选项,默认留空。服务端仍会按当前账号重新校验候选范围。 */}}
<div class="modal-backdrop" id="collect-modal" hidden>
@@ -170,6 +256,39 @@
</div>
</div>
{{/* ── 本次导入商品的采集确认弹窗 ─────────────────
IDs 来自刚完成的服务端导入结果,不受当前页分页影响。 */}}
{{with .ImportResult}}{{if .GoodsIDs}}
<div class="modal-backdrop" id="import-collect-modal" hidden>
<div class="modal" role="dialog" aria-modal="true" aria-labelledby="import-collect-modal-title">
<div class="modal-head">
<h2 id="import-collect-modal-title">为本次导入商品创建采集任务</h2>
<button type="button" class="modal-x" data-modal-close aria-label="关闭">×</button>
</div>
<div class="modal-body">
<p>将按现有状态规则处理本次导入的 <strong data-collect-count>{{len .GoodsIDs}}</strong> 个商品。</p>
<div class="field">
<label for="import-collect-client">执行客户端</label>
<select id="import-collect-client" name="client_id" form="pdd-import-collect-form" autofocus>
<option value="">不指定(任意客户端可领取)</option>
{{range $.AssignableClients}}
<option value="{{.ClientID}}">{{.Name}}({{.ClientID}},{{.Status}})</option>
{{end}}
</select>
</div>
<p class="hint">
上传本身没有创建任务。确认后才会建任务;已采集、正在采集和重复项会分别统计并跳过。
</p>
</div>
<div class="modal-foot">
<button type="button" data-modal-close>取消</button>
<button type="submit" form="pdd-import-collect-form" class="primary"
data-collect-submit>确认创建</button>
</div>
</div>
</div>
{{end}}{{end}}
{{/* ── 编辑弹窗的壳子 ───────────────────────────
里面的内容双击行时由 /pdd/detail 返回,前端只负责放进来和显示。 */}}
<div class="modal-backdrop" id="detail-modal" data-detail-url="{{.DetailURL}}" hidden>
BIN
View File
Binary file not shown.