refactor(wms): 合并库存表为统一inventory，重构业务逻辑

1. 合并inventory_batch与serial_number为统一inventory表，用manage_mode区分结构件批次/精密件SN
2. 移除冗余的material_type字段与相关逻辑
3. 重构库存查询、检验、入库出库等业务逻辑适配新表结构
4. 调整前端路由与菜单，拆分基础数据为区域维护和物料档案
5. 优化入库校验逻辑，避免空单问题
6. 调整Vite构建配置，关闭自动清空输出目录
7. 为各模块添加详细中文注释，统一业务术语
8. 生成并更新Ent自动代码文件

bj_power_wms/internal/handler/stocktake.go

@@ -5,8 +5,7 @@ import (
 	"time"
 
 	"bj_power_wms/ent"
-	"bj_power_wms/ent/inventorybatch"
-	"bj_power_wms/ent/serialnumber"
+	"bj_power_wms/ent/inventory"
 	"bj_power_wms/ent/stocktakeitem"
 	"bj_power_wms/ent/stocktakeorder"
 	"bj_power_wms/internal/svc"
@@ -15,10 +14,11 @@ import (
 )
 
 // startStocktakeHandler 发起盘点：冻结当前库存快照
+// 快照统一来自 inventory 一张表；结构件以批次为单位(bookQty=批次余量)，精密件以 SN 为单位(bookQty=1)。
 func startStocktakeHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		var req struct {
-			Operator string `json:"operator"`
+			Operator string   `json:"operator"`
 			Zones    []string `json:"zones"` // 可选：限定盘点区域，空=全部
 		}
 		if err := parseJSON(r, &req); err != nil {
@@ -28,45 +28,36 @@ func startStocktakeHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 
 		no := "ST" + time.Now().Format("20060102150405") + uuid.NewString()[:4]
 
+		q := ctx.EntClient.Inventory.Query().Where(inventory.StatusIn("在库", "锁定"))
+		if len(req.Zones) > 0 {
+			q = q.Where(inventory.ZoneCodeIn(req.Zones...))
+		}
+		rows, err := q.All(ctx0())
+		if err != nil {
+			fail(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
 		count := 0
-
-		// 快照批次库存
-		bq := ctx.EntClient.InventoryBatch.Query()
-		batches, err := bq.All(ctx0())
-		if err != nil {
-			fail(w, http.StatusInternalServerError, err.Error())
-			return
-		}
-		for _, b := range batches {
-			ctx.EntClient.StocktakeItem.Create().
-				SetStocktakeNo(no).
-				SetTargetType("BATCH").
-				SetTargetID(b.BatchNo).
-				SetNillableMaterialCode(strPtr(b.MaterialCode)).
-				SetNillableZoneCode(strPtr(b.ZoneCode)).
-				SetBookQty(b.Quantity).
-				SaveX(ctx0())
-			count++
-		}
-
-		// 快照 SN 库存
-		sns, err := ctx.EntClient.SerialNumber.Query().All(ctx0())
-		if err != nil {
-			fail(w, http.StatusInternalServerError, err.Error())
-			return
-		}
-		for _, s := range sns {
-			// 仅在库/锁定的才算库存；出库的不进快照
-			if s.Status == "出库" || s.Status == "报废" {
+		for _, inv := range rows {
+			tt := "BATCH"
+			tid := inv.BatchNo
+			book := inv.Quantity
+			if inv.ManageMode == 2 {
+				tt = "SN"
+				tid = inv.SnCode
+				book = 1
+			}
+			if tid == "" {
 				continue
 			}
 			ctx.EntClient.StocktakeItem.Create().
 				SetStocktakeNo(no).
-				SetTargetType("SN").
-				SetTargetID(s.SnCode).
-				SetNillableMaterialCode(strPtr(s.MaterialCode)).
-				SetNillableZoneCode(strPtr(s.CurrentZone)).
-				SetBookQty(1).
+				SetTargetType(tt).
+				SetTargetID(tid).
+				SetNillableMaterialCode(strPtr(inv.MaterialCode)).
+				SetNillableZoneCode(strPtr(inv.ZoneCode)).
+				SetBookQty(book).
 				SaveX(ctx0())
 			count++
 		}
@@ -137,15 +128,19 @@ func recordStocktakeHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 			ExecX(ctx0())
 
 		ok(w, map[string]any{
-			"targetId":  req.TargetId,
-			"bookQty":   item.BookQty,
+			"targetId":   req.TargetId,
+			"bookQty":    item.BookQty,
 			"scannedQty": qty,
-			"diffQty":   diff,
+			"diffQty":    diff,
 		})
 	}
 }
 
-// finishStocktakeHandler 完成盘点：统计差异、按需修正库存
+// finishStocktakeHandler 完成盘点：统计差异、按需按"增量"修正库存
+// 调整原则（问题2）：绝不覆盖最终值，只按差异增减——quantity += diffQty。
+//   - 结构件：批次余量 +diff（盘盈）/-diff（盘亏）
+//   - 精密件：差异为 -1（账面1实盘0）按报废处理；其余差异仅记录
+// 整个调整包在事务内，保证盘点修正原子性。
 func finishStocktakeHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		var req struct {
@@ -183,6 +178,23 @@ func finishStocktakeHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 		diffs := []diffRow{}
 		counted := 0
 		uncounted := 0
+
+		// 需要调整时开启事务
+		var tx *ent.Tx
+		if req.Adjust {
+			tx, err = ctx.EntClient.Tx(ctx0())
+			if err != nil {
+				fail(w, http.StatusInternalServerError, "开启事务失败: "+err.Error())
+				return
+			}
+		}
+		committed := false
+		defer func() {
+			if tx != nil && !committed {
+				_ = tx.Rollback()
+			}
+		}()
+
 		for _, it := range items {
 			if !it.Counted {
 				uncounted++
@@ -193,22 +205,36 @@ func finishStocktakeHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 				diffs = append(diffs, diffRow{it.TargetID, it.TargetType, it.BookQty, it.ScannedQty, it.DiffQty})
 				if req.Adjust {
 					if it.TargetType == "BATCH" {
-						b, err := ctx.EntClient.InventoryBatch.Query().
-							Where(inventorybatch.BatchNoEQ(it.TargetID)).Only(ctx0())
-						if err == nil && b.Quantity+it.DiffQty >= b.LockedQty {
-							ctx.EntClient.InventoryBatch.UpdateOneID(b.ID).
-								SetQuantity(b.Quantity + it.DiffQty).ExecX(ctx0())
+						// 增量调整：quantity += diffQty（不覆盖终值）
+						if _, e := tx.Inventory.Update().
+							Where(inventory.ManageModeEQ(1), inventory.BatchNoEQ(it.TargetID)).
+							AddQuantity(it.DiffQty).
+							Save(ctx0()); e != nil {
+							fail(w, http.StatusInternalServerError, "调整批次失败: "+e.Error())
+							return
+						}
+					} else if it.TargetType == "SN" && it.DiffQty == -1 {
+						// 账面1实盘0 → 报废
+						if _, e := tx.Inventory.Update().
+							Where(inventory.ManageModeEQ(2), inventory.SnCodeEQ(it.TargetID), inventory.StatusIn("在库", "锁定")).
+							SetStatus("报废").SetLockedQty(0).
+							Save(ctx0()); e != nil {
+							fail(w, http.StatusInternalServerError, "报废 SN 失败: "+e.Error())
+							return
 						}
-					} else if it.DiffQty == -1 {
-						// 账面1实盘0 → 报废标记
-						ctx.EntClient.SerialNumber.Update().
-							Where(serialnumber.SnCodeEQ(it.TargetID), serialnumber.StatusIn("在库", "锁定")).
-							SetStatus("报废").ExecX(ctx0())
 					}
 				}
 			}
 		}
 
+		if req.Adjust {
+			if err = tx.Commit(); err != nil {
+				fail(w, http.StatusInternalServerError, "提交事务失败: "+err.Error())
+				return
+			}
+			committed = true
+		}
+
 		ctx.EntClient.StocktakeOrder.UpdateOneID(order.ID).
 			SetStatus("已完成").
 			SetFinishedAt(time.Now().Unix()).