# Scrap Warehouse Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Add a fifth "废料库" to 嘉恒仓库 for production scrap, offcuts, defective goods, opening stock, outsourcing scrap return, and scrap sale outbound.

**Architecture:** Reuse the current warehouse ledger architecture: one new warehouse type `SCRAP`, one tab in `InventoryLedgerView.vue`, existing `wh_stock_lot` / `wh_stock_balance` / `wh_inventory_txn` tables, existing stocktake flow, and existing opening inventory import/export. Scrap inventory is weight-only and can reference existing material/product items rather than introducing a new scrap catalog.

**Tech Stack:** FastAPI, SQLAlchemy, Pydantic schemas, MySQL-compatible SQL patches, Vue 3 Composition API, Vite, Node assert-based frontend checks, Python unittest backend checks.

---

## File Structure

All paths are relative to `/Users/souplearn/Gitlab/py/ForgeFlow-ERP`.

- Modify `backend/app/api/routes/inventory.py`
  - Add `SCRAP` to warehouse labels and opening import sample rows.
  - Add inbound business types `PRODUCTION_SCRAP_IN` and `OUTSOURCING_SCRAP_IN`.
  - Add outbound business type `SCRAP_SALE_OUT`.
  - Allow `SCRAP` warehouse to execute only scrap-specific operations.
  - Treat `SCRAP` as weight-only.
  - Use sale unit price for `SCRAP_SALE_OUT` transaction amount.

- Modify `backend/app/schemas/operations.py`
  - Add new business type comments to inbound/outbound allowed value documentation.
  - Extend `WarehouseOutboundCreate` with `sale_unit_price`, `buyer_name`, and `sale_remark`.

- Modify `backend/app/api/routes/master_data.py`
  - Add `SCRAP` to `JIAHENG_WAREHOUSE_DEFINITIONS`.
  - Update `_ensure_jiaheng_warehouses()` to include `SCRAP` when checking existing warehouse types.

- Modify `backend/app/services/stocktake.py`
  - Add `SCRAP: 废料库` to stocktake sheet label mapping.

- Create `backend/sql/add_scrap_warehouse_patch.sql`
  - Ensure existing deployments have active `WH-SCRAP-01` and default `SCR-E-01`.

- Create `backend/tests/test_scrap_warehouse_flow.py`
  - Cover scrap opening template/import, production scrap inbound, outsourcing scrap inbound, sale outbound, validation blocks for wrong operations, and stocktake label/export.

- Modify `frontend/src/views/InventoryLedgerView.vue`
  - Add `scrap` tab after `auxiliary`.
  - Add warehouse type/label/title/tag/balances/operation matrix entries.
  - Treat scrap as weight-only.
  - Add sale-specific fields when active operation is `SCRAP_SALE_OUT`.

- Modify `frontend/src/utils/inventoryOperationOptions.js`
  - Treat `scrap` / `SCRAP` as weight-only.
  - For scrap inbound, return both material and product options.
  - For scrap outbound, use current scrap stock balances.

- Modify `frontend/src/utils/dictionaries.js`
  - Add Chinese labels for new inventory transaction and source document types.

- Modify `frontend/scripts/test-inventory-ledger-options.mjs`
  - Add assertions for scrap inbound options, scrap outbound options, and source code checks for the new tab/operations.

---

### Task 1: Backend Tests For Scrap Warehouse Behavior

**Files:**
- Create: `backend/tests/test_scrap_warehouse_flow.py`

- [ ] **Step 1: Write the failing backend test file**

Create `backend/tests/test_scrap_warehouse_flow.py` with this content:

```python
from __future__ import annotations

import unittest
from datetime import UTC, datetime
from decimal import Decimal
from io import BytesIO

from fastapi import HTTPException
from openpyxl import Workbook, load_workbook
from sqlalchemy import BigInteger, create_engine, select
from sqlalchemy.ext.compiler import compiles
from sqlalchemy.orm import Session, sessionmaker


@compiles(BigInteger, "sqlite")
def _compile_bigint_for_sqlite(type_, compiler, **kw) -> str:
    _ = type_, compiler, kw
    return "INTEGER"


import app.models.master_data  # noqa: E402,F401
import app.models.operations  # noqa: E402,F401
from app.models.base import Base  # noqa: E402
from app.models.master_data import Item, StockBalance, Warehouse  # noqa: E402
from app.models.operations import InventoryTxn, StockLot, StocktakeLine, WarehouseLocation  # noqa: E402
from app.schemas.operations import WarehouseInboundCreate, WarehouseOutboundCreate  # noqa: E402


class User:
    id = 1


class Context:
    user = User()


class ScrapWarehouseFlowTest(unittest.TestCase):
    def setUp(self) -> None:
        engine = create_engine("sqlite+pysqlite:///:memory:", future=True)
        Base.metadata.create_all(engine)
        self.SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False, future=True)
        self.db: Session = self.SessionLocal()
        self._seed()

    def tearDown(self) -> None:
        self.db.close()

    def _seed(self) -> None:
        now = datetime.now(UTC)
        self.scrap_warehouse = Warehouse(
            id=1,
            warehouse_code="WH-SCRAP-01",
            warehouse_name="废料库",
            warehouse_type="SCRAP",
            status="ACTIVE",
            created_at=now,
            updated_at=now,
        )
        self.raw_warehouse = Warehouse(
            id=2,
            warehouse_code="WH-RM-01",
            warehouse_name="原材料库",
            warehouse_type="RAW",
            status="ACTIVE",
            created_at=now,
            updated_at=now,
        )
        self.scrap_location = WarehouseLocation(
            id=1,
            warehouse_id=1,
            location_code="SCR-E-01",
            location_name="废料暂存位",
            is_default=1,
            is_locked=0,
            status="ACTIVE",
            created_at=now,
            updated_at=now,
        )
        self.raw_location = WarehouseLocation(
            id=2,
            warehouse_id=2,
            location_code="RM-A-01",
            location_name="原料主库位",
            is_default=1,
            is_locked=0,
            status="ACTIVE",
            created_at=now,
            updated_at=now,
        )
        self.raw_item = Item(
            id=1,
            item_code="原材料00001",
            item_name="304不锈钢边角料",
            item_type="RAW_MATERIAL",
            unit_weight_kg=Decimal("1"),
            safety_stock_weight_kg=Decimal("0"),
            scrap_sale_price=Decimal("1.6"),
            status="ACTIVE",
            created_at=now,
            updated_at=now,
        )
        self.product_item = Item(
            id=2,
            item_code="产品需规00001",
            item_name="冲压支架报废品",
            item_type="FINISHED_GOOD",
            unit_weight_kg=Decimal("2.5"),
            safety_stock_weight_kg=Decimal("0"),
            scrap_sale_price=Decimal("1.2"),
            status="ACTIVE",
            created_at=now,
            updated_at=now,
        )
        self.db.add_all(
            [
                self.scrap_warehouse,
                self.raw_warehouse,
                self.scrap_location,
                self.raw_location,
                self.raw_item,
                self.product_item,
            ]
        )
        self.db.commit()

    def _opening_workbook(self, rows: list[list[object]]) -> bytes:
        from app.api.routes.inventory import OPENING_INVENTORY_HEADERS

        workbook = Workbook()
        worksheet = workbook.active
        worksheet.title = "废料库期初导入"
        worksheet.append(OPENING_INVENTORY_HEADERS)
        for row in rows:
            worksheet.append(row)
        output = BytesIO()
        workbook.save(output)
        return output.getvalue()

    def test_scrap_opening_template_exports_sample_rows(self) -> None:
        from app.api.routes.inventory import build_opening_inventory_template

        workbook = build_opening_inventory_template(self.db, "SCRAP")
        output = BytesIO()
        workbook.save(output)
        loaded = load_workbook(BytesIO(output.getvalue()), read_only=True, data_only=True)
        rows = list(loaded["废料库期初导入"].iter_rows(values_only=True))
        headers = list(rows[0])

        self.assertEqual(rows[1][headers.index("仓库类型")], "废料库")
        self.assertEqual(rows[1][headers.index("仓库名称")], "废料库")
        self.assertIn("示例-SCRAP-", rows[1][headers.index("批次号")])
        self.assertGreater(rows[1][headers.index("重量(kg)")], 0)

    def test_scrap_opening_import_is_weight_only(self) -> None:
        from app.api.routes.inventory import import_opening_inventory_workbook

        content = self._opening_workbook(
            [[
                "废料库",
                "废料库",
                "废料暂存位",
                "原材料00001",
                "304不锈钢边角料",
                "OPEN-SCRAP-001",
                99,
                125,
                1.6,
                "初始化废料",
                "期初废料",
            ]]
        )

        result = import_opening_inventory_workbook(self.db, "SCRAP", content, user_id=1)

        lot = self.db.scalar(select(StockLot).where(StockLot.lot_no == "OPEN-SCRAP-001"))
        balance = self.db.scalar(
            select(StockBalance).where(
                StockBalance.item_id == self.raw_item.id,
                StockBalance.warehouse_id == self.scrap_warehouse.id,
            )
        )

        self.assertIsNotNone(lot)
        self.assertIsNotNone(balance)
        txn = self.db.scalar(select(InventoryTxn).where(InventoryTxn.lot_id == lot.id))
        self.assertIsNotNone(txn)
        self.assertEqual(result["warehouse_type"], "SCRAP")
        self.assertEqual(result["imported"], 1)
        self.assertEqual(float(lot.inbound_qty), 0)
        self.assertEqual(float(lot.remaining_qty), 0)
        self.assertEqual(float(lot.inbound_weight_kg), 125)
        self.assertEqual(float(balance.qty_on_hand), 0)
        self.assertEqual(float(balance.weight_on_hand_kg), 125)
        self.assertEqual(txn.txn_type, "OPENING_IN")
        self.assertEqual(float(txn.qty_change), 0)
        self.assertEqual(float(txn.weight_change_kg), 125)

    def test_production_scrap_inbound_creates_scrap_lot_balance_and_txn(self) -> None:
        from app.api.routes.inventory import create_warehouse_inbound

        row = create_warehouse_inbound(
            WarehouseInboundCreate(
                biz_type="PRODUCTION_SCRAP_IN",
                item_id=self.raw_item.id,
                warehouse_id=self.scrap_warehouse.id,
                inbound_weight_kg=36.5,
                unit_cost=1.6,
                source_material_sub_batch_no="JH_110501000185_0001",
                source_material_summary="LAC-51012170/71左右后纵梁后段 1序报废边角料",
                remark="生产废料入库",
            ),
            context=Context(),
            db=self.db,
        )

        lot = self.db.get(StockLot, row.lot_id)
        balance = self.db.scalar(
            select(StockBalance).where(
                StockBalance.item_id == self.raw_item.id,
                StockBalance.warehouse_id == self.scrap_warehouse.id,
            )
        )

        self.assertIsNotNone(lot)
        self.assertIsNotNone(balance)
        txn = self.db.scalar(select(InventoryTxn).where(InventoryTxn.lot_id == lot.id))
        self.assertIsNotNone(txn)
        self.assertEqual(lot.lot_role, "PRODUCTION_SCRAP")
        self.assertEqual(lot.source_doc_type, "PRODUCTION_SCRAP_IN")
        self.assertEqual(lot.source_material_sub_batch_no, "JH_110501000185_0001")
        self.assertEqual(float(balance.weight_on_hand_kg), 36.5)
        self.assertEqual(txn.txn_type, "PRODUCTION_SCRAP_IN")
        self.assertEqual(float(txn.amount), 58.40)

    def test_outsourcing_scrap_inbound_accepts_product_item(self) -> None:
        from app.api.routes.inventory import create_warehouse_inbound

        row = create_warehouse_inbound(
            WarehouseInboundCreate(
                biz_type="OUTSOURCING_SCRAP_IN",
                item_id=self.product_item.id,
                warehouse_id=self.scrap_warehouse.id,
                inbound_weight_kg=12,
                unit_cost=1.2,
                provider_name="外协加工厂A",
                remark="委外废料入库",
            ),
            context=Context(),
            db=self.db,
        )

        lot = self.db.get(StockLot, row.lot_id)
        self.assertIsNotNone(lot)
        txn = self.db.scalar(select(InventoryTxn).where(InventoryTxn.lot_id == lot.id))

        self.assertIsNotNone(txn)
        self.assertEqual(lot.lot_role, "OUTSOURCING_SCRAP")
        self.assertEqual(lot.source_doc_type, "OUTSOURCING_SCRAP_IN")
        self.assertEqual(float(lot.inbound_qty), 0)
        self.assertEqual(txn.txn_type, "OUTSOURCING_SCRAP_IN")

    def test_scrap_sale_outbound_schema_preserves_sale_fields(self) -> None:
        payload = WarehouseOutboundCreate(
            biz_type="SCRAP_SALE_OUT",
            item_id=self.raw_item.id,
            warehouse_id=self.scrap_warehouse.id,
            outbound_weight_kg=40,
            sale_unit_price=2.5,
            buyer_name="废品回收商A",
            sale_remark="按废不锈钢售卖",
        )

        self.assertEqual(float(payload.sale_unit_price), 2.5)
        self.assertEqual(payload.buyer_name, "废品回收商A")
        self.assertEqual(payload.sale_remark, "按废不锈钢售卖")

    def test_scrap_sale_outbound_uses_sale_price_for_transaction_amount(self) -> None:
        from app.api.routes.inventory import create_warehouse_inbound, create_warehouse_outbound

        create_warehouse_inbound(
            WarehouseInboundCreate(
                biz_type="PRODUCTION_SCRAP_IN",
                item_id=self.raw_item.id,
                warehouse_id=self.scrap_warehouse.id,
                inbound_weight_kg=100,
                unit_cost=1.6,
            ),
            context=Context(),
            db=self.db,
        )

        row = create_warehouse_outbound(
            WarehouseOutboundCreate(
                biz_type="SCRAP_SALE_OUT",
                item_id=self.raw_item.id,
                warehouse_id=self.scrap_warehouse.id,
                outbound_weight_kg=40,
                sale_unit_price=2.5,
                buyer_name="废品回收商A",
                sale_remark="按废不锈钢售卖",
            ),
            context=Context(),
            db=self.db,
        )

        txn = self.db.scalar(
            select(InventoryTxn)
            .where(InventoryTxn.txn_type == "SCRAP_SALE_OUT")
            .order_by(InventoryTxn.id.desc())
            .limit(1)
        )
        balance = self.db.scalar(
            select(StockBalance).where(
                StockBalance.item_id == self.raw_item.id,
                StockBalance.warehouse_id == self.scrap_warehouse.id,
            )
        )

        self.assertIsNotNone(txn)
        self.assertIsNotNone(balance)
        self.assertEqual(row.warehouse_type, "SCRAP")
        self.assertEqual(float(balance.weight_on_hand_kg), 60)
        self.assertEqual(float(txn.unit_cost), 2.5)
        self.assertEqual(float(txn.amount), 100)
        self.assertIn("废品回收商A", txn.remark)

    def test_scrap_warehouse_rejects_non_scrap_operations(self) -> None:
        from app.api.routes.inventory import create_warehouse_inbound, create_warehouse_outbound

        with self.assertRaises(HTTPException) as inbound_exc:
            create_warehouse_inbound(
                WarehouseInboundCreate(
                    biz_type="CUSTOMER_SUPPLIED",
                    item_id=self.raw_item.id,
                    warehouse_id=self.scrap_warehouse.id,
                    inbound_weight_kg=5,
                ),
                context=Context(),
                db=self.db,
            )
        self.assertEqual(inbound_exc.exception.status_code, 400)
        self.assertIn("废料库不允许执行该入库业务", inbound_exc.exception.detail)

        with self.assertRaises(HTTPException) as outbound_exc:
            create_warehouse_outbound(
                WarehouseOutboundCreate(
                    biz_type="SCRAP_OUT",
                    item_id=self.raw_item.id,
                    warehouse_id=self.scrap_warehouse.id,
                    outbound_weight_kg=5,
                ),
                context=Context(),
                db=self.db,
            )
        self.assertEqual(outbound_exc.exception.status_code, 400)
        self.assertIn("废料库不允许执行该出库业务", outbound_exc.exception.detail)

    def test_stocktake_export_uses_scrap_sheet_name(self) -> None:
        from app.services.stocktake import build_stocktake_workbook, start_stocktake

        self.db.add(
            StockLot(
                id=10,
                lot_no="SCRAP-STOCKTAKE-001",
                lot_role="PRODUCTION_SCRAP",
                item_id=self.raw_item.id,
                warehouse_id=self.scrap_warehouse.id,
                location_id=self.scrap_location.id,
                source_doc_type="PRODUCTION_SCRAP_IN",
                source_doc_id=10,
                source_material_sub_batch_no="JH_110501000185_0001",
                source_material_summary="盘库用废料",
                inbound_qty=Decimal("0"),
                inbound_weight_kg=Decimal("66"),
                remaining_qty=Decimal("0"),
                remaining_weight_kg=Decimal("66"),
                locked_qty=Decimal("0"),
                locked_weight_kg=Decimal("0"),
                unit_cost=Decimal("1.6"),
                quality_status="PASS",
                status="AVAILABLE",
            )
        )
        self.db.add(
            StockBalance(
                item_id=self.raw_item.id,
                warehouse_id=self.scrap_warehouse.id,
                location_id=self.scrap_location.id,
                qty_on_hand=Decimal("0"),
                weight_on_hand_kg=Decimal("66"),
                qty_available=Decimal("0"),
                weight_available_kg=Decimal("66"),
                qty_allocated=Decimal("0"),
                weight_allocated_kg=Decimal("0"),
                avg_unit_cost=Decimal("1.6"),
            )
        )
        self.db.commit()

        stocktake = start_stocktake(self.db, warehouse_ids=[self.scrap_warehouse.id], user_id=1, remark="废料库盘库")
        workbook = build_stocktake_workbook(self.db, stocktake.id)
        output = BytesIO()
        workbook.save(output)
        loaded = load_workbook(BytesIO(output.getvalue()), read_only=True, data_only=True)

        self.assertIn("废料库", loaded.sheetnames)
        rows = list(loaded["废料库"].iter_rows(values_only=True))
        headers = list(rows[0])

        self.assertEqual(rows[1][headers.index("仓库")], "废料库")
        self.assertEqual(rows[1][headers.index("库位")], "废料暂存位")
        self.assertEqual(rows[1][headers.index("物料编码")], "原材料00001")
        self.assertEqual(rows[1][headers.index("批次号")], "SCRAP-STOCKTAKE-001")
        self.assertEqual(rows[1][headers.index("来源材料分批次号")], "JH_110501000185_0001")
        self.assertEqual(rows[1][headers.index("系统数量")], 0)
        self.assertEqual(rows[1][headers.index("系统重量(kg)")], 66)
        self.assertEqual(rows[1][headers.index("系统单价")], 1.6)


    def test_scrap_stocktake_keeps_product_scrap_weight_only_after_confirm(self) -> None:
        from app.services.stocktake import build_stocktake_workbook, confirm_stocktake, import_stocktake_workbook, start_stocktake

        self.db.add(
            StockLot(
                id=11,
                lot_no="SCRAP-PRODUCT-001",
                lot_role="OUTSOURCING_SCRAP",
                item_id=self.product_item.id,
                warehouse_id=self.scrap_warehouse.id,
                location_id=self.scrap_location.id,
                source_doc_type="OUTSOURCING_SCRAP_IN",
                source_doc_id=11,
                source_material_summary="产品报废件盘库",
                inbound_qty=Decimal("0"),
                inbound_weight_kg=Decimal("30"),
                remaining_qty=Decimal("0"),
                remaining_weight_kg=Decimal("30"),
                locked_qty=Decimal("0"),
                locked_weight_kg=Decimal("0"),
                unit_cost=Decimal("1.2"),
                quality_status="PASS",
                status="AVAILABLE",
            )
        )
        self.db.add(
            StockBalance(
                item_id=self.product_item.id,
                warehouse_id=self.scrap_warehouse.id,
                location_id=self.scrap_location.id,
                qty_on_hand=Decimal("0"),
                weight_on_hand_kg=Decimal("30"),
                qty_available=Decimal("0"),
                weight_available_kg=Decimal("30"),
                qty_allocated=Decimal("0"),
                weight_allocated_kg=Decimal("0"),
                avg_unit_cost=Decimal("1.2"),
            )
        )
        self.db.commit()

        stocktake = start_stocktake(self.db, warehouse_ids=[self.scrap_warehouse.id], user_id=1, remark="产品废料盘库")
        workbook = build_stocktake_workbook(self.db, stocktake.id)
        output = BytesIO()
        workbook.save(output)
        loaded = load_workbook(BytesIO(output.getvalue()))
        worksheet = loaded["废料库"]
        headers = [cell.value for cell in worksheet[1]]
        worksheet.cell(row=2, column=headers.index("盘点数量") + 1, value=88)
        worksheet.cell(row=2, column=headers.index("盘点重量(kg)") + 1, value=45)
        imported_output = BytesIO()
        loaded.save(imported_output)

        import_stocktake_workbook(self.db, stocktake.id, imported_output.getvalue(), user_id=1)
        confirmed = confirm_stocktake(self.db, stocktake.id, user_id=2, confirm_text="", remark="确认产品废料盘库")

        self.assertEqual(confirmed.status, "CONFIRMED")
        lot = self.db.scalar(select(StockLot).where(StockLot.lot_no == "SCRAP-PRODUCT-001"))
        balance = self.db.scalar(
            select(StockBalance).where(
                StockBalance.item_id == self.product_item.id,
                StockBalance.warehouse_id == self.scrap_warehouse.id,
            )
        )
        line = self.db.scalar(select(StocktakeLine).where(StocktakeLine.stocktake_id == stocktake.id))

        self.assertIsNotNone(lot)
        self.assertIsNotNone(balance)
        self.assertIsNotNone(line)
        self.assertEqual(float(line.counted_qty), 0)
        self.assertEqual(float(line.diff_qty), 0)
        self.assertEqual(float(lot.remaining_qty), 0)
        self.assertEqual(float(lot.remaining_weight_kg), 45)
        self.assertEqual(float(balance.qty_on_hand), 0)
        self.assertEqual(float(balance.qty_available), 0)
        self.assertEqual(float(balance.weight_on_hand_kg), 45)



if __name__ == "__main__":
    unittest.main()

```

- [ ] **Step 2: Run the new test and verify it fails before implementation**

Run:

```bash
cd /Users/souplearn/Gitlab/py/ForgeFlow-ERP/backend
python -m unittest tests.test_scrap_warehouse_flow -v
```

Expected before implementation: FAIL with errors mentioning unsupported `SCRAP`, missing `sale_unit_price`, unsupported `PRODUCTION_SCRAP_IN`, unsupported `OUTSOURCING_SCRAP_IN`, unsupported `SCRAP_SALE_OUT`, or missing `废料库` sheet label.

---

### Task 2: Backend Scrap Warehouse Types, Validation, And Ledger Logic

**Files:**
- Modify: `backend/app/api/routes/inventory.py`
- Modify: `backend/app/schemas/operations.py`
- Modify: `backend/app/services/stocktake.py`

- [ ] **Step 1: Extend outbound schema with sale fields**

In `backend/app/schemas/operations.py`, change `WarehouseOutboundCreate` to:

```python
class WarehouseOutboundCreate(BaseModel):
    biz_type: str
    item_id: int
    warehouse_id: int
    location_id: int | None = None
    outbound_weight_kg: float
    target_doc_type: str | None = None
    target_doc_id: int | None = None
    target_doc_line_id: int | None = None
    target_material_sub_batch_no: str | None = None
    sale_unit_price: float | None = None
    buyer_name: str | None = None
    sale_remark: str | None = None
    remark: str | None = None
```

Also update the allowed business type comments near the inbound/outbound documentation:

```python
    "PRODUCTION_SCRAP_IN",  # 生产废料入库（废料库）
    "OUTSOURCING_SCRAP_IN", # 委外废料入库（废料库）
```

```python
    "SCRAP_SALE_OUT",     # 售卖出库（废料库）
```

- [ ] **Step 2: Add `SCRAP` to warehouse labels and opening template samples**

In `backend/app/api/routes/inventory.py`, update `WAREHOUSE_TYPE_LABELS`:

```python
WAREHOUSE_TYPE_LABELS = {
    "RAW": "原材料库",
    "SEMI": "半成品库",
    "FINISHED": "成品库",
    "AUX": "辅料库",
    "SCRAP": "废料库",
}
```

Add this row group to `OPENING_INVENTORY_SAMPLE_ROWS`:

```python
    "SCRAP": [
        ["废料库", "废料库", "废料暂存位", "示例原材料001", "304不锈钢边角料", "示例-SCRAP-0001", 0, 120, 1.6, "仓库初始化清点", "示例行，导入时会自动跳过，请替换为真实数据"],
        ["废料库", "废料库", "废料暂存位", "示例原材料002", "冲压报废件", "示例-SCRAP-0002", 0, 80, 1.2, "仓库初始化清点", "示例行，导入时会自动跳过，请替换为真实数据"],
    ],
```

- [ ] **Step 3: Treat scrap opening import as weight-only**

In `_create_opening_inventory_row()` or the nearby opening import row handling in `backend/app/api/routes/inventory.py`, change the weight-only condition from:

```python
raw_weight_only = warehouse_type in {"RAW", "AUX"} or item.item_type == "RAW_MATERIAL"
```

to:

```python
raw_weight_only = warehouse_type in {"RAW", "AUX", "SCRAP"} or item.item_type == "RAW_MATERIAL"
```

- [ ] **Step 4: Add scrap inbound and outbound business maps**

In `_INBOUND_BIZ_MAP`, add:

```python
    "PRODUCTION_SCRAP_IN":  ("PRODUCTION_SCRAP",  "PRODUCTION_SCRAP_IN",  "PRODUCTION_SCRAP_IN",  None),
    "OUTSOURCING_SCRAP_IN": ("OUTSOURCING_SCRAP", "OUTSOURCING_SCRAP_IN", "OUTSOURCING_SCRAP_IN", None),
```

In `_ALLOWED_INBOUND_BY_WAREHOUSE_TYPE`, add:

```python
    "SCRAP": {"PRODUCTION_SCRAP_IN", "OPENING", "OUTSOURCING_SCRAP_IN"},
```

In `_OUTBOUND_BIZ_MAP`, add:

```python
    "SCRAP_SALE_OUT":     ("SCRAP_SALE_OUT",    "SCRAP_SALE_OUT"),
```

In `_ALLOWED_OUTBOUND_BY_WAREHOUSE_TYPE`, add:

```python
    "SCRAP": {"SCRAP_SALE_OUT"},
```

- [ ] **Step 5: Add scrap labels and item validation**

In `_warehouse_type_label()`, add:

```python
        "SCRAP": "废料库",
```

In `_validate_warehouse_item()`, add this branch between the RAW/AUX branch and the SEMI/FINISHED branch:

```python
    if warehouse_type == "SCRAP" and item.item_type not in {"RAW_MATERIAL", "PRODUCT", "FINISHED_GOOD"}:
        raise HTTPException(status_code=400, detail="废料库只能选择原材料、辅料、产品或报废品类物料")
```

- [ ] **Step 6: Generate clear scrap lot numbers**

In the lot number generation block in `create_warehouse_inbound()`, add a scrap branch before the final `else`:

```python
        elif biz_type in ("PRODUCTION_SCRAP_IN", "OUTSOURCING_SCRAP_IN"):
            tag = "SCFL" if biz_type == "PRODUCTION_SCRAP_IN" else "WWFL"
            lot_no = _build_surplus_lot_no(db, item, warehouse, tag)
```

This keeps the current lot-number helper and creates readable lot numbers with production scrap and outsourcing scrap tags.

- [ ] **Step 7: Use sale unit price for scrap sale outbound transaction amount**

In `create_warehouse_outbound()`, after `txn_type, source_doc_type = _OUTBOUND_BIZ_MAP[biz_type]`, add:

```python
    sale_unit_price = to_decimal(payload.sale_unit_price, "0.0001") if payload.sale_unit_price is not None else None
    if biz_type == "SCRAP_SALE_OUT" and (sale_unit_price is None or sale_unit_price <= 0):
        raise HTTPException(status_code=400, detail="废料售卖出库必须填写大于0的售卖单价")
```

Inside the lot deduction loop, replace:

```python
        unit_cost = to_decimal(available_lot.unit_cost, "0.0001")
```

with:

```python
        lot_unit_cost = to_decimal(available_lot.unit_cost, "0.0001")
        txn_unit_cost = sale_unit_price if biz_type == "SCRAP_SALE_OUT" and sale_unit_price is not None else lot_unit_cost
```

Use `lot_unit_cost` in `upsert_stock_balance()`:

```python
            unit_cost=lot_unit_cost,
```

Build the remark before `create_inventory_txn()` like this:

```python
        remark_parts = [payload.remark or biz_type]
        if payload.target_material_sub_batch_no:
            remark_parts.append(f"目标/来源分批号 {payload.target_material_sub_batch_no}")
        if biz_type == "SCRAP_SALE_OUT":
            if payload.buyer_name:
                remark_parts.append(f"购买方 {payload.buyer_name}")
            if payload.sale_remark:
                remark_parts.append(payload.sale_remark)
        remark = "；".join(part for part in remark_parts if part)
```

Use `txn_unit_cost` in `create_inventory_txn()`:

```python
            unit_cost=txn_unit_cost,
```

Keep `amount_basis="WEIGHT"` unchanged.

- [ ] **Step 8: Add scrap to stocktake label mapping**

In `backend/app/services/stocktake.py`, update `stocktake_warehouse_type_label()`:

```python
def stocktake_warehouse_type_label(value: str | None) -> str:
    return {
        "RAW": "原材料库",
        "SEMI": "半成品库",
        "FINISHED": "成品库",
        "AUX": "辅料库",
        "SCRAP": "废料库",
    }.get(str(value or "").upper(), str(value or "未知仓库"))
```

- [ ] **Step 9: Run backend scrap tests**

Run:

```bash
cd /Users/souplearn/Gitlab/py/ForgeFlow-ERP/backend
python -m unittest tests.test_scrap_warehouse_flow -v
```

Expected: all tests in `ScrapWarehouseFlowTest` pass.

- [ ] **Step 10: Run related backend regression tests**

Run:

```bash
cd /Users/souplearn/Gitlab/py/ForgeFlow-ERP/backend
python -m unittest tests.test_opening_inventory_import tests.test_stocktake_locking tests.test_stocktake_excel_diff_confirm -v
```

Expected: all existing opening inventory and stocktake tests pass.

---

### Task 3: Default Warehouse Seed And Deployment SQL

**Files:**
- Modify: `backend/app/api/routes/master_data.py`
- Create: `backend/sql/add_scrap_warehouse_patch.sql`

- [ ] **Step 1: Add scrap warehouse to runtime default warehouse definitions**

In `backend/app/api/routes/master_data.py`, append this object to `JIAHENG_WAREHOUSE_DEFINITIONS`:

```python
    {
        "warehouse_code": "WH-SCRAP-01",
        "warehouse_name": "废料库",
        "warehouse_type": "SCRAP",
        "location_code": "SCR-E-01",
        "location_name": "废料暂存位",
        "zone_name": "E区",
        "remark": "生产废料、边角料、委外废料、报废品等废料库存",
    },
```

Change `_ensure_jiaheng_warehouses()` existing type query from:

```python
select(Warehouse).where(Warehouse.warehouse_type.in_(["RAW", "SEMI", "FINISHED", "AUX"]))
```

to:

```python
select(Warehouse).where(Warehouse.warehouse_type.in_(["RAW", "SEMI", "FINISHED", "AUX", "SCRAP"]))
```

- [ ] **Step 2: Create the SQL patch**

Create `backend/sql/add_scrap_warehouse_patch.sql`:

```sql
INSERT INTO wh_warehouse (warehouse_code, warehouse_name, warehouse_type, manager_employee_id, status, remark)
SELECT 'WH-SCRAP-01', '废料库', 'SCRAP', NULL, 'ACTIVE', '生产废料、边角料、委外废料、报废品等废料库存'
WHERE NOT EXISTS (SELECT 1 FROM wh_warehouse WHERE warehouse_code = 'WH-SCRAP-01');

UPDATE wh_warehouse
SET warehouse_name = '废料库',
    warehouse_type = 'SCRAP',
    status = 'ACTIVE',
    remark = '生产废料、边角料、委外废料、报废品等废料库存'
WHERE warehouse_code = 'WH-SCRAP-01';

INSERT INTO wh_warehouse_location (
  warehouse_id,
  location_code,
  location_name,
  zone_name,
  is_default,
  is_locked,
  status,
  remark
)
SELECT
  (SELECT id FROM wh_warehouse WHERE warehouse_code = 'WH-SCRAP-01'),
  'SCR-E-01',
  '废料暂存位',
  'E区',
  1,
  0,
  'ACTIVE',
  '废料库默认库位'
WHERE NOT EXISTS (
  SELECT 1
  FROM wh_warehouse_location
  WHERE warehouse_id = (SELECT id FROM wh_warehouse WHERE warehouse_code = 'WH-SCRAP-01')
    AND location_code = 'SCR-E-01'
);

UPDATE wh_warehouse_location
SET location_name = '废料暂存位',
    zone_name = 'E区',
    is_default = 1,
    is_locked = 0,
    status = 'ACTIVE',
    remark = '废料库默认库位'
WHERE warehouse_id = (SELECT id FROM wh_warehouse WHERE warehouse_code = 'WH-SCRAP-01')
  AND location_code = 'SCR-E-01';
```

- [ ] **Step 3: Verify SQL text is present and deterministic**

Run:

```bash
cd /Users/souplearn/Gitlab/py/ForgeFlow-ERP
rg -n "WH-SCRAP-01|废料库|SCR-E-01" backend/sql/add_scrap_warehouse_patch.sql backend/app/api/routes/master_data.py
```

Expected: output contains the new warehouse code, label, type, location code, and definition.

---

### Task 4: Frontend Option Builder Tests And Logic

**Files:**
- Modify: `frontend/src/utils/inventoryOperationOptions.js`
- Modify: `frontend/scripts/test-inventory-ledger-options.mjs`

- [ ] **Step 1: Add failing frontend option tests for scrap warehouse**

In `frontend/scripts/test-inventory-ledger-options.mjs`, after the auxiliary option assertions, add:

```javascript
const scrapInboundOptions = buildGenericItemOptions({
  direction: "in",
  activeInventoryTab: "scrap",
  activeWarehouseType: "SCRAP",
  warehouseId: 11,
  balances: [],
  materials: [{ item_id: 801, item_code: "原材料00001", item_name: "304边角料" }],
  products: [{ item_id: 901, item_code: "产品需规00001", item_name: "报废冲压件" }]
});

assert.deepEqual(scrapInboundOptions.map((item) => item.item_id), [801, 901]);

const scrapOutboundOptions = buildGenericItemOptions({
  direction: "out",
  activeInventoryTab: "scrap",
  activeWarehouseType: "SCRAP",
  warehouseId: 11,
  balances: [
    {
      item_id: 801,
      item_code: "原材料00001",
      item_name: "304边角料",
      warehouse_id: 11,
      warehouse_type: "SCRAP",
      qty_available: 0,
      weight_available_kg: 18
    },
    {
      item_id: 802,
      item_code: "原材料00002",
      item_name: "废铁",
      warehouse_id: 11,
      warehouse_type: "SCRAP",
      qty_available: 99,
      weight_available_kg: 0
    }
  ],
  materials: [],
  products: []
});

assert.equal(scrapOutboundOptions.length, 1);
assert.equal(scrapOutboundOptions[0].item_id, 801);
```

Add source checks near the bottom:

```javascript
assert.match(inventoryLedgerSource, /key: "scrap"/);
assert.match(inventoryLedgerSource, /label: "废料库"/);
assert.match(inventoryLedgerSource, /PRODUCTION_SCRAP_IN/);
assert.match(inventoryLedgerSource, /OUTSOURCING_SCRAP_IN/);
assert.match(inventoryLedgerSource, /SCRAP_SALE_OUT/);
```

- [ ] **Step 2: Run frontend option test and verify it fails before logic changes**

Run:

```bash
cd /Users/souplearn/Gitlab/py/ForgeFlow-ERP/frontend
node scripts/test-inventory-ledger-options.mjs
```

Expected before implementation: FAIL because `scrap` inbound does not return both materials and products, `SCRAP` is not weight-only, or the component source does not contain the new tab/operations.

- [ ] **Step 3: Update option builder for scrap**

In `frontend/src/utils/inventoryOperationOptions.js`, change:

```javascript
function isWeightOnlyTab(tab) {
  return ["raw", "auxiliary"].includes(String(tab || ""));
}
```

to:

```javascript
function isWeightOnlyTab(tab) {
  return ["raw", "auxiliary", "scrap"].includes(String(tab || ""));
}
```

Change:

```javascript
const weightOnly = isWeightOnlyTab(activeInventoryTab) || ["RAW", "AUX"].includes(normalizedWarehouseType);
```

to:

```javascript
const weightOnly = isWeightOnlyTab(activeInventoryTab) || ["RAW", "AUX", "SCRAP"].includes(normalizedWarehouseType);
```

Change inbound option selection:

```javascript
  if (["raw", "auxiliary"].includes(activeInventoryTab)) {
    return materials;
  }
  return products;
```

to:

```javascript
  if (String(activeInventoryTab || "") === "scrap") {
    return [...materials, ...products];
  }
  if (["raw", "auxiliary"].includes(activeInventoryTab)) {
    return materials;
  }
  return products;
```

- [ ] **Step 4: Re-run frontend option test**

Run:

```bash
cd /Users/souplearn/Gitlab/py/ForgeFlow-ERP/frontend
node scripts/test-inventory-ledger-options.mjs
```

Expected at this point: scrap option assertions pass, source checks still fail until `InventoryLedgerView.vue` is updated in Task 5.

---

### Task 5: Frontend Scrap Tab, Operations, And Sale Fields

**Files:**
- Modify: `frontend/src/views/InventoryLedgerView.vue`
- Modify: `frontend/src/utils/dictionaries.js`

- [ ] **Step 1: Add scrap tab constants and computed balances**

In `frontend/src/views/InventoryLedgerView.vue`, update `WAREHOUSE_TYPE_BY_TAB`:

```javascript
const WAREHOUSE_TYPE_BY_TAB = {
  raw: "RAW",
  semi: "SEMI",
  finished: "FINISHED",
  auxiliary: "AUX",
  scrap: "SCRAP"
};
```

Update `WAREHOUSE_LABEL_BY_TAB`:

```javascript
const WAREHOUSE_LABEL_BY_TAB = {
  raw: "原材料库",
  semi: "半成品库",
  finished: "成品库",
  auxiliary: "辅料库",
  scrap: "废料库"
};
```

Add scrap balances after `auxiliaryBalances`:

```javascript
const scrapBalances = computed(() => balances.value.filter((item) => normalizeWarehouseType(item) === "SCRAP"));
```

- [ ] **Step 2: Add fifth inventory tab**

In `inventoryTabs`, append:

```javascript
  {
    key: "scrap",
    label: "废料库",
    count: filteredScrapCount.value,
    iconClass: "inventory-tab-icon-scrap",
    iconPaths: ["M7 7.5 10 4h4l3 3.5", "M17 7.5h-3.2l1.6-2.2", "M17.5 11.5l2 3.5-2 3.5h-4", "M13.5 18.5l1.7-2.6", "M8.5 18.5h-4l-2-3.5 2-3.5", "M4.5 11.5 6.2 14"]
  }
```

Add this after `filteredAuxiliaryCount`:

```javascript
const filteredScrapCount = computed(() => scrapBalances.value.length);
```

- [ ] **Step 3: Add labels, title, active balance mapping, and weight-only logic**

In `activeInventoryTitle`, add:

```javascript
    scrap: "废料库存与售卖出库"
```

In `activeInventoryTag`, add:

```javascript
    scrap: "废料库"
```

Change:

```javascript
const activeWeightOnly = computed(() => ["raw", "auxiliary"].includes(activeInventoryTab.value));
const selectedWeightOnly = computed(() => ["RAW", "AUX"].includes(selectedWarehouseType.value));
```

to:

```javascript
const activeWeightOnly = computed(() => ["raw", "auxiliary", "scrap"].includes(activeInventoryTab.value));
const selectedWeightOnly = computed(() => ["RAW", "AUX", "SCRAP"].includes(selectedWarehouseType.value));
```

In `activeBalances`, add:

```javascript
    scrap: scrapBalances.value
```

- [ ] **Step 4: Add scrap operation matrix**

In `operationMatrix`, append:

```javascript
  scrap: {
    inbound: [
      makeOperation("scrap-production-in", "in", "PRODUCTION_SCRAP_IN", "生产废料入库", "生产过程中产生的废料、边角料、报废品入废料库。"),
      makeOperation("scrap-opening-in", "in", "OPENING", "期初入库", "仓库初始化时导入的初始废料。"),
      makeOperation("scrap-outsourcing-in", "in", "OUTSOURCING_SCRAP_IN", "委外废料入库", "委外加工返回的废料、边角料、报废品入废料库。")
    ],
    outbound: [
      makeOperation("scrap-sale-out", "out", "SCRAP_SALE_OUT", "售卖出库", "废料售卖给回收商或客户后出库。")
    ]
  }
```

- [ ] **Step 5: Add sale-specific fields to the generic drawer**

In the generic drawer template, below the outbound weight input and before remark, add:

```vue
            <label v-if="activeOperation?.bizType === 'SCRAP_SALE_OUT'">
              <span>购买方</span>
              <input v-model.trim="genericForm.buyer_name" type="text" placeholder="例如：废品回收商A" />
            </label>
            <label v-if="activeOperation?.bizType === 'SCRAP_SALE_OUT'">
              <span>售卖单价(元/kg)</span>
              <input v-model.number="genericForm.sale_unit_price" type="number" min="0" step="0.0001" required />
            </label>
            <label v-if="activeOperation?.bizType === 'SCRAP_SALE_OUT'">
              <span>预计售卖金额</span>
              <input :value="formatAmount(scrapSaleAmount)" type="text" disabled />
            </label>
```

Add computed amount:

```javascript
const scrapSaleAmount = computed(() => {
  const weight = Number(genericForm.weight_kg || 0);
  const price = Number(genericForm.sale_unit_price || 0);
  return Number.isFinite(weight * price) ? weight * price : 0;
});
```

- [ ] **Step 6: Extend generic form state and submit payload**

In `buildEmptyGenericForm()`, add:

```javascript
    sale_unit_price: "",
    buyer_name: "",
    sale_remark: ""
```

In `resetGenericForm()` or the function that clears generic form values, clear the same fields:

```javascript
  genericForm.sale_unit_price = "";
  genericForm.buyer_name = "";
  genericForm.sale_remark = "";
```

In `submitGenericOperation()`, in the outbound payload sent to `/inventory/outbound`, add:

```javascript
        sale_unit_price: activeOperation.value?.bizType === "SCRAP_SALE_OUT" ? Number(genericForm.sale_unit_price || 0) : null,
        buyer_name: activeOperation.value?.bizType === "SCRAP_SALE_OUT" ? genericForm.buyer_name || "" : null,
        sale_remark: activeOperation.value?.bizType === "SCRAP_SALE_OUT" ? genericForm.remark || "" : null,
```

Before posting outbound, add frontend validation:

```javascript
    if (activeOperation.value?.bizType === "SCRAP_SALE_OUT" && Number(genericForm.sale_unit_price || 0) <= 0) {
      errorMessage.value = "废料售卖出库必须填写大于0的售卖单价";
      return;
    }
```

- [ ] **Step 7: Add dictionary labels**

In `frontend/src/utils/dictionaries.js`, update `INVENTORY_TXN_TYPE_LABELS`:

```javascript
  PRODUCTION_SCRAP_IN: "生产废料入库",
  OUTSOURCING_SCRAP_IN: "委外废料入库",
  SCRAP_SALE_OUT: "废料售卖出库",
```

Update `SOURCE_DOC_TYPE_LABELS`:

```javascript
  PRODUCTION_SCRAP_IN: "生产废料入库",
  OUTSOURCING_SCRAP_IN: "委外废料入库",
  SCRAP_SALE_OUT: "废料售卖出库",
```

- [ ] **Step 8: Run frontend option test**

Run:

```bash
cd /Users/souplearn/Gitlab/py/ForgeFlow-ERP/frontend
node scripts/test-inventory-ledger-options.mjs
```

Expected: `inventory ledger option tests passed`.

- [ ] **Step 9: Run frontend build**

Run:

```bash
cd /Users/souplearn/Gitlab/py/ForgeFlow-ERP/frontend
npm run build
```

Expected: Vite build completes without Vue compile errors.

---

### Task 6: End-To-End Verification Checklist

**Files:**
- No new files.
- Verify changed files from Tasks 1 through 5.

- [ ] **Step 1: Backend full targeted verification**

Run:

```bash
cd /Users/souplearn/Gitlab/py/ForgeFlow-ERP/backend
python -m unittest tests.test_scrap_warehouse_flow tests.test_opening_inventory_import tests.test_stocktake_locking tests.test_stocktake_excel_diff_confirm -v
```

Expected: all tests pass.

- [ ] **Step 2: Frontend targeted verification**

Run:

```bash
cd /Users/souplearn/Gitlab/py/ForgeFlow-ERP/frontend
node scripts/test-inventory-ledger-options.mjs
node scripts/test-stocktake-workflow.mjs
npm run build
```

Expected:
- `inventory ledger option tests passed`
- `stocktake workflow tests passed`
- `npm run build` exits successfully

- [ ] **Step 3: Static search verification**

Run:

```bash
cd /Users/souplearn/Gitlab/py/ForgeFlow-ERP
rg -n "SCRAP|废料库|PRODUCTION_SCRAP_IN|OUTSOURCING_SCRAP_IN|SCRAP_SALE_OUT" backend/app frontend/src backend/sql
```

Expected:
- Backend labels include `SCRAP: 废料库`.
- Backend allowed inbound map includes `PRODUCTION_SCRAP_IN`, `OPENING`, `OUTSOURCING_SCRAP_IN` for `SCRAP`.
- Backend allowed outbound map includes only `SCRAP_SALE_OUT` for `SCRAP`.
- Frontend tab and operation matrix include `废料库`.
- SQL patch includes `WH-SCRAP-01` and `SCR-E-01`.

- [ ] **Step 4: Manual browser verification**

Start the app using the project’s normal local commands:

```bash
cd /Users/souplearn/Gitlab/py/ForgeFlow-ERP/backend
python -m uvicorn app.main:app --reload
```

```bash
cd /Users/souplearn/Gitlab/py/ForgeFlow-ERP/frontend
npm run dev
```

Expected manual checks:
- 嘉恒仓库 shows five warehouse tabs: 原材料库、半成品库、成品库、辅料库、废料库.
- 废料库 tab uses the same card style and selected style as the other four warehouses.
- 废料库 list is weight-only and does not show quantity columns.
- 入库 bar shows 生产废料入库、期初入库、委外废料入库.
- 出库 bar shows 售卖出库.
- 期初入库 exports `废料库期初导入模版.xlsx` with two sample rows.
- 生产废料入库 creates a new scrap lot and stock balance.
- 售卖出库 only offers items that have available scrap stock.
- 售卖出库 requires sale unit price and records buyer information in the inventory transaction remark.
- 盘库 can lock/export/import/confirm/unlock 废料库.

---

## Self-Review

- Spec coverage: The plan covers the fifth warehouse tab, three inbound operations, one outbound operation, backend validation, stock ledger writes, opening import/export, stocktake support, runtime default warehouse creation, SQL patch, Chinese labels, and targeted tests.
- Placeholder scan: No placeholder implementation steps remain. Every task names concrete files, snippets, commands, and expected outcomes.
- Type consistency: The plan uses `SCRAP`, `PRODUCTION_SCRAP_IN`, `OUTSOURCING_SCRAP_IN`, `SCRAP_SALE_OUT`, `sale_unit_price`, `buyer_name`, and `sale_remark` consistently across schemas, backend routes, frontend payloads, and tests.
- Scope check: This is one coherent warehouse-ledger extension. It does not add an independent scrap catalog, independent finance module, or unrelated warehouse UI refactor.
