feat(admin): 运营后台（登录/查看/审核编辑/补全）+ 写入API + 审计留痕

Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>

api/internal/adminstore/adminstore.go

@@ -0,0 +1,282 @@
+// Package adminstore is the read/write data-access layer for the admin console.
+// Unlike the public store (read-only), it performs INSERT/UPDATE/DELETE and
+// records field-level provenance (source = "manual") plus an audit_log entry
+// for every write, then recomputes product.quality_score.
+package adminstore
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"strconv"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// ErrNotFound is returned when a requested row does not exist.
+var ErrNotFound = errors.New("not found")
+
+// Store wraps a pgx pool for admin operations.
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+// New constructs an admin Store.
+func New(pool *pgxpool.Pool) *Store { return &Store{pool: pool} }
+
+// Ping verifies DB connectivity.
+func (s *Store) Ping(ctx context.Context) error { return s.pool.Ping(ctx) }
+
+// CompletenessFields mirrors ingestion/opengoods/etl/quality.py COMPLETENESS_FIELDS.
+var CompletenessFields = []string{
+	"name", "gtin", "brand", "category", "net_content",
+	"country_of_origin", "nutriments", "ingredients", "image",
+}
+
+// ---------- list ----------
+
+// ProductRow is a list-view row for the admin product table.
+type ProductRow struct {
+	ID           string   `json:"id"`
+	GTIN         *string  `json:"gtin"`
+	Name         string   `json:"name"`
+	Brand        *string  `json:"brand"`
+	CategoryPath *string  `json:"category_path"`
+	Status       string   `json:"status"`
+	QualityScore float64  `json:"quality_score"`
+	Missing      []string `json:"missing"`
+	UpdatedAt    string   `json:"updated_at"`
+}
+
+// ListProducts returns a paginated, optionally name/gtin-filtered list.
+func (s *Store) ListProducts(ctx context.Context, q string, limit, offset int) ([]ProductRow, int, error) {
+	args := []any{}
+	where := "WHERE 1=1"
+	if q != "" {
+		args = append(args, q)
+		where += " AND (p.name ILIKE '%' || $1 || '%' OR p.gtin ILIKE '%' || $1 || '%')"
+	}
+
+	var total int
+	if err := s.pool.QueryRow(ctx, "SELECT count(*) FROM product p "+where, args...).Scan(&total); err != nil {
+		return nil, 0, err
+	}
+
+	args = append(args, limit, offset)
+	sql := `
+SELECT p.id, p.gtin, p.name, b.name, c.path::text, p.status, p.quality_score,
+       p.updated_at,
+       (p.brand_id IS NOT NULL) AS has_brand,
+       (p.category_id IS NOT NULL) AS has_cat,
+       (p.net_content_canonical IS NOT NULL) AS has_net,
+       (p.country_of_origin IS NOT NULL AND p.country_of_origin <> '') AS has_country,
+       (f.nutriments IS NOT NULL AND f.nutriments::text <> '{}') AS has_nutri,
+       (f.ingredients_text IS NOT NULL AND f.ingredients_text <> '') AS has_ing,
+       EXISTS (SELECT 1 FROM product_image pi WHERE pi.product_id = p.id) AS has_img
+FROM product p
+LEFT JOIN brand b ON b.id = p.brand_id
+LEFT JOIN category c ON c.id = p.category_id
+LEFT JOIN food_detail f ON f.product_id = p.id ` + where +
+		" ORDER BY p.updated_at DESC LIMIT $" + strconv.Itoa(len(args)-1) + " OFFSET $" + strconv.Itoa(len(args))
+
+	rows, err := s.pool.Query(ctx, sql, args...)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer rows.Close()
+
+	out := []ProductRow{}
+	for rows.Next() {
+		var r ProductRow
+		var hasBrand, hasCat, hasNet, hasCountry, hasNutri, hasIng, hasImg bool
+		var updated time.Time
+		if err := rows.Scan(&r.ID, &r.GTIN, &r.Name, &r.Brand, &r.CategoryPath, &r.Status,
+			&r.QualityScore, &updated, &hasBrand, &hasCat, &hasNet, &hasCountry,
+			&hasNutri, &hasIng, &hasImg); err != nil {
+			return nil, 0, err
+		}
+		r.UpdatedAt = updated.Format(time.RFC3339)
+		present := map[string]bool{
+			"name":              r.Name != "",
+			"gtin":              r.GTIN != nil && *r.GTIN != "",
+			"brand":             hasBrand,
+			"category":          hasCat,
+			"net_content":       hasNet,
+			"country_of_origin": hasCountry,
+			"nutriments":        hasNutri,
+			"ingredients":       hasIng,
+			"image":             hasImg,
+		}
+		r.Missing = []string{}
+		for _, f := range CompletenessFields {
+			if !present[f] {
+				r.Missing = append(r.Missing, f)
+			}
+		}
+		out = append(out, r)
+	}
+	return out, total, rows.Err()
+}
+
+// ---------- detail ----------
+
+// ProductImage is one image row.
+type ProductImage struct {
+	ID      string  `json:"id"`
+	URL     string  `json:"url"`
+	Kind    string  `json:"kind"`
+	License *string `json:"license"`
+}
+
+// MSRP is one suggested-retail-price snapshot.
+type MSRP struct {
+	ID            string  `json:"id"`
+	Amount        float64 `json:"amount"`
+	Currency      string  `json:"currency"`
+	Region        string  `json:"region"`
+	EffectiveDate *string `json:"effective_date"`
+	SourceURL     *string `json:"source_url"`
+	Note          *string `json:"note"`
+}
+
+// ProductDetail is the full editable view of a product.
+type ProductDetail struct {
+	ID              string         `json:"id"`
+	GTIN            *string        `json:"gtin"`
+	Name            string         `json:"name"`
+	BrandID         *string        `json:"brand_id"`
+	Brand           *string        `json:"brand"`
+	CategoryID      *string        `json:"category_id"`
+	CategoryPath    *string        `json:"category_path"`
+	NetContentValue *float64       `json:"net_content_value"`
+	NetContentUnit  *string        `json:"net_content_unit"`
+	CountryOfOrigin *string        `json:"country_of_origin"`
+	Status          string         `json:"status"`
+	QualityScore    float64        `json:"quality_score"`
+	IngredientsText *string        `json:"ingredients_text"`
+	Allergens       []string       `json:"allergens"`
+	Additives       []string       `json:"additives"`
+	Nutriments      map[string]any `json:"nutriments"`
+	NutritionBasis  *string        `json:"nutrition_basis"`
+	ServingSize     *string        `json:"serving_size"`
+	NutriScore      *string        `json:"nutri_score"`
+	Images          []ProductImage `json:"images"`
+	MSRP            []MSRP         `json:"msrp"`
+	Missing         []string       `json:"missing"`
+	UpdatedAt       string         `json:"updated_at"`
+}
+
+// GetProduct returns the full editable detail for one product.
+func (s *Store) GetProduct(ctx context.Context, id string) (*ProductDetail, error) {
+	var d ProductDetail
+	var nutriments []byte
+	var updated time.Time
+	err := s.pool.QueryRow(ctx, `
+SELECT p.id, p.gtin, p.name, p.brand_id, b.name, p.category_id, c.path::text,
+       p.net_content_value, p.net_content_unit, p.country_of_origin, p.status,
+       p.quality_score, p.updated_at,
+       f.ingredients_text, f.allergens, f.additives, f.nutriments,
+       f.nutrition_basis, f.serving_size, f.nutri_score
+FROM product p
+LEFT JOIN brand b ON b.id = p.brand_id
+LEFT JOIN category c ON c.id = p.category_id
+LEFT JOIN food_detail f ON f.product_id = p.id
+WHERE p.id = $1`, id).Scan(
+		&d.ID, &d.GTIN, &d.Name, &d.BrandID, &d.Brand, &d.CategoryID, &d.CategoryPath,
+		&d.NetContentValue, &d.NetContentUnit, &d.CountryOfOrigin, &d.Status,
+		&d.QualityScore, &updated,
+		&d.IngredientsText, &d.Allergens, &d.Additives, &nutriments,
+		&d.NutritionBasis, &d.ServingSize, &d.NutriScore,
+	)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, ErrNotFound
+	}
+	if err != nil {
+		return nil, err
+	}
+	d.UpdatedAt = updated.Format(time.RFC3339)
+	if len(nutriments) > 0 {
+		_ = json.Unmarshal(nutriments, &d.Nutriments)
+	}
+	if d.Allergens == nil {
+		d.Allergens = []string{}
+	}
+	if d.Additives == nil {
+		d.Additives = []string{}
+	}
+
+	imgs, err := s.listImages(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	d.Images = imgs
+
+	msrps, err := s.listMSRP(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	d.MSRP = msrps
+
+	d.Missing = missingFromDetail(&d)
+	return &d, nil
+}
+
+func missingFromDetail(d *ProductDetail) []string {
+	present := map[string]bool{
+		"name":              d.Name != "",
+		"gtin":              d.GTIN != nil && *d.GTIN != "",
+		"brand":             d.BrandID != nil,
+		"category":          d.CategoryID != nil,
+		"net_content":       d.NetContentValue != nil,
+		"country_of_origin": d.CountryOfOrigin != nil && *d.CountryOfOrigin != "",
+		"nutriments":        len(d.Nutriments) > 0,
+		"ingredients":       d.IngredientsText != nil && *d.IngredientsText != "",
+		"image":             len(d.Images) > 0,
+	}
+	missing := []string{}
+	for _, f := range CompletenessFields {
+		if !present[f] {
+			missing = append(missing, f)
+		}
+	}
+	return missing
+}
+
+func (s *Store) listImages(ctx context.Context, productID string) ([]ProductImage, error) {
+	rows, err := s.pool.Query(ctx,
+		"SELECT id, url, kind, license FROM product_image WHERE product_id = $1 ORDER BY id", productID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := []ProductImage{}
+	for rows.Next() {
+		var im ProductImage
+		if err := rows.Scan(&im.ID, &im.URL, &im.Kind, &im.License); err != nil {
+			return nil, err
+		}
+		out = append(out, im)
+	}
+	return out, rows.Err()
+}
+
+func (s *Store) listMSRP(ctx context.Context, productID string) ([]MSRP, error) {
+	rows, err := s.pool.Query(ctx, `
+SELECT id, amount, currency, region, effective_date::text, source_url, note
+FROM product_msrp WHERE product_id = $1 ORDER BY effective_date DESC NULLS LAST`, productID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := []MSRP{}
+	for rows.Next() {
+		var m MSRP
+		if err := rows.Scan(&m.ID, &m.Amount, &m.Currency, &m.Region, &m.EffectiveDate, &m.SourceURL, &m.Note); err != nil {
+			return nil, err
+		}
+		out = append(out, m)
+	}
+	return out, rows.Err()
+}

api/internal/adminstore/quality.go

@@ -0,0 +1,137 @@
+package adminstore
+
+import (
+	"context"
+	"math"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+)
+
+// Quality weights mirror ingestion/opengoods/etl/quality.py.
+const (
+	wCompleteness = 0.4
+	wSourceTrust  = 0.3
+	wAgreement    = 0.2
+	wFreshness    = 0.1
+)
+
+// queryer is satisfied by both *pgxpool.Pool and pgx.Tx.
+type queryer interface {
+	QueryRow(ctx context.Context, sql string, args ...any) pgx.Row
+}
+
+func agreementFromSources(n int) float64 {
+	switch {
+	case n <= 1:
+		return 0.5
+	case n == 2:
+		return 0.8
+	default:
+		return 1.0
+	}
+}
+
+func freshnessFromAge(ageDays *float64) float64 {
+	if ageDays == nil {
+		return 0.5
+	}
+	d := *ageDays
+	switch {
+	case d <= 30:
+		return 1.0
+	case d <= 180:
+		return 0.8
+	case d <= 365:
+		return 0.6
+	case d <= 730:
+		return 0.4
+	default:
+		return 0.2
+	}
+}
+
+func (s *Store) computeQuality(ctx context.Context, q queryer, productID string) (float64, error) {
+	var name, country *string
+	var gtin *string
+	var brandID, categoryID *string
+	var netCanonical *float64
+	var ingredients *string
+	var hasNutri, hasImage bool
+	err := q.QueryRow(ctx, `
+SELECT p.name, p.gtin, p.brand_id, p.category_id, p.net_content_canonical,
+       p.country_of_origin, f.ingredients_text,
+       (f.nutriments IS NOT NULL AND f.nutriments::text <> '{}'),
+       EXISTS (SELECT 1 FROM product_image pi WHERE pi.product_id = p.id)
+FROM product p LEFT JOIN food_detail f ON f.product_id = p.id
+WHERE p.id = $1`, productID).Scan(
+		&name, &gtin, &brandID, &categoryID, &netCanonical, &country,
+		&ingredients, &hasNutri, &hasImage)
+	if err != nil {
+		return 0, err
+	}
+
+	present := 0
+	bump := func(ok bool) {
+		if ok {
+			present++
+		}
+	}
+	bump(name != nil && *name != "")
+	bump(gtin != nil && *gtin != "")
+	bump(brandID != nil)
+	bump(categoryID != nil)
+	bump(netCanonical != nil)
+	bump(country != nil && *country != "")
+	bump(hasNutri)
+	bump(ingredients != nil && *ingredients != "")
+	bump(hasImage)
+	completeness := float64(present) / float64(len(CompletenessFields))
+
+	var sourceCount int
+	var sourceTrust *float64
+	var lastFetched *time.Time
+	err = q.QueryRow(ctx, `
+SELECT count(DISTINCT ps.source_id), COALESCE(max(s.trust_weight),0), max(ps.fetched_at)
+FROM product_source ps LEFT JOIN source s ON s.id = ps.source_id
+WHERE ps.product_id = $1`, productID).Scan(&sourceCount, &sourceTrust, &lastFetched)
+	if err != nil {
+		return 0, err
+	}
+	trust := 0.0
+	if sourceTrust != nil {
+		trust = *sourceTrust
+	}
+
+	var ageDays *float64
+	if lastFetched != nil {
+		d := time.Since(*lastFetched).Hours() / 24.0
+		if d < 0 {
+			d = 0
+		}
+		ageDays = &d
+	}
+
+	raw := wCompleteness*completeness + wSourceTrust*trust +
+		wAgreement*agreementFromSources(sourceCount) + wFreshness*freshnessFromAge(ageDays)
+	raw = math.Max(0, math.Min(1, raw))
+	return math.Round(raw*1000) / 1000, nil
+}
+
+func (s *Store) recomputeQualityTx(ctx context.Context, tx pgx.Tx, productID string) (float64, error) {
+	v, err := s.computeQuality(ctx, tx, productID)
+	if err != nil {
+		return 0, err
+	}
+	_, err = tx.Exec(ctx, "UPDATE product SET quality_score=$1 WHERE id=$2", v, productID)
+	return v, err
+}
+
+func (s *Store) recomputeQuality(ctx context.Context, productID string) (float64, error) {
+	v, err := s.computeQuality(ctx, s.pool, productID)
+	if err != nil {
+		return 0, err
+	}
+	_, err = s.pool.Exec(ctx, "UPDATE product SET quality_score=$1 WHERE id=$2", v, productID)
+	return v, err
+}

api/internal/adminstore/quality_test.go

@@ -0,0 +1,30 @@
+package adminstore
+
+import "testing"
+
+func TestAgreementFromSources(t *testing.T) {
+	cases := map[int]float64{0: 0.5, 1: 0.5, 2: 0.8, 3: 1.0, 9: 1.0}
+	for n, want := range cases {
+		if got := agreementFromSources(n); got != want {
+			t.Errorf("agreementFromSources(%d) = %v, want %v", n, got, want)
+		}
+	}
+}
+
+func TestFreshnessFromAge(t *testing.T) {
+	mk := func(d float64) *float64 { return &d }
+	if got := freshnessFromAge(nil); got != 0.5 {
+		t.Errorf("nil age = %v, want 0.5", got)
+	}
+	cases := []struct {
+		days float64
+		want float64
+	}{
+		{10, 1.0}, {30, 1.0}, {100, 0.8}, {300, 0.6}, {500, 0.4}, {1000, 0.2},
+	}
+	for _, c := range cases {
+		if got := freshnessFromAge(mk(c.days)); got != c.want {
+			t.Errorf("freshnessFromAge(%v) = %v, want %v", c.days, got, c.want)
+		}
+	}
+}

api/internal/adminstore/write.go

@@ -0,0 +1,415 @@
+package adminstore
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"strings"
+
+	"github.com/jackc/pgx/v5"
+)
+
+// ProductInput is the editable payload accepted from the admin UI.
+type ProductInput struct {
+	GTIN            *string        `json:"gtin"`
+	Name            string         `json:"name"`
+	BrandID         *string        `json:"brand_id"`
+	BrandName       *string        `json:"brand_name"`
+	CategoryID      *string        `json:"category_id"`
+	NetContentValue *float64       `json:"net_content_value"`
+	NetContentUnit  *string        `json:"net_content_unit"`
+	CountryOfOrigin *string        `json:"country_of_origin"`
+	Status          string         `json:"status"`
+	IngredientsText *string        `json:"ingredients_text"`
+	Allergens       []string       `json:"allergens"`
+	Additives       []string       `json:"additives"`
+	Nutriments      map[string]any `json:"nutriments"`
+	NutritionBasis  *string        `json:"nutrition_basis"`
+	ServingSize     *string        `json:"serving_size"`
+	NutriScore      *string        `json:"nutri_score"`
+}
+
+func normBrand(name string) string { return strings.Join(strings.Fields(strings.ToLower(name)), " ") }
+
+func (s *Store) ensureBrand(ctx context.Context, tx pgx.Tx, name string) (string, error) {
+	var id string
+	err := tx.QueryRow(ctx, `
+INSERT INTO brand (name, normalized_name) VALUES ($1, $2)
+ON CONFLICT (normalized_name) DO UPDATE SET name = brand.name
+RETURNING id`, name, normBrand(name)).Scan(&id)
+	return id, err
+}
+
+func (s *Store) manualSourceID(ctx context.Context, tx pgx.Tx) (string, error) {
+	var id string
+	err := tx.QueryRow(ctx, "SELECT id FROM source WHERE name = 'manual'").Scan(&id)
+	return id, err
+}
+
+// netCanonical converts value+unit to the canonical base unit via the unit table.
+func (s *Store) netCanonical(ctx context.Context, tx pgx.Tx, value *float64, unit *string) (*float64, error) {
+	if value == nil || unit == nil || *unit == "" {
+		return nil, nil
+	}
+	var factor *float64
+	err := tx.QueryRow(ctx, "SELECT to_canonical_factor FROM unit WHERE code = $1", *unit).Scan(&factor)
+	if errors.Is(err, pgx.ErrNoRows) || factor == nil {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	c := *value * *factor
+	return &c, nil
+}
+
+// UpdateProduct applies an edit, records provenance + audit, and recomputes quality.
+func (s *Store) UpdateProduct(ctx context.Context, id, actor string, in ProductInput) (*ProductDetail, error) {
+	before, err := s.GetProduct(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback(ctx)
+
+	// Resolve brand (create-by-name takes precedence over id).
+	brandID := in.BrandID
+	if in.BrandName != nil && strings.TrimSpace(*in.BrandName) != "" {
+		bid, err := s.ensureBrand(ctx, tx, strings.TrimSpace(*in.BrandName))
+		if err != nil {
+			return nil, err
+		}
+		brandID = &bid
+	}
+
+	// Resolve category gpc brick code.
+	var gpc *string
+	if in.CategoryID != nil && *in.CategoryID != "" {
+		if err := tx.QueryRow(ctx, "SELECT gpc_brick_code FROM category WHERE id = $1", *in.CategoryID).Scan(&gpc); err != nil && !errors.Is(err, pgx.ErrNoRows) {
+			return nil, err
+		}
+	}
+
+	canonical, err := s.netCanonical(ctx, tx, in.NetContentValue, in.NetContentUnit)
+	if err != nil {
+		return nil, err
+	}
+
+	status := in.Status
+	if status == "" {
+		status = before.Status
+	}
+
+	_, err = tx.Exec(ctx, `
+UPDATE product SET gtin=$1, name=$2, brand_id=$3, category_id=$4, gpc_brick_code=$5,
+   net_content_value=$6, net_content_unit=$7, net_content_canonical=$8,
+   country_of_origin=$9, status=$10
+WHERE id=$11`,
+		in.GTIN, in.Name, brandID, in.CategoryID, gpc,
+		in.NetContentValue, in.NetContentUnit, canonical,
+		in.CountryOfOrigin, status, id)
+	if err != nil {
+		return nil, err
+	}
+
+	var nutriJSON []byte
+	if in.Nutriments != nil {
+		nutriJSON, _ = json.Marshal(in.Nutriments)
+	}
+	allergens := in.Allergens
+	if allergens == nil {
+		allergens = []string{}
+	}
+	additives := in.Additives
+	if additives == nil {
+		additives = []string{}
+	}
+	_, err = tx.Exec(ctx, `
+INSERT INTO food_detail (product_id, ingredients_text, allergens, additives,
+   nutriments, nutrition_basis, serving_size, nutri_score)
+VALUES ($1,$2,$3,$4,$5,$6,$7,$8)
+ON CONFLICT (product_id) DO UPDATE SET
+   ingredients_text=EXCLUDED.ingredients_text,
+   allergens=EXCLUDED.allergens,
+   additives=EXCLUDED.additives,
+   nutriments=EXCLUDED.nutriments,
+   nutrition_basis=EXCLUDED.nutrition_basis,
+   serving_size=EXCLUDED.serving_size,
+   nutri_score=EXCLUDED.nutri_score`,
+		id, in.IngredientsText, allergens, additives,
+		nutriJSON, in.NutritionBasis, in.ServingSize, in.NutriScore)
+	if err != nil {
+		return nil, err
+	}
+
+	if _, err := s.recomputeQualityTx(ctx, tx, id); err != nil {
+		return nil, err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return nil, err
+	}
+
+	after, err := s.GetProduct(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	changed := diffFields(before, after)
+	if len(changed) > 0 {
+		if err := s.recordProvenance(ctx, id, changed); err != nil {
+			return nil, err
+		}
+	}
+	if err := s.writeAudit(ctx, actor, "update", "product", &id, changed, before, after); err != nil {
+		return nil, err
+	}
+	return after, nil
+}
+
+func strEq(a, b *string) bool {
+	if a == nil && b == nil {
+		return true
+	}
+	if a == nil || b == nil {
+		return false
+	}
+	return *a == *b
+}
+
+func floatEq(a, b *float64) bool {
+	if a == nil && b == nil {
+		return true
+	}
+	if a == nil || b == nil {
+		return false
+	}
+	return *a == *b
+}
+
+func diffFields(a, b *ProductDetail) []string {
+	changed := []string{}
+	add := func(name string, eq bool) {
+		if !eq {
+			changed = append(changed, name)
+		}
+	}
+	add("gtin", strEq(a.GTIN, b.GTIN))
+	add("name", a.Name == b.Name)
+	add("brand", strEq(a.BrandID, b.BrandID))
+	add("category", strEq(a.CategoryID, b.CategoryID))
+	add("net_content", floatEq(a.NetContentValue, b.NetContentValue) && strEq(a.NetContentUnit, b.NetContentUnit))
+	add("country_of_origin", strEq(a.CountryOfOrigin, b.CountryOfOrigin))
+	add("status", a.Status == b.Status)
+	add("ingredients", strEq(a.IngredientsText, b.IngredientsText))
+	ja, _ := json.Marshal(a.Nutriments)
+	jb, _ := json.Marshal(b.Nutriments)
+	add("nutriments", string(ja) == string(jb))
+	add("nutrition_basis", strEq(a.NutritionBasis, b.NutritionBasis))
+	add("serving_size", strEq(a.ServingSize, b.ServingSize))
+	add("nutri_score", strEq(a.NutriScore, b.NutriScore))
+	return changed
+}
+
+func (s *Store) recordProvenance(ctx context.Context, productID string, fields []string) error {
+	var srcID string
+	if err := s.pool.QueryRow(ctx, "SELECT id FROM source WHERE name = 'manual'").Scan(&srcID); err != nil {
+		return err
+	}
+	_, err := s.pool.Exec(ctx, `
+INSERT INTO product_source (product_id, source_id, url, fields, fetched_at, raw)
+VALUES ($1, $2, NULL, $3, now(), NULL)`, productID, srcID, fields)
+	return err
+}
+
+func (s *Store) writeAudit(ctx context.Context, actor, action, entity string, entityID *string, fields []string, before, after any) error {
+	bj, _ := json.Marshal(before)
+	aj, _ := json.Marshal(after)
+	if fields == nil {
+		fields = []string{}
+	}
+	_, err := s.pool.Exec(ctx, `
+INSERT INTO audit_log (actor, action, entity, entity_id, fields, before, after)
+VALUES ($1,$2,$3,$4,$5,$6,$7)`, actor, action, entity, entityID, fields, bj, aj)
+	return err
+}
+
+// ---------- images ----------
+
+// AddImage inserts an image URL (manual source) and recomputes quality.
+func (s *Store) AddImage(ctx context.Context, productID, actor, url, kind string) (*ProductImage, error) {
+	if kind == "" {
+		kind = "other"
+	}
+	var srcID string
+	if err := s.pool.QueryRow(ctx, "SELECT id FROM source WHERE name = 'manual'").Scan(&srcID); err != nil {
+		return nil, err
+	}
+	var im ProductImage
+	err := s.pool.QueryRow(ctx, `
+INSERT INTO product_image (product_id, url, kind, license, source_id)
+VALUES ($1,$2,$3,NULL,$4) RETURNING id, url, kind, license`,
+		productID, url, kind, srcID).Scan(&im.ID, &im.URL, &im.Kind, &im.License)
+	if err != nil {
+		return nil, err
+	}
+	if _, err := s.recomputeQuality(ctx, productID); err != nil {
+		return nil, err
+	}
+	_ = s.writeAudit(ctx, actor, "add_image", "product", &productID, []string{"image"}, nil, im)
+	return &im, nil
+}
+
+// DeleteImage removes an image and recomputes quality.
+func (s *Store) DeleteImage(ctx context.Context, productID, imageID, actor string) error {
+	ct, err := s.pool.Exec(ctx, "DELETE FROM product_image WHERE id=$1 AND product_id=$2", imageID, productID)
+	if err != nil {
+		return err
+	}
+	if ct.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	if _, err := s.recomputeQuality(ctx, productID); err != nil {
+		return err
+	}
+	_ = s.writeAudit(ctx, actor, "delete_image", "product", &productID, []string{"image"}, map[string]string{"image_id": imageID}, nil)
+	return nil
+}
+
+// ---------- msrp ----------
+
+// MSRPInput is the payload for adding an MSRP snapshot.
+type MSRPInput struct {
+	Amount        float64 `json:"amount"`
+	Currency      string  `json:"currency"`
+	Region        string  `json:"region"`
+	EffectiveDate *string `json:"effective_date"`
+	SourceURL     *string `json:"source_url"`
+	Note          *string `json:"note"`
+}
+
+// AddMSRP inserts a suggested-retail-price snapshot.
+func (s *Store) AddMSRP(ctx context.Context, productID, actor string, in MSRPInput) (*MSRP, error) {
+	if in.Currency == "" {
+		in.Currency = "CNY"
+	}
+	if in.Region == "" {
+		in.Region = "CN"
+	}
+	var srcID string
+	_ = s.pool.QueryRow(ctx, "SELECT id FROM source WHERE name = 'manual'").Scan(&srcID)
+	var m MSRP
+	err := s.pool.QueryRow(ctx, `
+INSERT INTO product_msrp (product_id, amount, currency, region, source_id, source_url, effective_date, note)
+VALUES ($1,$2,$3,$4,$5,$6,$7,$8)
+RETURNING id, amount, currency, region, effective_date::text, source_url, note`,
+		productID, in.Amount, in.Currency, in.Region, srcID, in.SourceURL, in.EffectiveDate, in.Note).
+		Scan(&m.ID, &m.Amount, &m.Currency, &m.Region, &m.EffectiveDate, &m.SourceURL, &m.Note)
+	if err != nil {
+		return nil, err
+	}
+	_ = s.writeAudit(ctx, actor, "add_msrp", "product", &productID, []string{"msrp"}, nil, m)
+	return &m, nil
+}
+
+// DeleteMSRP removes an MSRP snapshot.
+func (s *Store) DeleteMSRP(ctx context.Context, productID, msrpID, actor string) error {
+	ct, err := s.pool.Exec(ctx, "DELETE FROM product_msrp WHERE id=$1 AND product_id=$2", msrpID, productID)
+	if err != nil {
+		return err
+	}
+	if ct.RowsAffected() == 0 {
+		return ErrNotFound
+	}
+	_ = s.writeAudit(ctx, actor, "delete_msrp", "product", &productID, []string{"msrp"}, map[string]string{"msrp_id": msrpID}, nil)
+	return nil
+}
+
+// ---------- dictionaries ----------
+
+// Brand is a brand option for the edit form.
+type Brand struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+}
+
+// ListBrands returns all brands ordered by name.
+func (s *Store) ListBrands(ctx context.Context) ([]Brand, error) {
+	rows, err := s.pool.Query(ctx, "SELECT id, name FROM brand ORDER BY name")
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := []Brand{}
+	for rows.Next() {
+		var b Brand
+		if err := rows.Scan(&b.ID, &b.Name); err != nil {
+			return nil, err
+		}
+		out = append(out, b)
+	}
+	return out, rows.Err()
+}
+
+// Category is a category option for the edit form.
+type Category struct {
+	ID     string  `json:"id"`
+	NameZH string  `json:"name_zh"`
+	NameEN *string `json:"name_en"`
+	Path   string  `json:"path"`
+	Level  int     `json:"level"`
+}
+
+// ListCategories returns the full category tree.
+func (s *Store) ListCategories(ctx context.Context) ([]Category, error) {
+	rows, err := s.pool.Query(ctx,
+		"SELECT id, name_zh, name_en, path::text, level FROM category ORDER BY path")
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := []Category{}
+	for rows.Next() {
+		var c Category
+		if err := rows.Scan(&c.ID, &c.NameZH, &c.NameEN, &c.Path, &c.Level); err != nil {
+			return nil, err
+		}
+		out = append(out, c)
+	}
+	return out, rows.Err()
+}
+
+// ---------- audit ----------
+
+// AuditEntry is one audit-log row for the history view.
+type AuditEntry struct {
+	ID        string   `json:"id"`
+	Actor     string   `json:"actor"`
+	Action    string   `json:"action"`
+	Fields    []string `json:"fields"`
+	CreatedAt string   `json:"created_at"`
+}
+
+// ListAudit returns audit history for one product, newest first.
+func (s *Store) ListAudit(ctx context.Context, productID string, limit int) ([]AuditEntry, error) {
+	rows, err := s.pool.Query(ctx, `
+SELECT id, actor, action, fields, created_at::text
+FROM audit_log WHERE entity='product' AND entity_id=$1
+ORDER BY created_at DESC LIMIT $2`, productID, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := []AuditEntry{}
+	for rows.Next() {
+		var e AuditEntry
+		if err := rows.Scan(&e.ID, &e.Actor, &e.Action, &e.Fields, &e.CreatedAt); err != nil {
+			return nil, err
+		}
+		out = append(out, e)
+	}
+	return out, rows.Err()
+}