diff --git a/Spec.md b/Spec.md
index 5a9718e..cd5262d 100644
--- a/Spec.md
+++ b/Spec.md
@@ -121,6 +121,8 @@
 改訂120: 2026-09-23（5.1節：MBOMの代替部品グループの整合を登録時に確かめるようにした。グループの無い代替部品の行、主材料の無いグループ、主材料が2つ以上あるグループを登録できた。主材料が無いとバックフラッシュ（代替部品の行を消費しない。3.9節）がそのグループの部材を何も引かず、主材料が2つ以上だと代わりになるはずの部材を両方とも原単位ぶん引く。グループの無い代替部品はどの主材料の代わりかが決まらない。判定は `ProductStructurePolicy.CheckAlternativeGroups` に置き、単票APIとマスタCSV取込の両方から呼ぶ。グループ名は前後の空白を除いて比べ、その形で保存する（空白違いで別グループになるのを防ぐ）。既存のデータは直さない（次にそのMBOMを保存するときに判定される））
 改訂121: 2026-09-23（3.1節：MBOMの改訂（A-40-10-05 設計変更）の監査ログに変更前後の明細を残すようにした。これまでは `items=件数` だけで、一括置換のため何を変えたか追えなかった。明細は子品目をIDではなくコードで残す（品目を無効化・改名しても読めるように）。マスタCSV取込では種別ごとの取込ログに加えて親品目ごとに同じ形のログを書く（CSVが追跡の抜け道にならないように）。監査ログは書くたびに保存するため、取込の途中では書かず、全行の検証が通って保存した後にまとめて書く）
 改訂122: 2026-09-23（5.7節「指図展開時のマスタ固定」に、予定材料の標準不良率による割り増しと消費工程の固定（改訂117・118）を追記した。あわせてマスタCSV・実績CSVの列の案内（`AlternativeGroup`・`IsAlternative`・`Backflush`）、サンプルの説明、利用者ガイド（帳票・用語・マスタのCSV・部材投入）を改訂117〜121に合わせた）
+改訂123: 2026-09-23（工程管理項目の自由記述（`Routing.ControlItems`）の長さの上限を、工順・作業指示・API・マスタCSVで1000文字に揃えた。工順が1000文字、展開先の作業指示が500文字だったため、501文字以上を書いた工順は PostgreSQL / SQL Server で指図の展開に失敗していた（SQLiteは長さを守らせないため表に出なかった）。上限を超える記述は工順の登録で拒否する）
+改訂124: 2026-09-23（工程管理項目を工順（BOP）の工程ごとに紐付けるようにした（`RoutingControlItem`。I-30-20-10）。これまでは項目側の対象品目/対象工程に「または」で合致する項目を展開時に自動選択していたため、品目を指定した項目がその品目の全工程の作業指示に載り、品目と工程の組合せや、同じ工程が2回ある工順の工程ごとの条件を表せなかった。改訂48の「工順に明示的な紐付けを持たせない」方針を改め、`ControlItem` から対象品目・対象工程を削除した（作業手順書と同じく紐付けは工順側だけに持つ）。紐付けられるのは有効な項目だけで、紐付け中の項目は単票APIでもCSV取込でも無効化できない（`MasterDeactivationPolicy`）。API は `RoutingStepRequest.ControlItemIds`、CSV は工程管理項目から `TargetProductCode`・`TargetProcessCode` を外し、工順に `ControlItemCodes`（セミコロン区切り）を追加。`Routing.ControlItems` の自由記述は補足として残す。5.1節・5.7節に反映）
 参考: みんなのMES（min-MES） https://min-mes.com/ / OSS: https://github.com/mihatama/open-mes-project
 
 ---
@@ -407,14 +409,15 @@ DBはバックエンド（MesApp.Api）のみが保持し、既定はSQLiteと
 | Product（品目マスタ） | 品目コード、品目名、単位、規格、品目区分（製品/半製品・中間品/部材）、標準不良率（0〜99.99%。指図の予定材料を割り増す。A-40-10-04）、**既定ロケーション**（推奨ロケーション指示の第一候補。D-10-30-03） |
 | BomItem（MBOM明細） | 親品目ID、子品目ID（部材）、必要数量（親1単位あたり）、内外製区分、代替部品グループ、**代替部品フラグ**（同一グループ内の主材料でない行。A-40-10）、**消費工程**（工順の工程順序。未指定なら最終工程。B-40-10-09）。品目自身を子品目にする行と、明細をたどって親品目へ戻る循環は登録できない（単票API・CSVで同じ判定。`ProductStructurePolicy.FindBomCycle`）。代替部品グループは主材料（代替部品フラグの無い行）をちょうど1つ持ち、代替部品フラグの行はグループを必須とする（`CheckAlternativeGroups`。グループ名は前後の空白を除いて保存・比較） |
 | Process（工程マスタ） | 工程コード、工程名、工程区分（内製/外注） |
-| Routing（工順/BOP） | 品目ID、工程順序、工程ID、標準作業時間（**1個あたり**）、標準段取り時間（**1回あたり**）、必要スキルID、**候補設備**・治工具、**作業区**、工程管理項目、チェックリストID、**作業手順書ID**（A-40-20、I-30-20）<br>標準時間の予実（3.2節 B-60-10-05）は 段取り時間＋作業時間×数量 で予定を出す |
+| Routing（工順/BOP） | 品目ID、工程順序、工程ID、標準作業時間（**1個あたり**）、標準段取り時間（**1回あたり**）、必要スキルID、**候補設備**・治工具、**作業区**、**工程管理項目（紐付け）**と補足（自由記述）、チェックリストID、**作業手順書ID**（A-40-20、I-30-20）<br>標準時間の予実（3.2節 B-60-10-05）は 段取り時間＋作業時間×数量 で予定を出す |
 | RoutingEquipment（工順の候補設備） | 工順ID、設備ID（同一工順で一意）。同じ工程を複数の装置で実行できる場合に列挙し、差立ではこの中から1台を選ぶ（B-10-20-02） |
+| RoutingControlItem（工順の工程管理項目） | 工順ID、工程管理項目ID（同一工順で一意）。その工程で記録する製造条件を指す。指図展開時にこの紐付けどおり作業指示へ指示値を写す（I-30-20-10、B-30-30-04） |
 | WorkCenter（作業区／資源階層） | 作業区コード、名称、段（工場/ライン/エリア/作業区）、上位の資源、有効フラグ。工場・ライン・エリア・作業区を1つの自己参照ツリーで持ち、資源構成全体（BOR）を表す。最下段の作業区が作業の管理単位（I-10-20-02） |
 | Equipment（設備台帳/BOE） | 資産番号、設備名、**設置場所（作業区）**、状態（稼働可能/停止中/保全中/廃棄・除却。差立は稼働可能のみ）、保全タイプ（カレンダ/時間/回数ベース）、保全閾値、**保全部品（`EquipmentPart`）**（E-10-10、I-10-20）。`MaintenanceParts`（自由記述の保全部品）と`Site`（自由記述の設置場所）は作業区を整備するまでの旧項目として残すが、**設置場所の正は作業区参照**とする |
 | EquipmentPart（設備の保全部品） | 設備ID、部品の品目ID（同一設備で一意）、管理区分（資産管理部品/消耗品）、1回あたり数量、備考。自由記述では消耗材の使用状況（E-20-10-04）を集計できないため品目マスタを参照する（E-10-10-01） |
 | Tool（治工具マスタ） | 治工具コード、名称、種別（型/切削工具/検査工具等）、寿命閾値（使用回数/時間）、状態（使用可能/使用中/メンテナンス中/廃棄。**使用中は引当（`ToolIssue`）から決まり、マスタ編集・CSV取込では付けも外しもできない**。引当中の治工具は使用可能にできず、メンテナンス中・廃棄への変更はできる）（E-60） |
 | Location（ロケーション） | ロケーションコード、倉庫/エリア区分（部材倉庫/工程内/製品倉庫/出荷場）、**所属する作業区**、棚番（D-50-20-01） |
-| ControlItem（工程管理項目） | 工程管理項目コード、名称、単位、対象品目/工程、**指示値**、許容下限/上限、版数、有効フラグ。温度・回転数など製造時に記録すべき条件の定義（B-30-30-04）。検査項目と同じ形にしているのは、「指示値と実績値」の関係が「検査パラメータと検査結果」と同じ構造で、判定の考え方も揃うため |
+| ControlItem（工程管理項目） | 工程管理項目コード、名称、単位、**指示値**、許容下限/上限、版数、有効フラグ。対象品目・対象工程は持たず、工順（BOP）の工程から紐付ける（`RoutingControlItem`）。温度・回転数など製造時に記録すべき条件の定義（B-30-30-04）。検査項目と同じ形にしているのは、「指示値と実績値」の関係が「検査パラメータと検査結果」と同じ構造で、判定の考え方も揃うため |
 | InspectionItem（検査項目・基準） | 検査項目コード、対象品目/工程、検査種別（受入/工程内/完成品/サンプル）、規格値（上限/下限/基準値）、検査方法、サンプリング数、版数（C-10-10） |
 | InspectionDevice（検査機・測定器） | 検査機コード、名称、製造番号、設置場所、最終校正日、**次回校正期限**、校正周期（日）、備考、状態（C-20-50-03）。校正期限切れ・無効化された機器は検査実績に使えない |
 | InspectionDeviceCalibration（校正実施記録） | 検査機ID、校正日、次回期限、結果・所見、実施者（C-20-50-03）。現在値の上書きだけでは「いつ誰がどの結果で校正したか」が残らないため履歴に残す |
@@ -511,12 +514,15 @@ DBはバックエンド（MesApp.Api）のみが保持し、既定はSQLiteと
 - **製造条件の指示値と実績値**：製造条件（温度・回転数など）は「こう作れ」という**指示値**と「実際はこうだった」という**実績値**の対になる。指示値と許容範囲を持たないと、実績を記録しても逸脱かどうかを判定できない
   - 条件の定義と指示値・許容範囲は`ControlItem`（工程管理項目）に持つ。**検査項目（`InspectionItem`）と同じ形**にする：指示値と実績値の関係は検査パラメータと検査結果と同じ構造であり、判定・版管理・スナップショットの考え方をそのまま適用できるため
   - **指示値は許容範囲の内側であることを登録時に確認する**。範囲外を許すと、指示どおりに作った実績が逸脱と判定されてしまう
-  - **工順に明示的な紐付けは持たせない**。検査基準と同じく**対象品目/工程に合致する有効な項目を指図展開時に自動選択**し、`WorkOrderControlItem`へ写す。工順側に選択リストを持たせると、品目にも工程にも当たる条件をどちらに登録するかで運用が割れるため
+  - **どの工程で記録するかは工順（BOP）の工程ごとに紐付ける**（`RoutingControlItem`。I-30-20-10「BOPに登録された作業に工程管理条件を定義する」）。指図展開時は紐付けどおりに`WorkOrderControlItem`へ写す
+    - 項目側に対象品目・対象工程を持たせて自動で選ぶ方式（改訂48）はやめた。品目を指定した項目がその品目の**全工程**の作業指示に載り、「品目Xの加熱工程だけ」を表せず、**同じ工程が2回ある工順**では工程ごとに条件を変えられなかったため
+    - 項目側には対象を持たせない（作業手順書と同じ。両側に持たせるとどちらで紐付けたかで運用が割れる）。品目ごとに指示値が違う条件は、品目ごとに別の項目として登録する
+    - 紐付けられるのは有効な項目だけで、**紐付け中の項目は無効化できない**（`MasterDeactivationPolicy`。単票APIとCSV取込の両方で同じ条件）。無効化を許すと、使わせないはずの条件が以降の作業指示へ写り続ける
   - スナップショットを取る理由は検査基準（下記）と同じ。**マスタを改訂しても展開済みの作業指示の指示値・許容範囲・版数は変わらない**
   - **実績は指示と照合して逸脱を判定する**。判定は1か所（`Api/Policies/ControlItemDeviationPolicy`）に集約し、基準はマスタの現在値ではなく作業指示のスナップショットを使う（現在値で判定すると同じ実績の合否が後から変わる）
     - **判定しない場合を「範囲内」と混同しない**。数値でない記録（定性的な記録）と、上下限をどちらも持たない項目（記録だけが目的の条件）は判定対象外とし、逸脱フラグはnullのままにする。falseにすると、条件を決めていない項目まで合格扱いになる
     - 逸脱は監査ログの`detail`にも内容を残し、ロットの履歴（H-30-10-04）では**逸脱した記録だけ**を出す（範囲内まで並べると見るべきものが埋もれる）
-  - `Routing.ControlItems`（自由記述）は**当面残す**。既存データの表示経路であり、工程管理項目マスタを整備していない運用では唯一の記録手段になる。マスタへ移行し終えた運用で不要になった時点で削除を判断する
+  - `Routing.ControlItems`（自由記述）は**工程管理項目の補足**として残す。指示値を持たない確認事項や外注の内容など、工程管理項目にもチェックリストにも当てはまらない記述の置き場になる。作業指示へはそのまま写す（上限1000文字）
 - **製造品軸と設備軸の紐付け（2軸データ）**：製造の実績は「どのロットをどう作ったか」（製造品軸）と「そのとき設備はどうだったか」（設備軸）の2つの軸で残り、**両者の交差点**が品質不良の原因究明に効く。交差点を作るのは`EquipmentLog.対象作業指示ID`だけなので、これを欠かすと設備の状態を時刻の重なりから推測するしかなくなる
   - 稼働報告（B-40-20-01）では作業指示を**任意**で指定する。段取り・保全・アイドルのように作業指示に紐づかない稼働区間もあるため必須にはしない
   - ロットの履歴（H-30-10-04）は、そのロットを産出した作業指示に紐づく稼働区間を**設備稼働履歴**として返す。紐付けのない稼働は履歴に出ない（出すと別のロットの設備状態を混ぜて見せることになる）
diff --git a/docs-dev/CodeMap.md b/docs-dev/CodeMap.md
index aeb6db1..e0a63eb 100644
--- a/docs-dev/CodeMap.md
+++ b/docs-dev/CodeMap.md
@@ -44,7 +44,7 @@
 
 | 業務 | MES No | API | エンティティ | 画面 | テスト |
 |:--|:--|:--|:--|:--|:--|
-| 工程管理項目マスタ（指示値・許容範囲。版数付き） | B-30-30-04 | `ControlItemsController.cs` `api/control-items`<br>展開時のスナップショット取得は `WorkOrdersController.ControlItems` `api/work-orders/{id}/control-items` | Masters.cs: ControlItem<br>Production.cs: **WorkOrderControlItem**（展開時点の指示値。判定・表示はこちらを使い、マスタ現在値を参照しない） | `/masters` `Masters/ControlItemsTab.razor` | `Tests/MasterTests.cs` / `MasterCsvTests.cs` |
+| 工程管理項目マスタ（指示値・許容範囲。版数付き） | B-30-30-04 | `ControlItemsController.cs` `api/control-items`<br>展開時のスナップショット取得は `WorkOrdersController.ControlItems` `api/work-orders/{id}/control-items` | Masters.cs: ControlItem（対象品目・工程は持たない）/ **RoutingControlItem**（工順の工程への紐付け。展開はこの紐付けどおり。紐付け中は無効化できない：`MasterDeactivationPolicy`）<br>Production.cs: **WorkOrderControlItem**（展開時点の指示値。判定・表示はこちらを使い、マスタ現在値を参照しない） | `/masters` `Masters/ControlItemsTab.razor`<br>工順への紐付けは `Masters/Products/ProductRoutingEditor.razor` | `Tests/MasterTests.cs` / `MasterCsvTests.cs` / `ProductionTests.cs` |
 | 検査機・測定器マスタ／校正管理 | C-20-50-03 | `InspectionDevicesController.cs` `api/inspection-devices`<br>校正の記録は `POST {id}/calibrations`（次回期限は校正周期から自動）／期限接近は `GET expiring?withinDays=` | Masters.cs: InspectionDevice（現在の校正状態）／InspectionDeviceCalibration（実施履歴） | `/masters` `Masters/InspectionDevicesTab.razor` | `Tests/MasterTests.cs` / `MasterCsvTests.cs` |
 | 検査項目・基準マスタ | C-10-10 | `InspectionItemsController.cs` `api/inspection-items` | Masters.cs: InspectionItem | `/masters` `Masters/InspectionItemsTab.razor` | `Tests/MasterTests.cs` |
 | 検査指示・実績・判定・成績書 | C-20 | `InspectionOrdersController.cs` `api/inspection-orders`（発行・実績・判定の処理は `Api/Services/InspectionService.cs`。実績登録時に**検査機の校正期限を判定**：`InspectionDeviceCalibrationPolicy`） | `Core/Entities/Quality.cs`<br>InspectionOrder / InspectionOrderItem（**発行時点の基準スナップショット**。判定・成績書はこちらを使い、マスタ現在値を参照しない：Spec.md 5.7） / InspectionResult / **InspectionResultCorrection**（訂正前の記録。詳細画面・成績書に表示） | `/inspections` `Inspections.razor`<br>`/inspections/{id}` `InspectionDetail.razor`<br>`/print/inspection/{id}` `Print/InspectionCertificate.razor` | `Tests/QualityTests.cs` |
@@ -119,7 +119,7 @@
 | ロット使用可否（投入・引当・出荷の共通判定） | `Api/Policies/LotUsabilityPolicy.cs` | Spec.md 3.9。ステータス・有効期限の条件は**ここだけ**に置く。呼び先は `WorkOrderExecutionService.AddConsumptionAsync`（投入）／`InventoryService.AllocateFefoAsync`（FEFO）／`ShippingService.ShipAsync`（出荷） |
 | 製造条件の逸脱判定 | `Api/Policies/ControlItemDeviationPolicy.cs` | Spec.md 5.7。基準は**マスタ現在値ではなく作業指示のスナップショット**（`WorkOrderControlItem`）。数値なし・上下限なしは判定せず`null`のまま（`false`にしない）。呼び先は `WorkOrderExecutionService.AddDataRecordsAsync` |
 | 直（シフト）の時間帯判定 | `Api/Policies/ShiftSchedulePolicy.cs` | Spec.md 5.7。日跨ぎ（`EndTime <= StartTime`）・重なり判定・時刻→直の解決・**製造日の境界またぎの警告**（`CheckBusinessDateBoundary`。拒否ではなく `ShiftResponse.BoundaryWarning` で返す）。単票APIとCSV取込の両方から通す。重なり判定は**0時で切って区間に開いてから突き合わせる**（開始・終了の大小比較だと 22:00〜06:00 と 05:00〜09:00 の重なりを見落とす）。判定の単体テストは `Tests/ShiftSchedulePolicyTests.cs`（1440分の総当たりを期待値にした網羅テストで等価性を固定） |
-| 工順・品目から参照できるマスタ | `Api/Policies/ProductStructurePolicy.cs` | Spec.md 5.7。工順の作業区（最下段かつ有効）・作業手順書（有効）・品目の既定ロケーション（有効）・候補設備（代表設備を含める）・**MBOMの循環（`FindBomCycle`）と代替部品グループの整合（`CheckAlternativeGroups`）**。呼び先は `ProductStructureService` / `ProductsController` と `MasterCsvService.Import` の `ImportProductsAsync`・`ImportRoutingAsync`・`ImportBomAsync`。`Tests/MasterTests.cs` / `MasterCsvTests.cs` |
+| 工順・品目から参照できるマスタ | `Api/Policies/ProductStructurePolicy.cs` | Spec.md 5.7。工順の作業区（最下段かつ有効）・作業手順書（有効）・工程管理項目（有効）・品目の既定ロケーション（有効）・候補設備（代表設備を含める）・**MBOMの循環（`FindBomCycle`）と代替部品グループの整合（`CheckAlternativeGroups`）**。呼び先は `ProductStructureService` / `ProductsController` と `MasterCsvService.Import` の `ImportProductsAsync`・`ImportRoutingAsync`・`ImportBomAsync`。`Tests/MasterTests.cs` / `MasterCsvTests.cs` |
 | 部材投入の照合（予定材料） | `Api/Policies/MaterialIssuePolicy.cs` | Spec.md 3.9・5.7。基準はMBOMの現在値ではなく**指図の予定材料**。呼び先は `WorkOrderExecutionService.AddConsumptionAsync` |
 | 作業指示ステータス変更（＋状態履歴） | `Api/Services/WorkOrderStatusService.cs`<br>`Core/Entities/Production.cs`: WorkOrderStatusHistory | Spec.md 5.2。`WorkOrder.Status` を**直接代入しない**。履歴は `GET api/work-orders/{id}/status-history` |
 | システム管理者を失わない | `Api/Policies/LastAdminPolicy.cs` | Spec.md 3.6。有効なシステム管理者が0人になる無効化・降格を拒否する。呼び先は `UsersController.Update`（1件ずつ判定）／`MasterCsvService.Import.ImportUsersAsync`（**全行の適用後**に判定。行順で引き継ぎを弾かないため）。`Tests/MasterTests.cs` / `MasterCsvTests.cs` |
diff --git a/docs/masters.md b/docs/masters.md
index 74aad8f..d8a0c88 100644
--- a/docs/masters.md
+++ b/docs/masters.md
@@ -112,7 +112,8 @@ MBOMは、実績入力の**バックフラッシュ**（部材の自動消費）
 | 必要スキル・資格 | 差立時に作業者の資格を照合します |
 | 使用設備 / 使用治工具 | 既定の設備・治工具 |
 | チェックリスト | この工程で実施するチェックリスト |
-| 工程管理項目 | 温度、回転数など記録すべき条件のメモ |
+| 工程管理項目 | この工程で記録する製造条件（温度・回転数など）を、工程管理項目マスタから複数選択します。展開した作業指示に指示値と許容範囲が写り、実績と照合されます |
+| 工程管理項目の補足 | 指示値の無い確認事項などのメモ |
 
 **工程を追加** で行を積み上げ、**工順を保存（一括置換）** で確定します。MBOMと同様に一括置換です。
 
diff --git a/samples/master-csv/13_control-items.csv b/samples/master-csv/13_control-items.csv
index c2bb651..a4f7475 100644
--- a/samples/master-csv/13_control-items.csv
+++ b/samples/master-csv/13_control-items.csv
@@ -1,5 +1,5 @@
-Code,Name,Unit,TargetProductCode,TargetProcessCode,TargetValue,LowerLimit,UpperLimit,IsActive
-CI-01,主軸回転数,rpm,SF-2000,PR-10,8000,7600,8400,true
-CI-02,送り速度,mm/min,SF-2000,PR-10,1200,1100,1300,true
-CI-03,締付トルク,N・m,FG-1000,PR-30,10,9,11,true
-CI-04,試験圧力,MPa,FG-1000,PR-40,0.5,0.48,0.52,true
+Code,Name,Unit,TargetValue,LowerLimit,UpperLimit,IsActive
+CI-01,主軸回転数,rpm,8000,7600,8400,true
+CI-02,送り速度,mm/min,1200,1100,1300,true
+CI-03,締付トルク,N・m,10,9,11,true
+CI-04,試験圧力,MPa,0.5,0.48,0.52,true
diff --git a/samples/master-csv/17_routing.csv b/samples/master-csv/17_routing.csv
index 67d672e..6bec392 100644
--- a/samples/master-csv/17_routing.csv
+++ b/samples/master-csv/17_routing.csv
@@ -1,6 +1,6 @@
-ProductCode,Sequence,ProcessCode,StandardWorkMinutes,StandardSetupMinutes,RequiredSkillCode,EquipmentAssetNo,EquipmentAssetNos,ToolCode,WorkCenterCode,ChecklistCode,ControlItems,WorkProcedureNo
-SF-2000,10,PR-10,25,15,SK-01,EQ-01,EQ-01;EQ-05,TL-01,WC-MC1,CL-01,"主軸回転数, 送り速度",SOP-MC-001
-SF-2000,20,PR-20,0,0,,,,,,,外注（アルマイト処理）,
-FG-1000,10,PR-30,30,10,SK-04,EQ-02,,TL-02,WC-AS1,CL-02,締付トルク,SOP-AS-001
-FG-1000,20,PR-40,15,5,SK-03,EQ-03,,TL-03,WC-QC1,,試験圧力,
-FG-1000,30,PR-50,10,5,,EQ-04,,,WC-PK1,CL-03,,
+ProductCode,Sequence,ProcessCode,StandardWorkMinutes,StandardSetupMinutes,RequiredSkillCode,EquipmentAssetNo,EquipmentAssetNos,ToolCode,WorkCenterCode,ChecklistCode,ControlItems,ControlItemCodes,WorkProcedureNo
+SF-2000,10,PR-10,25,15,SK-01,EQ-01,EQ-01;EQ-05,TL-01,WC-MC1,CL-01,,CI-01;CI-02,SOP-MC-001
+SF-2000,20,PR-20,0,0,,,,,,,外注（アルマイト処理）,,
+FG-1000,10,PR-30,30,10,SK-04,EQ-02,,TL-02,WC-AS1,CL-02,,CI-03,SOP-AS-001
+FG-1000,20,PR-40,15,5,SK-03,EQ-03,,TL-03,WC-QC1,,吐出音に異音が無いこと,CI-04,
+FG-1000,30,PR-50,10,5,,EQ-04,,,WC-PK1,CL-03,,,
diff --git a/samples/master-csv/README.md b/samples/master-csv/README.md
index d84b836..a4b2a4d 100644
--- a/samples/master-csv/README.md
+++ b/samples/master-csv/README.md
@@ -36,11 +36,11 @@ RM-3001 ハウジング鋳造品
 | 10 | `10_checklists.csv` | チェックリスト | 同じコードの複数行が1つのチェックリストになる例 |
 | 11 | `11_defect-reasons.csv` | 不良理由 | 材質・加工・設備・人的要因・その他 |
 | 12 | `12_inspection-items.csv` | 検査項目・基準 | 規格値あり／なし、受入・工程内・完成品・サンプル検査 |
-| 13 | `13_control-items.csv` | 工程管理項目 | 指示値と許容範囲（製造条件の逸脱判定に使う） |
+| 13 | `13_control-items.csv` | 工程管理項目 | 指示値と許容範囲（製造条件の逸脱判定に使う）。どの工程で記録するかは `17_routing.csv` の `ControlItemCodes` で紐付ける |
 | 14 | `14_inspection-devices.csv` | 検査機・測定器 | 校正期限切れの機器を1台含む（システム管理者のみ取込可） |
 | 15 | `15_bom.csv` | 品目・MBOM・工順 | FG-1000 と SF-2000 のMBOM。Oリングに代替部品あり。部材はどれも最初の工程（工程10）で消費する |
 | 16 | `16_work-procedures.csv` | 作業手順書 | 手順を本文に書く例と、所在だけを書く例（システム管理者のみ取込可） |
-| 17 | `17_routing.csv` | 品目・MBOM・工順 | 候補設備・作業区・治工具・スキル・チェックリスト・手順書を紐づけた工順 |
+| 17 | `17_routing.csv` | 品目・MBOM・工順 | 候補設備・作業区・治工具・スキル・チェックリスト・工程管理項目・手順書を紐づけた工順 |
 | 18 | `18_users.csv` | ユーザー | 各ロールの担当者。作業場所・所属・直つき（システム管理者のみ取込可） |
 | 19 | `19_user-skills.csv` | ユーザー | ユーザーへのスキル・資格の割当（システム管理者のみ取込可） |
 
@@ -59,7 +59,7 @@ RM-3001 ハウジング鋳造品
 - **明細は同じキーの行をまとめる**（`08_equipment-parts.csv` は設備単位、`10_checklists.csv` はコード単位、
   `15_bom.csv` は親品目単位、`17_routing.csv` は品目単位。取込時はその明細を丸ごと置き換えます）
 - **他のマスタはコードで参照する**（`17_routing.csv` の `ProcessCode` / `EquipmentAssetNo` など）
-- **複数の値はセミコロンで区切る**（`17_routing.csv` の `EquipmentAssetNos`、`18_users.csv` の `Roles`）
+- **複数の値はセミコロンで区切る**（`17_routing.csv` の `EquipmentAssetNos`・`ControlItemCodes`、`18_users.csv` の `Roles`）
 - **設備と工順の作業区は最下段（作業区）だけ**を指定できる。ロケーションとユーザーは工場・エリアなど、どの段でもよい
 - **工程順序は 10, 20, 30 のように間隔を空けておく**と、後から工程を差し込みやすくなります
 
diff --git a/src/MesApp.Api/Controllers/ControlItemsController.cs b/src/MesApp.Api/Controllers/ControlItemsController.cs
index 8cda990..2b00dad 100644
--- a/src/MesApp.Api/Controllers/ControlItemsController.cs
+++ b/src/MesApp.Api/Controllers/ControlItemsController.cs
@@ -1,4 +1,5 @@
 using MesApp.Api.Localization;
+using MesApp.Api.Policies;
 using MesApp.Core.Abstractions;
 using MesApp.Core.Contracts.Masters;
 using MesApp.Core.Entities;
@@ -13,6 +14,7 @@ namespace MesApp.Api.Controllers;
 /// 工程管理項目マスタ（Spec.md 5.1 ControlItem。B-30-30-04）。
 /// 温度・回転数など製造時に記録すべき条件の定義と指示値・上下限を持つ。
 /// 条件の改訂では版数を自動インクリメントする（検査項目 C-10-10-03 と同じ扱い）。
+/// どの工程で記録するかは工順（BOP）側で紐付ける（I-30-20-10。<see cref="RoutingControlItem"/>）。
 /// </summary>
 [ApiController]
 [Route("api/control-items")]
@@ -22,8 +24,6 @@ public class ControlItemsController(MesAppDbContext db, IAuditLogger auditLogger
     [HttpGet]
     public async Task<ActionResult<List<ControlItemResponse>>> List(
         [FromQuery] bool includeInactive = false,
-        [FromQuery] int? targetProductId = null,
-        [FromQuery] int? targetProcessId = null,
         CancellationToken ct = default)
     {
         var query = BaseQuery();
@@ -31,14 +31,6 @@ public async Task<ActionResult<List<ControlItemResponse>>> List(
         {
             query = query.Where(i => i.IsActive);
         }
-        if (targetProductId is not null)
-        {
-            query = query.Where(i => i.TargetProductId == targetProductId);
-        }
-        if (targetProcessId is not null)
-        {
-            query = query.Where(i => i.TargetProcessId == targetProcessId);
-        }
         return await query.OrderBy(i => i.Code).Select(i => ToResponse(i)).ToListAsync(ct);
     }
 
@@ -57,7 +49,7 @@ public async Task<ActionResult<ControlItemResponse>> Create(ControlItemRequest r
         {
             return this.ConflictProblem(ApiText.T("工程管理項目コード '{0}' は既に存在します。", request.Code));
         }
-        if (await ValidateAsync(request, ct) is { } error)
+        if (Validate(request) is { } error)
         {
             return this.BadRequestProblem(error);
         }
@@ -67,8 +59,6 @@ public async Task<ActionResult<ControlItemResponse>> Create(ControlItemRequest r
             Code = request.Code,
             Name = request.Name,
             Unit = request.Unit,
-            TargetProductId = request.TargetProductId,
-            TargetProcessId = request.TargetProcessId,
             TargetValue = request.TargetValue,
             LowerLimit = request.LowerLimit,
             UpperLimit = request.UpperLimit,
@@ -94,7 +84,7 @@ public async Task<ActionResult<ControlItemResponse>> Update(
         {
             return this.ConflictProblem(ApiText.T("工程管理項目コード '{0}' は既に存在します。", request.Code));
         }
-        if (await ValidateAsync(request, ct) is { } error)
+        if (Validate(request) is { } error)
         {
             return this.BadRequestProblem(error);
         }
@@ -102,8 +92,6 @@ public async Task<ActionResult<ControlItemResponse>> Update(
         item.Code = request.Code;
         item.Name = request.Name;
         item.Unit = request.Unit;
-        item.TargetProductId = request.TargetProductId;
-        item.TargetProcessId = request.TargetProcessId;
         item.TargetValue = request.TargetValue;
         item.LowerLimit = request.LowerLimit;
         item.UpperLimit = request.UpperLimit;
@@ -117,10 +105,19 @@ await auditLogger.LogAsync("Master", "Update", nameof(ControlItem), id.ToString(
     [HttpDelete("{id:int}")]
     [Authorize(Roles = MesRoleGroups.MasterWrite)]
     public Task<IActionResult> Deactivate(int id, CancellationToken ct) =>
-        this.DeactivateMasterAsync<ControlItem>(db, auditLogger, id, item => $"code={item.Code}", ct);
+        this.DeactivateMasterAsync<ControlItem>(db, auditLogger, id, item => $"code={item.Code}", ct,
+            // 工順から紐付けている項目を無効化すると、展開した作業指示に改訂されない指示値が載り続ける。
+            // 判定は MasterDeactivationPolicy に置き、CSV取込と同じ条件・同じ文面で弾く
+            precheck: async item => MasterDeactivationPolicy.CheckControlItem(
+                item.Code,
+                await db.RoutingControlItems.AsNoTracking()
+                    .Where(l => l.ControlItemId == id)
+                    .Select(l => l.Routing!.Product!.Code)
+                    .Distinct()
+                    .ToListAsync(ct)));
 
-    /// <summary>上下限の整合と参照先の存在を確認する。問題があれば日本語の理由を返す</summary>
-    private async Task<string?> ValidateAsync(ControlItemRequest request, CancellationToken ct)
+    /// <summary>上下限と指示値の整合を確認する。問題があれば日本語の理由を返す</summary>
+    private static string? Validate(ControlItemRequest request)
     {
         if (request.LowerLimit is { } lower && request.UpperLimit is { } upper && lower > upper)
         {
@@ -138,23 +135,10 @@ public Task<IActionResult> Deactivate(int id, CancellationToken ct) =>
                 return ApiText.T("指示値が許容上限を超えています。");
             }
         }
-        if (request.TargetProductId is { } productId
-            && !await db.Products.AnyAsync(p => p.Id == productId, ct))
-        {
-            return ApiText.T("対象品目（ID {0}）が見つかりません。", productId);
-        }
-        if (request.TargetProcessId is { } processId
-            && !await db.Processes.AnyAsync(p => p.Id == processId, ct))
-        {
-            return ApiText.T("対象工程（ID {0}）が見つかりません。", processId);
-        }
         return null;
     }
 
-    private IQueryable<ControlItem> BaseQuery() =>
-        db.ControlItems.AsNoTracking()
-            .Include(i => i.TargetProduct)
-            .Include(i => i.TargetProcess);
+    private IQueryable<ControlItem> BaseQuery() => db.ControlItems.AsNoTracking();
 
     private async Task<ControlItemResponse?> GetResponseAsync(int id, CancellationToken ct)
     {
@@ -164,7 +148,5 @@ private IQueryable<ControlItem> BaseQuery() =>
 
     private static ControlItemResponse ToResponse(ControlItem i) =>
         new(i.Id, i.Code, i.Name, i.Unit,
-            i.TargetProductId, i.TargetProduct?.Code,
-            i.TargetProcessId, i.TargetProcess?.Code,
             i.TargetValue, i.LowerLimit, i.UpperLimit, i.Version, i.IsActive);
 }
diff --git a/src/MesApp.Api/Controllers/ProductsController.cs b/src/MesApp.Api/Controllers/ProductsController.cs
index fb708f5..bc4a704 100644
--- a/src/MesApp.Api/Controllers/ProductsController.cs
+++ b/src/MesApp.Api/Controllers/ProductsController.cs
@@ -180,6 +180,7 @@ public async Task<ActionResult<List<RoutingStepResponse>>> GetRouting(int id, Ca
         return await db.Routings.AsNoTracking()
             .Include(r => r.EquipmentCandidates).ThenInclude(c => c.Equipment)
             .Include(r => r.WorkProcedure)
+            .Include(r => r.ControlItemLinks).ThenInclude(l => l.ControlItem)
             .Where(r => r.ProductId == id)
             .OrderBy(r => r.Sequence)
             .Select(r => new RoutingStepResponse(
@@ -195,7 +196,11 @@ public async Task<ActionResult<List<RoutingStepResponse>>> GetRouting(int id, Ca
                     .Select(c => c.EquipmentId).ToList(),
                 r.WorkProcedureId,
                 r.WorkProcedure != null ? r.WorkProcedure.ProcedureNo : null,
-                r.WorkProcedure != null ? r.WorkProcedure.Title : null))
+                r.WorkProcedure != null ? r.WorkProcedure.Title : null,
+                r.ControlItemLinks.OrderBy(l => l.ControlItem!.Code)
+                    .Select(l => l.ControlItemId).ToList(),
+                r.ControlItemLinks.OrderBy(l => l.ControlItem!.Code)
+                    .Select(l => l.ControlItem!.Code).ToList()))
             .ToListAsync(ct);
     }
 
diff --git a/src/MesApp.Api/Localization/ApiText.en.resx b/src/MesApp.Api/Localization/ApiText.en.resx
index 73ff611..aed7dcb 100644
--- a/src/MesApp.Api/Localization/ApiText.en.resx
+++ b/src/MesApp.Api/Localization/ApiText.en.resx
@@ -900,9 +900,6 @@
   <data name="品目 '{0}' の工程順序 {1} が重複しています。" xml:space="preserve">
     <value>Process sequence {1} of item '{0}' is duplicated.</value>
   </data>
-  <data name="候補設備 '{0}' は登録されていません（EquipmentAssetNos）。" xml:space="preserve">
-    <value>Candidate equipment '{0}' is not registered (EquipmentAssetNos).</value>
-  </data>
   <data name="StartTime（開始時刻）とEndTime（終了時刻）は HH:mm で指定してください。" xml:space="preserve">
     <value>StartTime (start time) and EndTime (end time) must be in HH:mm format.</value>
   </data>
@@ -2016,4 +2013,7 @@
   <data name="グループの主材料（IsAlternative=false）はちょうど1つ" xml:space="preserve">
     <value>Exactly one primary material (IsAlternative=false) per group</value>
   </data>
+  <data name="工程管理項目 '{0}' は品目 {1} の工順から紐付けられているため無効化できません。" xml:space="preserve">
+    <value>Control item '{0}' cannot be deactivated because it is linked from the routing of item {1}.</value>
+  </data>
 </root>
diff --git a/src/MesApp.Api/Policies/MasterDeactivationPolicy.cs b/src/MesApp.Api/Policies/MasterDeactivationPolicy.cs
index 161e9a1..ab6b08a 100644
--- a/src/MesApp.Api/Policies/MasterDeactivationPolicy.cs
+++ b/src/MesApp.Api/Policies/MasterDeactivationPolicy.cs
@@ -24,6 +24,17 @@ public static class MasterDeactivationPolicy
             ? null
             : ApiText.T("手順書 '{0}' は品目 {1} の工順から参照されているため無効化できません。", procedureNo, string.Join("、", referencingProductCodes));
 
+    /// <summary>
+    /// 工程管理項目（B-30-30-04）。工順から紐付けている項目を無効化すると、
+    /// 以降に展開する作業指示へ「使わせないはずの条件」が載り続ける（展開時は紐付けどおりに写すため）。
+    /// </summary>
+    /// <param name="referencingProductCodes">その項目を紐付けている工順の品目コード（重複なし）</param>
+    public static string? CheckControlItem(
+        string code, IReadOnlyCollection<string> referencingProductCodes) =>
+        referencingProductCodes.Count == 0
+            ? null
+            : ApiText.T("工程管理項目 '{0}' は品目 {1} の工順から紐付けられているため無効化できません。", code, string.Join("、", referencingProductCodes));
+
     /// <summary>
     /// 勤務シフト（F-10-10-01）。所属する直として使われている間に無効化すると、従業員の所属が宙に浮く。
     /// </summary>
diff --git a/src/MesApp.Api/Policies/ProductStructurePolicy.cs b/src/MesApp.Api/Policies/ProductStructurePolicy.cs
index 9e5e843..1fe8327 100644
--- a/src/MesApp.Api/Policies/ProductStructurePolicy.cs
+++ b/src/MesApp.Api/Policies/ProductStructurePolicy.cs
@@ -24,6 +24,13 @@ public static IQueryable<WorkCenter> AssignableWorkCenters(IQueryable<WorkCenter
     public static IQueryable<WorkProcedure> AssignableWorkProcedures(IQueryable<WorkProcedure> source) =>
         source.Where(p => p.IsActive);
 
+    /// <summary>
+    /// 工順に紐付けられる工程管理項目。無効な項目を紐付けると、使わせないはずの条件が作業指示に載る
+    /// （紐付け中の無効化は <see cref="MasterDeactivationPolicy.CheckControlItem"/> で止める）
+    /// </summary>
+    public static IQueryable<ControlItem> AssignableControlItems(IQueryable<ControlItem> source) =>
+        source.Where(i => i.IsActive);
+
     /// <summary>品目の既定ロケーションに指定できるロケーション。無効なロケーションは推奨に出せないため弾く</summary>
     public static IQueryable<Location> AssignableDefaultLocations(IQueryable<Location> source) =>
         source.Where(l => l.IsActive);
diff --git a/src/MesApp.Api/Services/ManufacturingOrderService.cs b/src/MesApp.Api/Services/ManufacturingOrderService.cs
index d0d07e6..7c9d10e 100644
--- a/src/MesApp.Api/Services/ManufacturingOrderService.cs
+++ b/src/MesApp.Api/Services/ManufacturingOrderService.cs
@@ -205,6 +205,7 @@ public async Task<OrderOutcome> ExpandAsync(ManufacturingOrder order, string? lo
 
         var routing = await db.Routings
             .Include(r => r.WorkProcedure)
+            .Include(r => r.ControlItemLinks).ThenInclude(l => l.ControlItem)
             .Where(r => r.ProductId == order.ProductId)
             .OrderBy(r => r.Sequence)
             .ToListAsync(ct);
@@ -251,14 +252,8 @@ public async Task<OrderOutcome> ExpandAsync(ManufacturingOrder order, string? lo
 
         // 工順（BOP）は展開時点の値を作業指示へ写して固定する（Spec.md 5.7）。
         // 以降に工順が改訂されても、この指図の標準時間・必要スキル・管理項目は変わらない
-        // 工程管理項目も同じ理由で展開時点の値を写す（B-30-30-04）。検査基準のスナップショットと同じ方針で、
-        // 対象品目/工程に合致する有効な項目を自動選択する（工順に明示的な紐付けを持たせない）
-        var controlItems = await db.ControlItems.AsNoTracking()
-            .Where(i => i.IsActive && i.TargetProductId == order.ProductId)
-            .ToListAsync(ct);
-        var processControlItems = await db.ControlItems.AsNoTracking()
-            .Where(i => i.IsActive && i.TargetProcessId != null)
-            .ToListAsync(ct);
+        // 工程管理項目も同じ理由で展開時点の値を写す（B-30-30-04）。どの項目を載せるかは工順の工程ごとの紐付けに従う
+        // （I-30-20-10。紐付け中の項目は無効化できないため、ここで有効かを見直す必要はない）
 
         foreach (var step in routing)
         {
@@ -281,13 +276,11 @@ public async Task<OrderOutcome> ExpandAsync(ManufacturingOrder order, string? lo
                 // 表示はマスタの現在値を使い、ここには「計画時の版数」だけを残す
                 WorkProcedureVersion = step.WorkProcedure?.Version,
             };
-            // 品目単位の項目と、この工程を対象にした項目を合わせる（同じ項目は1回だけ）
             workOrder.ControlItemSnapshots =
             [
-                .. controlItems
-                    .Concat(processControlItems.Where(i => i.TargetProcessId == step.ProcessId))
-                    .DistinctBy(i => i.Id)
-                    .OrderBy(i => i.Code)
+                .. step.ControlItemLinks
+                    .Select(l => l.ControlItem!)
+                    .OrderBy(i => i.Code, StringComparer.Ordinal)
                     .Select(i => new WorkOrderControlItem
                     {
                         ControlItemId = i.Id,
diff --git a/src/MesApp.Api/Services/MasterCsvKinds.cs b/src/MesApp.Api/Services/MasterCsvKinds.cs
index 2d7fe83..758e7b8 100644
--- a/src/MesApp.Api/Services/MasterCsvKinds.cs
+++ b/src/MesApp.Api/Services/MasterCsvKinds.cs
@@ -119,12 +119,10 @@ public static class MasterCsvKinds
             new("Code", "工程管理項目コード", true, null),
             new("Name", "名称", true, null),
             new("Unit", "単位", false, "℃ / rpm など"),
-            new("TargetProductCode", "対象品目コード", false, "登録済みの品目コード"),
-            new("TargetProcessCode", "対象工程コード", false, "登録済みの工程コード"),
             new("TargetValue", "指示値", false, "許容範囲の内側であること"),
             new("LowerLimit", "許容下限", false, null),
             new("UpperLimit", "許容上限", false, null),
-            new("IsActive", "有効", false, "true / false"),
+            new("IsActive", "有効", false, "true / false。工順から紐付けている項目は無効にできない"),
         ]),
         new(Checklists, "チェックリスト", false,
         [
@@ -178,7 +176,8 @@ public static class MasterCsvKinds
             new("ToolCode", "使用治工具コード", false, null),
             new("WorkCenterCode", "作業区コード", false, "登録済みの作業区コード（段が作業区のもの）"),
             new("ChecklistCode", "チェックリストコード", false, null),
-            new("ControlItems", "工程管理項目", false, "温度・回転数 など"),
+            new("ControlItems", "工程管理項目の補足", false, "自由記述。指示値を持つ条件は ControlItemCodes で紐付ける"),
+            new("ControlItemCodes", "工程管理項目コード", false, "セミコロン区切り。登録済みで有効な項目。作業指示に指示値を写す"),
             new("WorkProcedureNo", "作業手順書番号", false, "登録済みで有効な手順書の番号"),
         ]),
         new(WorkProcedures, "作業手順書（SOP）", true,
diff --git a/src/MesApp.Api/Services/MasterCsvService.Import.cs b/src/MesApp.Api/Services/MasterCsvService.Import.cs
index ef2b417..76e7386 100644
--- a/src/MesApp.Api/Services/MasterCsvService.Import.cs
+++ b/src/MesApp.Api/Services/MasterCsvService.Import.cs
@@ -773,11 +773,17 @@ private async Task ImportControlItemsAsync(
         CsvTable table, List<CsvImportError> errors, ImportCounter counter, CancellationToken ct)
     {
         var byCode = await db.ControlItems.ToDictionaryAsync(i => i.Code, StringComparer.Ordinal, ct);
-        var productIds = await db.Products.AsNoTracking()
-            .ToDictionaryAsync(p => p.Code, p => p.Id, StringComparer.Ordinal, ct);
-        var processIds = await db.Processes.AsNoTracking()
-            .ToDictionaryAsync(p => p.Code, p => p.Id, StringComparer.Ordinal, ct);
         var seen = new HashSet<string>(StringComparer.Ordinal);
+        // 工順から紐付けている項目を無効化できないのは単票APIと同じ。行ごとに引けるよう先にまとめて読む
+        // （工順は別種別のCSVなので、この取込の途中で紐付けが変わることはない）
+        var referencingProducts = (await db.RoutingControlItems.AsNoTracking()
+                .Select(l => new { l.ControlItemId, ProductCode = l.Routing!.Product!.Code })
+                .Distinct()
+                .ToListAsync(ct))
+            .GroupBy(x => x.ControlItemId)
+            .ToDictionary(
+                g => g.Key,
+                g => (IReadOnlyCollection<string>)g.Select(x => x.ProductCode).ToList());
 
         foreach (var row in table.Rows)
         {
@@ -793,12 +799,16 @@ private async Task ImportControlItemsAsync(
 
             var name = reader.RequiredText("Name", 200);
             var unit = reader.Text("Unit", item.Unit, 30);
-            var productId = reader.Reference("TargetProductCode", item.TargetProductId, productIds, "対象品目");
-            var processId = reader.Reference("TargetProcessCode", item.TargetProcessId, processIds, "対象工程");
             var target = reader.NumberOrNull("TargetValue", item.TargetValue);
             var lower = reader.NumberOrNull("LowerLimit", item.LowerLimit);
             var upper = reader.NumberOrNull("UpperLimit", item.UpperLimit);
             var isActive = reader.Bool("IsActive", item.IsActive);
+            if (!isNew && item.IsActive && !isActive
+                && MasterDeactivationPolicy.CheckControlItem(
+                    code, referencingProducts.GetValueOrDefault(item.Id, [])) is { } inUse)
+            {
+                reader.Fail(inUse);
+            }
             if (reader.Failed)
             {
                 continue;
@@ -817,8 +827,6 @@ private async Task ImportControlItemsAsync(
 
             item.Name = name;
             item.Unit = unit;
-            item.TargetProductId = productId;
-            item.TargetProcessId = processId;
             item.TargetValue = target;
             item.LowerLimit = lower;
             item.UpperLimit = upper;
@@ -1092,6 +1100,9 @@ private async Task ImportRoutingAsync(
         // 候補をここで絞ることで、上位の段を書いた行は「登録されていません」として弾かれる
         var workCenterIds = await ProductStructurePolicy.AssignableWorkCenters(db.WorkCenters.AsNoTracking())
             .ToDictionaryAsync(w => w.Code, w => w.Id, StringComparer.Ordinal, ct);
+        // 無効な工程管理項目は候補に入れない（単票APIと共通の条件）
+        var controlItemIds = await ProductStructurePolicy.AssignableControlItems(db.ControlItems.AsNoTracking())
+            .ToDictionaryAsync(i => i.Code, i => i.Id, StringComparer.Ordinal, ct);
         var existing = await db.Routings.ToListAsync(ct);
 
         foreach (var group in GroupRows(table, "ProductCode", errors))
@@ -1116,11 +1127,13 @@ private async Task ImportRoutingAsync(
                 var setup = reader.Number("StandardSetupMinutes", 0m, 0);
                 var skillId = reader.Reference("RequiredSkillCode", null, skillIds, "スキル・資格");
                 var equipmentId = reader.Reference("EquipmentAssetNo", null, equipmentIds, "設備");
-                var candidateIds = ParseCandidates(reader, table, row, equipmentIds);
+                var candidateIds = ParseCodeList(reader, table, row, "EquipmentAssetNos", equipmentIds, ApiText.T("候補設備"));
+                var linkedControlItemIds = ParseCodeList(
+                    reader, table, row, "ControlItemCodes", controlItemIds, ApiText.T("工程管理項目"));
                 var toolId = reader.Reference("ToolCode", null, toolIds, "治工具");
                 var checklistId = reader.Reference("ChecklistCode", null, checklistIds, "チェックリスト");
                 var workCenterId = reader.Reference("WorkCenterCode", null, workCenterIds, "作業区");
-                var controlItems = reader.Text("ControlItems", null, 500);
+                var controlItems = reader.Text("ControlItems", null, 1000);
                 var workProcedureId = reader.Reference("WorkProcedureNo", null, workProcedureIds, "作業手順書");
                 if (sequence is null && !reader.Failed)
                 {
@@ -1157,6 +1170,10 @@ .. ProductStructurePolicy.CandidateEquipmentIds(candidateIds, equipmentId)
                     WorkCenterId = workCenterId,
                     ChecklistId = checklistId,
                     ControlItems = controlItems,
+                    ControlItemLinks =
+                    [
+                        .. linkedControlItemIds.Distinct().Select(x => new RoutingControlItem { ControlItemId = x }),
+                    ],
                     WorkProcedureId = workProcedureId,
                 });
             }
@@ -1181,15 +1198,19 @@ .. ProductStructurePolicy.CandidateEquipmentIds(candidateIds, equipmentId)
 
     // ---- ユーザー（システム管理者のみ）----
 
-    /// <summary>工順CSVの候補設備列（セミコロン区切りの資産番号）を解決する</summary>
-    private static List<int> ParseCandidates(
-        CsvRowReader reader, CsvTable table, CsvRecord row, IReadOnlyDictionary<string, int> equipmentIds)
+    /// <summary>
+    /// 工順CSVのセミコロン区切りのコード列（候補設備の資産番号・工程管理項目コード）を解決する。
+    /// 候補に無いコード（未登録・無効）はその行の誤りにする
+    /// </summary>
+    private static List<int> ParseCodeList(
+        CsvRowReader reader, CsvTable table, CsvRecord row, string column,
+        IReadOnlyDictionary<string, int> idsByCode, string label)
     {
-        if (!table.HasColumn("EquipmentAssetNos"))
+        if (!table.HasColumn(column))
         {
             return [];
         }
-        var raw = table.Value(row, "EquipmentAssetNos");
+        var raw = table.Value(row, column);
         if (string.IsNullOrWhiteSpace(raw))
         {
             return [];
@@ -1197,13 +1218,13 @@ private static List<int> ParseCandidates(
         var result = new List<int>();
         foreach (var code in raw.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
         {
-            if (equipmentIds.TryGetValue(code, out var id))
+            if (idsByCode.TryGetValue(code, out var id))
             {
                 result.Add(id);
             }
             else
             {
-                reader.Fail(ApiText.T("候補設備 '{0}' は登録されていません（EquipmentAssetNos）。", code));
+                reader.Fail(ApiText.T("{0} '{1}' は登録されていません（{2}）。", label, code, column));
             }
         }
         return result;
diff --git a/src/MesApp.Api/Services/MasterCsvService.cs b/src/MesApp.Api/Services/MasterCsvService.cs
index ba6ac34..3c24007 100644
--- a/src/MesApp.Api/Services/MasterCsvService.cs
+++ b/src/MesApp.Api/Services/MasterCsvService.cs
@@ -162,12 +162,11 @@ public async Task<string> ExportAsync(CsvKindInfo kind, bool includeInactive, Ca
     private async Task<List<string?[]>> ExportControlItemsAsync(bool includeInactive, CancellationToken ct)
     {
         var items = await db.ControlItems.AsNoTracking()
-            .Include(i => i.TargetProduct).Include(i => i.TargetProcess)
             .Where(i => includeInactive || i.IsActive)
             .OrderBy(i => i.Code).ToListAsync(ct);
         return [.. items.Select(i => new string?[]
         {
-            i.Code, i.Name, i.Unit, i.TargetProduct?.Code, i.TargetProcess?.Code,
+            i.Code, i.Name, i.Unit,
             Num(i.TargetValue), Num(i.LowerLimit), Num(i.UpperLimit), Bool(i.IsActive),
         })];
     }
@@ -229,6 +228,7 @@ public async Task<string> ExportAsync(CsvKindInfo kind, bool includeInactive, Ca
             .Include(r => r.Tool).Include(r => r.Checklist).Include(r => r.WorkCenter)
             .Include(r => r.WorkProcedure)
             .Include(r => r.EquipmentCandidates).ThenInclude(c => c.Equipment)
+            .Include(r => r.ControlItemLinks).ThenInclude(l => l.ControlItem)
             .OrderBy(r => r.Product!.Code).ThenBy(r => r.Sequence)
             .ToListAsync(ct);
         return [.. items.Select(r => new string?[]
@@ -238,7 +238,9 @@ public async Task<string> ExportAsync(CsvKindInfo kind, bool includeInactive, Ca
             r.RequiredSkill?.Code, r.Equipment?.AssetNo,
             string.Join(";", r.EquipmentCandidates.Select(c => c.Equipment!.AssetNo).Order(StringComparer.Ordinal)),
             r.Tool?.Code, r.WorkCenter?.Code,
-            r.Checklist?.Code, r.ControlItems, r.WorkProcedure?.ProcedureNo,
+            r.Checklist?.Code, r.ControlItems,
+            string.Join(";", r.ControlItemLinks.Select(l => l.ControlItem!.Code).Order(StringComparer.Ordinal)),
+            r.WorkProcedure?.ProcedureNo,
         })];
     }
 
diff --git a/src/MesApp.Api/Services/ProductStructureService.cs b/src/MesApp.Api/Services/ProductStructureService.cs
index 63ba9e8..f972ec9 100644
--- a/src/MesApp.Api/Services/ProductStructureService.cs
+++ b/src/MesApp.Api/Services/ProductStructureService.cs
@@ -121,6 +121,8 @@ object[] Snapshot(IEnumerable<BomItem> lines) =>
             (steps.Where(s => s.WorkProcedureId != null).Select(s => s.WorkProcedureId!.Value),
                 ProductStructurePolicy.AssignableWorkProcedures(db.WorkProcedures).Select(x => x.Id), ApiText.T("作業手順書")),
             (steps.SelectMany(s => s.EquipmentIds ?? []), db.Equipments.Select(x => x.Id), ApiText.T("候補設備")),
+            (steps.SelectMany(s => s.ControlItemIds ?? []),
+                ProductStructurePolicy.AssignableControlItems(db.ControlItems).Select(x => x.Id), ApiText.T("工程管理項目")),
             (steps.Where(s => s.WorkCenterId != null).Select(s => s.WorkCenterId!.Value),
                 ProductStructurePolicy.AssignableWorkCenters(db.WorkCenters).Select(x => x.Id), ApiText.T("作業区")),
         })
@@ -155,6 +157,10 @@ .. ProductStructurePolicy.CandidateEquipmentIds(s.EquipmentIds, s.EquipmentId)
             ToolId = s.ToolId,
             WorkCenterId = s.WorkCenterId,
             ControlItems = s.ControlItems,
+            ControlItemLinks =
+            [
+                .. (s.ControlItemIds ?? []).Distinct().Select(x => new RoutingControlItem { ControlItemId = x }),
+            ],
             ChecklistId = s.ChecklistId,
             WorkProcedureId = s.WorkProcedureId,
         }));
diff --git a/src/MesApp.Client.Web/Pages/Masters/ControlItemsTab.razor b/src/MesApp.Client.Web/Pages/Masters/ControlItemsTab.razor
index e41eab1..55f10be 100644
--- a/src/MesApp.Client.Web/Pages/Masters/ControlItemsTab.razor
+++ b/src/MesApp.Client.Web/Pages/Masters/ControlItemsTab.razor
@@ -8,6 +8,7 @@
         <h2 style="margin-top:0;">@(_editingId is null ? L["工程管理項目の登録"] : L["編集（{0}）", _code])</h2>
         <p class="text-muted">
             @L["温度・回転数など、製造時に記録すべき条件の定義と指示値・上下限。実績はこの範囲と照合する。"]
+            @L["どの工程で記録するかは品目タブの工順で紐付けます。品目ごとに指示値が違う条件は、品目ごとに別の項目として登録してください。"]
         </p>
         <div class="form-grid">
             <div class="form-field">
@@ -22,24 +23,6 @@
                 <label>@L["単位"]</label>
                 <input @bind="_unit" placeholder="@L["℃ / rpm など"]" />
             </div>
-            <div class="form-field">
-                <label>@L["対象品目"]</label>
-                <OptionSelect TItem="ProductResponse" Endpoint="api/products/options"
-                              @bind-Value="_productId"
-                              EmptyLabel="@L["指定なし"]"
-                              ValueOf="p => p.Id"
-                              LabelOf='@(p => $"{p.Code} {p.Name}")' />
-            </div>
-            <div class="form-field">
-                <label>@L["対象工程"]</label>
-                <select @bind="_processId">
-                    <option value="0">@L["指定なし"]</option>
-                    @foreach (var process in _processes)
-                    {
-                        <option value="@process.Id">@process.Code @process.Name</option>
-                    }
-                </select>
-            </div>
             <div class="form-field">
                 <label>@L["指示値"]</label>
                 <input type="number" step="any" @bind="_target" />
@@ -74,7 +57,7 @@
     {
         <table class="table">
             <thead>
-                <tr><th>@L["コード"]</th><th>@L["名称"]</th><th>@L["単位"]</th><th>@L["対象"]</th><th>@L["指示値"]</th><th>@L["許容範囲"]</th><th>@L["版数"]</th><th>@L["状態"]</th><th></th></tr>
+                <tr><th>@L["コード"]</th><th>@L["名称"]</th><th>@L["単位"]</th><th>@L["指示値"]</th><th>@L["許容範囲"]</th><th>@L["版数"]</th><th>@L["状態"]</th><th></th></tr>
             </thead>
             <tbody>
                 @foreach (var item in _items)
@@ -83,7 +66,6 @@
                         <td>@item.Code</td>
                         <td>@item.Name</td>
                         <td>@(item.Unit ?? "-")</td>
-                        <td>@(item.TargetProductCode ?? item.TargetProcessCode ?? "-")</td>
                         <td>@(item.TargetValue?.ToString() ?? "-")</td>
                         <td>@(item.LowerLimit?.ToString() ?? "-") 〜 @(item.UpperLimit?.ToString() ?? "-")</td>
                         <td>v@(item.Version)</td>
@@ -107,14 +89,11 @@
 
 @code {
     private List<ControlItemResponse>? _items;
-    private List<ProcessResponse> _processes = [];
 
     private int? _editingId;
     private string _code = string.Empty;
     private string _name = string.Empty;
     private string? _unit;
-    private int _productId;
-    private int _processId;
     private decimal? _target;
     private decimal? _lower;
     private decimal? _upper;
@@ -122,11 +101,7 @@
     private string? _message;
     private bool _busy;
 
-    protected override async Task OnInitializedAsync()
-    {
-        _processes = await Http.GetFromJsonAsync<List<ProcessResponse>>("api/processes") ?? [];
-        await LoadAsync();
-    }
+    protected override Task OnInitializedAsync() => LoadAsync();
 
     private async Task LoadAsync() =>
         _items = await Http.GetFromJsonAsync<List<ControlItemResponse>>("api/control-items?includeInactive=true");
@@ -137,8 +112,6 @@
         _code = item.Code;
         _name = item.Name;
         _unit = item.Unit;
-        _productId = item.TargetProductId ?? 0;
-        _processId = item.TargetProcessId ?? 0;
         _target = item.TargetValue;
         _lower = item.LowerLimit;
         _upper = item.UpperLimit;
@@ -150,8 +123,6 @@
         _code = string.Empty;
         _name = string.Empty;
         _unit = null;
-        _productId = 0;
-        _processId = 0;
         _target = null;
         _lower = null;
         _upper = null;
@@ -169,10 +140,7 @@
         _message = null;
         try
         {
-            var request = new ControlItemRequest(_code, _name, _unit,
-                _productId == 0 ? null : _productId,
-                _processId == 0 ? null : _processId,
-                _target, _lower, _upper);
+            var request = new ControlItemRequest(_code, _name, _unit, _target, _lower, _upper);
             var response = _editingId is null
                 ? await Http.PostAsJsonAsync("api/control-items", request)
                 : await Http.PutAsJsonAsync($"api/control-items/{_editingId}", request);
diff --git a/src/MesApp.Client.Web/Pages/Masters/Products/ProductRoutingEditor.razor b/src/MesApp.Client.Web/Pages/Masters/Products/ProductRoutingEditor.razor
index 0294b30..aa9818b 100644
--- a/src/MesApp.Client.Web/Pages/Masters/Products/ProductRoutingEditor.razor
+++ b/src/MesApp.Client.Web/Pages/Masters/Products/ProductRoutingEditor.razor
@@ -6,7 +6,7 @@
     <Notice Error="@_error" Message="@_message" />
     <table class="table">
         <thead>
-            <tr><th>@L["順序"]</th><th>@L["工程"]</th><th>@L["標準作業(分)"]</th><th>@L["標準段取(分)"]</th><th>@L["必要スキル"]</th><th>@L["候補設備"]</th><th>@L["治工具"]</th><th>@L["チェックリスト"]</th><th>@L["管理項目"]</th><th>@L["作業手順書"]</th><th></th></tr>
+            <tr><th>@L["順序"]</th><th>@L["工程"]</th><th>@L["標準作業(分)"]</th><th>@L["標準段取(分)"]</th><th>@L["必要スキル"]</th><th>@L["候補設備"]</th><th>@L["治工具"]</th><th>@L["チェックリスト"]</th><th>@L["管理項目"]</th><th>@L["補足"]</th><th>@L["作業手順書"]</th><th></th></tr>
         </thead>
         <tbody>
             @foreach (var step in _steps.OrderBy(s => s.Sequence))
@@ -17,9 +17,10 @@
                     <td>@step.StandardWorkMinutes</td>
                     <td>@step.StandardSetupMinutes</td>
                     <td>@(_skills.FirstOrDefault(s => s.Id == step.RequiredSkillId)?.Name ?? "-")</td>
-                    <td>@CandidateLabel(step)</td>
+                    <td>@ShortList(step.EquipmentIds ?? (step.EquipmentId is { } single ? [single] : []), id => _equipments.FirstOrDefault(e => e.Id == id)?.AssetNo)</td>
                     <td>@(_tools.FirstOrDefault(t => t.Id == step.ToolId)?.Code ?? "-")</td>
                     <td>@(_checklists.FirstOrDefault(c => c.Id == step.ChecklistId)?.Code ?? "-")</td>
+                    <td>@ShortList(step.ControlItemIds ?? [], id => _controlItemOptions.FirstOrDefault(i => i.Id == id)?.Code)</td>
                     <td>@(step.ControlItems ?? "-")</td>
                     <td>@(_workProcedures.FirstOrDefault(w => w.Id == step.WorkProcedureId)?.ProcedureNo ?? "-")</td>
                     <td><button class="btn btn-danger btn-sm" @onclick="() => _steps.Remove(step)">@L["削除"]</button></td>
@@ -64,7 +65,7 @@
             <div class="form-field">
                 @* 候補設備（B-10-20-02）。複数選ぶと差立でその中から選ばせる。空なら限定しない *@
                 <label>@L["候補設備（Ctrl/Shiftで複数選択）"]</label>
-                <select multiple size="4" @onchange="OnCandidatesChanged">
+                <select multiple size="4" @key="_formVersion" @onchange="OnCandidatesChanged">
                     @foreach (var equipment in _equipments)
                     {
                         <option value="@equipment.Id" selected="@_equipmentIds.Contains(equipment.Id)">
@@ -104,8 +105,20 @@
                 </select>
             </div>
             <div class="form-field">
-                <label>@L["工程管理項目"]</label>
-                <input @bind="_controlItems" placeholder="@L["例：温度、回転数"]" />
+                @* 工程管理項目の紐付け（I-30-20-10）。展開時にこの工程の作業指示へ指示値・許容範囲を写す *@
+                <label>@L["工程管理項目（Ctrl/Shiftで複数選択）"]</label>
+                <select multiple size="4" @key="_formVersion" @onchange="OnControlItemsChanged">
+                    @foreach (var item in _controlItemOptions)
+                    {
+                        <option value="@item.Id" selected="@_controlItemIds.Contains(item.Id)">
+                            @item.Code @item.Name
+                        </option>
+                    }
+                </select>
+            </div>
+            <div class="form-field">
+                <label>@L["工程管理項目の補足"]</label>
+                <input @bind="_controlItems" placeholder="@L["指示値の無い確認事項など"]" />
             </div>
             <div class="form-field">
                 @* 作業手順書の紐付け（I-30-20-12）。作業者は作業指示からこれを辿る *@
@@ -139,6 +152,8 @@
     private List<ToolResponse> _tools = [];
     private List<ChecklistResponse> _checklists = [];
     private List<WorkProcedureResponse> _workProcedures = [];
+    /// <summary>紐付けられる工程管理項目（有効なものだけ）</summary>
+    private List<ControlItemResponse> _controlItemOptions = [];
     /// <summary>工順の作業区は最下段のみ（Spec.md 5.7 資源階層への紐付け）</summary>
     private List<WorkCenterResponse> _workCenters = [];
 
@@ -157,6 +172,12 @@
     private int _workProcedureId;
     private int _workCenterId;
     private string? _controlItems;
+    private readonly List<int> _controlItemIds = [];
+    /// <summary>
+    /// 工程を追加するたびに上げ、複数選択の一覧を作り直す。
+    /// 利用者が選んだ選択状態は selected 属性を外しても画面に残るため、選択を空にしても表示だけが前の工程のままになる
+    /// </summary>
+    private int _formVersion;
 
     private string? _error;
     private string? _message;
@@ -170,6 +191,7 @@
         _tools = await Http.GetFromJsonAsync<List<ToolResponse>>("api/tools") ?? [];
         _checklists = await Http.GetFromJsonAsync<List<ChecklistResponse>>("api/checklists") ?? [];
         _workProcedures = await Http.GetFromJsonAsync<List<WorkProcedureResponse>>("api/work-procedures") ?? [];
+        _controlItemOptions = await Http.GetFromJsonAsync<List<ControlItemResponse>>("api/control-items") ?? [];
         _workCenters = await Http.GetFromJsonAsync<List<WorkCenterResponse>>(
             $"api/work-centers?level={WorkCenterLevel.WorkCenter}") ?? [];
     }
@@ -192,7 +214,7 @@
         _steps.AddRange(routing.Select(r => new RoutingStepRequest(
             r.Sequence, r.ProcessId, r.StandardWorkMinutes, r.StandardSetupMinutes,
             r.RequiredSkillId, r.EquipmentId, r.ToolId, r.ControlItems, r.ChecklistId,
-            r.WorkCenterId, r.EquipmentIds, r.WorkProcedureId)));
+            r.WorkCenterId, r.EquipmentIds, r.WorkProcedureId, r.ControlItemIds)));
         _sequence = _steps.Count == 0 ? 1 : _steps.Max(s => s.Sequence) + 1;
         // 親から呼ばれたときはパラメータが変わらないため、自分で再描画を要求する
         StateHasChanged();
@@ -219,37 +241,44 @@
             _checklistId == 0 ? null : _checklistId,
             _workCenterId == 0 ? null : _workCenterId,
             _equipmentIds.Count == 0 ? null : [.. _equipmentIds],
-            _workProcedureId == 0 ? null : _workProcedureId));
+            _workProcedureId == 0 ? null : _workProcedureId,
+            _controlItemIds.Count == 0 ? null : [.. _controlItemIds]));
         _sequence = _steps.Max(s => s.Sequence) + 1;
         _controlItems = null;
         _equipmentIds.Clear();
+        _controlItemIds.Clear();
+        _formVersion++;
     }
 
     /// <summary>複数選択の設備一覧から候補を取り込む</summary>
-    private void OnCandidatesChanged(ChangeEventArgs e)
+    private void OnCandidatesChanged(ChangeEventArgs e) => ReadSelected(e, _equipmentIds);
+
+    /// <summary>複数選択の工程管理項目一覧から紐付けを取り込む</summary>
+    private void OnControlItemsChanged(ChangeEventArgs e) => ReadSelected(e, _controlItemIds);
+
+    private static void ReadSelected(ChangeEventArgs e, List<int> target)
     {
-        _equipmentIds.Clear();
+        target.Clear();
         foreach (var value in (string[])(e.Value ?? Array.Empty<string>()))
         {
             if (int.TryParse(value, out var id))
             {
-                _equipmentIds.Add(id);
+                target.Add(id);
             }
         }
     }
 
-    /// <summary>一覧に出す候補設備の表示（多いときは件数で省略する）</summary>
-    private string CandidateLabel(RoutingStepRequest step)
+    /// <summary>一覧に出す候補設備・工程管理項目の表示（多いときは件数で省略する）</summary>
+    private string ShortList(IEnumerable<int> ids, Func<int, string?> codeOf)
     {
-        var ids = step.EquipmentIds ?? (step.EquipmentId is { } single ? [single] : []);
-        if (ids.Count == 0)
-        {
-            return "-";
-        }
         var codes = ids
-            .Select(id => _equipments.FirstOrDefault(e => e.Id == id)?.AssetNo)
+            .Select(codeOf)
             .Where(code => code is not null)
             .ToList();
+        if (codes.Count == 0)
+        {
+            return "-";
+        }
         return codes.Count <= 3 ? string.Join(L["、"], codes) : L["{0} ほか{1}件", string.Join(L["、"], codes.Take(3)), codes.Count - 3];
     }
 
diff --git a/src/MesApp.Client.Web/Shared/UiText.en.resx b/src/MesApp.Client.Web/Shared/UiText.en.resx
index 54ce73d..cea695f 100644
--- a/src/MesApp.Client.Web/Shared/UiText.en.resx
+++ b/src/MesApp.Client.Web/Shared/UiText.en.resx
@@ -1005,9 +1005,6 @@
   <data name="使用治工具" xml:space="preserve">
     <value>Tools used</value>
   </data>
-  <data name="例：温度、回転数" xml:space="preserve">
-    <value>e.g. temperature, speed</value>
-  </data>
   <data name="作業手順書（SOP）" xml:space="preserve">
     <value>Work procedure (SOP)</value>
   </data>
@@ -4167,4 +4164,19 @@
   <data name="{0}（工順に無し）" xml:space="preserve">
     <value>{0} (not in routing)</value>
   </data>
+  <data name="どの工程で記録するかは品目タブの工順で紐付けます。品目ごとに指示値が違う条件は、品目ごとに別の項目として登録してください。" xml:space="preserve">
+    <value>Link items to process steps in the routing on the Items tab. If the target value differs by item, register a separate control item for each item.</value>
+  </data>
+  <data name="補足" xml:space="preserve">
+    <value>Notes</value>
+  </data>
+  <data name="工程管理項目（Ctrl/Shiftで複数選択）" xml:space="preserve">
+    <value>Control items (Ctrl/Shift to select multiple)</value>
+  </data>
+  <data name="工程管理項目の補足" xml:space="preserve">
+    <value>Control item notes</value>
+  </data>
+  <data name="指示値の無い確認事項など" xml:space="preserve">
+    <value>Checks without target values, etc.</value>
+  </data>
 </root>
diff --git a/src/MesApp.Core/Contracts/Masters/MasterContracts.cs b/src/MesApp.Core/Contracts/Masters/MasterContracts.cs
index 5cb58bc..a8d0ab2 100644
--- a/src/MesApp.Core/Contracts/Masters/MasterContracts.cs
+++ b/src/MesApp.Core/Contracts/Masters/MasterContracts.cs
@@ -57,13 +57,15 @@ public record RoutingStepRequest(
     int? RequiredSkillId,
     int? EquipmentId,
     int? ToolId,
-    string? ControlItems,
+    [MaxLength(1000)] string? ControlItems,
     int? ChecklistId,
     int? WorkCenterId = null,
     /// <summary>候補設備（B-10-20-02）。空なら差立で設備を限定しない</summary>
     List<int>? EquipmentIds = null,
     /// <summary>作業手順書（SOP。I-30-20-12）</summary>
-    int? WorkProcedureId = null);
+    int? WorkProcedureId = null,
+    /// <summary>この工程で記録する工程管理項目（I-30-20-10）。有効な項目だけを指定できる</summary>
+    List<int>? ControlItemIds = null);
 
 public record RoutingStepResponse(
     int Id, int Sequence, int ProcessId, string ProcessCode, string ProcessName,
@@ -74,7 +76,10 @@ public record RoutingStepResponse(
     /// <summary>候補設備の資産番号（表示用）</summary>
     List<string>? EquipmentAssetNos = null,
     List<int>? EquipmentIds = null,
-    int? WorkProcedureId = null, string? WorkProcedureNo = null, string? WorkProcedureTitle = null);
+    int? WorkProcedureId = null, string? WorkProcedureNo = null, string? WorkProcedureTitle = null,
+    /// <summary>この工程で記録する工程管理項目（コード順）</summary>
+    List<int>? ControlItemIds = null,
+    List<string>? ControlItemCodes = null);
 
 // ---- 作業手順書（SOP。I-30-40、B-10-30-03）----
 
@@ -212,16 +217,12 @@ public record ControlItemRequest(
     [Required, MaxLength(50)] string Code,
     [Required, MaxLength(200)] string Name,
     [MaxLength(30)] string? Unit,
-    int? TargetProductId,
-    int? TargetProcessId,
     decimal? TargetValue,
     decimal? LowerLimit,
     decimal? UpperLimit);
 
 public record ControlItemResponse(
     int Id, string Code, string Name, string? Unit,
-    int? TargetProductId, string? TargetProductCode,
-    int? TargetProcessId, string? TargetProcessCode,
     decimal? TargetValue, decimal? LowerLimit, decimal? UpperLimit,
     int Version, bool IsActive);
 
diff --git a/src/MesApp.Core/Entities/Masters.cs b/src/MesApp.Core/Entities/Masters.cs
index a8ed796..85d982a 100644
--- a/src/MesApp.Core/Entities/Masters.cs
+++ b/src/MesApp.Core/Entities/Masters.cs
@@ -139,9 +139,18 @@ public class Routing
     public int? ToolId { get; set; }
     public Tool? Tool { get; set; }
 
-    /// <summary>工程管理項目（温度・回転数など記録すべき製造条件の定義）</summary>
+    /// <summary>
+    /// 工程管理項目の補足（自由記述）。指示値・許容範囲を持つ条件は <see cref="ControlItemLinks"/> で紐付ける
+    /// </summary>
     public string? ControlItems { get; set; }
 
+    /// <summary>
+    /// この工程で記録する工程管理項目（I-30-20-10「BOPに登録された作業に工程管理条件を定義する」）。
+    /// 指図展開時にこの紐付けどおり作業指示へ指示値を写す。項目側に対象品目・工程を持たせて自動で選ぶと、
+    /// 品目を指定した項目がその品目の全工程に載り、同じ工程が2回ある工順を区別できないため
+    /// </summary>
+    public List<RoutingControlItem> ControlItemLinks { get; set; } = [];
+
     /// <summary>工程・段取りで実施するチェックリスト</summary>
     public int? ChecklistId { get; set; }
     public Checklist? Checklist { get; set; }
@@ -205,6 +214,21 @@ public class RoutingEquipment
     public Equipment? Equipment { get; set; }
 }
 
+/// <summary>
+/// 工順の工程管理項目（Spec.md 5.1 RoutingControlItem。I-30-20-10、B-30-30-04）。
+/// 工順の1工程で記録する製造条件を指す。工順の一括置換で工程ごと作り直す
+/// </summary>
+public class RoutingControlItem
+{
+    public int Id { get; set; }
+
+    public int RoutingId { get; set; }
+    public Routing? Routing { get; set; }
+
+    public int ControlItemId { get; set; }
+    public ControlItem? ControlItem { get; set; }
+}
+
 /// <summary>設備台帳/BOE（Spec.md 5.1 Equipment。E-10-10、I-10-20）</summary>
 public class Equipment : IDeactivatableMaster
 {
@@ -498,6 +522,11 @@ public class InspectionItem : IDeactivatableMaster
 /// 関係は「検査パラメータと検査結果」と同じ構造であり、判定の考え方も揃うため。
 /// 違いは、検査が結果を測るのに対し、こちらは作る前に与える条件だという点。
 /// </para>
+/// <para>
+/// 対象品目・対象工程は持たない。どの工程で記録するかは工順（BOP）側から紐付ける（<see cref="RoutingControlItem"/>）。
+/// 作業手順書（<see cref="WorkProcedure"/>）と同じ理由で、両側に対象を持たせると運用が割れる。
+/// 品目ごとに指示値が違う条件は、品目ごとに別の項目として登録する
+/// </para>
 /// </summary>
 public class ControlItem : IDeactivatableMaster
 {
@@ -511,14 +540,6 @@ public class ControlItem : IDeactivatableMaster
     /// <summary>単位（℃・rpm など）</summary>
     public string? Unit { get; set; }
 
-    /// <summary>対象品目（品目単位の条件の場合）</summary>
-    public int? TargetProductId { get; set; }
-    public Product? TargetProduct { get; set; }
-
-    /// <summary>対象工程（工程単位の条件の場合）</summary>
-    public int? TargetProcessId { get; set; }
-    public ProcessMaster? TargetProcess { get; set; }
-
     /// <summary>指示値（レシピ上の狙い値。例「600W」）</summary>
     public decimal? TargetValue { get; set; }
 
diff --git a/src/MesApp.Infrastructure/Configurations/MasterConfigurations.cs b/src/MesApp.Infrastructure/Configurations/MasterConfigurations.cs
index b783e88..a4c085d 100644
--- a/src/MesApp.Infrastructure/Configurations/MasterConfigurations.cs
+++ b/src/MesApp.Infrastructure/Configurations/MasterConfigurations.cs
@@ -77,6 +77,21 @@ public void Configure(EntityTypeBuilder<RoutingEquipment> e)
     }
 }
 
+internal sealed class RoutingControlItemConfiguration : IEntityTypeConfiguration<RoutingControlItem>
+{
+    public void Configure(EntityTypeBuilder<RoutingControlItem> e)
+    {
+        // 同じ工程に同じ項目を二重に紐付けさせない（作業指示に同じ指示が2行出る）
+        e.HasIndex(x => new { x.RoutingId, x.ControlItemId }).IsUnique();
+        // 候補設備と同じく、工順を置き換えると紐付けも消える。逆側のナビゲーションを明示する
+        e.HasOne(x => x.Routing).WithMany(r => r.ControlItemLinks)
+            .HasForeignKey(x => x.RoutingId)
+            .OnDelete(DeleteBehavior.Cascade);
+        e.HasOne(x => x.ControlItem).WithMany().HasForeignKey(x => x.ControlItemId)
+            .OnDelete(DeleteBehavior.Restrict);
+    }
+}
+
 internal sealed class WorkProcedureConfiguration : IEntityTypeConfiguration<WorkProcedure>
 {
     public void Configure(EntityTypeBuilder<WorkProcedure> e)
diff --git a/src/MesApp.Infrastructure/Configurations/ProductionConfigurations.cs b/src/MesApp.Infrastructure/Configurations/ProductionConfigurations.cs
index 0b7450d..2274b96 100644
--- a/src/MesApp.Infrastructure/Configurations/ProductionConfigurations.cs
+++ b/src/MesApp.Infrastructure/Configurations/ProductionConfigurations.cs
@@ -101,7 +101,7 @@ public void Configure(EntityTypeBuilder<WorkOrder> e)
             .WithMany()
             .HasForeignKey(x => x.ProcessId)
             .OnDelete(DeleteBehavior.Restrict);
-        e.Property(x => x.ControlItems).HasMaxLength(500);
+        e.Property(x => x.ControlItems).HasMaxLength(1000);
         e.HasOne(x => x.RequiredSkill)
             .WithMany()
             .HasForeignKey(x => x.RequiredSkillId)
diff --git a/src/MesApp.Infrastructure/MesAppDbContext.cs b/src/MesApp.Infrastructure/MesAppDbContext.cs
index 049ddf8..a65823d 100644
--- a/src/MesApp.Infrastructure/MesAppDbContext.cs
+++ b/src/MesApp.Infrastructure/MesAppDbContext.cs
@@ -19,6 +19,7 @@ public class MesAppDbContext(DbContextOptions<MesAppDbContext> options)
     public DbSet<ProcessMaster> Processes => Set<ProcessMaster>();
     public DbSet<Routing> Routings => Set<Routing>();
     public DbSet<RoutingEquipment> RoutingEquipments => Set<RoutingEquipment>();
+    public DbSet<RoutingControlItem> RoutingControlItems => Set<RoutingControlItem>();
     public DbSet<Equipment> Equipments => Set<Equipment>();
     public DbSet<EquipmentPart> EquipmentParts => Set<EquipmentPart>();
     public DbSet<Tool> Tools => Set<Tool>();
diff --git a/src/MesApp.Infrastructure/Migrations/20260923080825_WidenWorkOrderControlItems.Designer.cs b/src/MesApp.Infrastructure/Migrations/20260923080825_WidenWorkOrderControlItems.Designer.cs
new file mode 100644
index 0000000..e844591
--- /dev/null
+++ b/src/MesApp.Infrastructure/Migrations/20260923080825_WidenWorkOrderControlItems.Designer.cs
@@ -0,0 +1,4753 @@
+// <auto-generated />
+using System;
+using MesApp.Infrastructure;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace MesApp.Infrastructure.Migrations
+{
+    [DbContext(typeof(MesAppDbContext))]
+    [Migration("20260923080825_WidenWorkOrderControlItems")]
+    partial class WidenWorkOrderControlItems
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.10");
+
+            modelBuilder.Entity("MesApp.Core.Entities.AppUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Department")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("MustChangePassword")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ShiftId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.HasIndex("ShiftId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.AuditLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Detail")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("IpAddress")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly>("RecordedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetId")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetType")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserName")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RecordedOn");
+
+                    b.HasIndex("Timestamp");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("Category", "Action");
+
+                    b.HasIndex("TargetType", "TargetId");
+
+                    b.ToTable("AuditLogs");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.BomItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AlternativeGroup")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ChildProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsAlternative")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MakeOrBuy")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ParentProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("RoutingSequence")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildProductId");
+
+                    b.HasIndex("ParentProductId", "ChildProductId")
+                        .IsUnique();
+
+                    b.ToTable("BomItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Checklist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Checklists");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsRequired")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.ToTable("ChecklistItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("PerformedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ChecklistRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistResultItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChecklistItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChecklistRecordId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsChecked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistItemId");
+
+                    b.HasIndex("ChecklistRecordId");
+
+                    b.ToTable("ChecklistResultItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TargetProcessId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("TargetProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("TargetValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Unit")
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("TargetProcessId");
+
+                    b.HasIndex("TargetProductId");
+
+                    b.ToTable("ControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.DefectReason", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("DefectReasons");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MaintenanceParts")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("MaintenanceThreshold")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("MaintenanceType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Site")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetNo")
+                        .IsUnique();
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("Equipments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("StopCause")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("EquipmentLogs");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentPart", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("EquipmentId", "ProductId")
+                        .IsUnique();
+
+                    b.ToTable("EquipmentParts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDevice", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly?>("CalibratedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("CalibrationCycleDays")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly?>("CalibrationDueOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Location")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SerialNo")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("InspectionDevices");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDeviceCalibration", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("CalibratedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("InspectionDeviceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly?>("NextDueOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("InspectionDeviceId", "CalibratedOn");
+
+                    b.ToTable("InspectionDeviceCalibrations");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Method")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SamplingCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("StandardValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TargetProcessId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("TargetProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("TargetProcessId");
+
+                    b.HasIndex("TargetProductId");
+
+                    b.ToTable("InspectionItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("JudgedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("JudgedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OverallJudgment")
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RequestedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TargetLotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("TargetWorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedByUserId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("TargetLotId");
+
+                    b.HasIndex("TargetWorkOrderId");
+
+                    b.ToTable("InspectionOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrderItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("InspectionItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ItemCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ItemVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Method")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SamplingCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("StandardValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionItemId");
+
+                    b.HasIndex("InspectionOrderId", "InspectionItemId")
+                        .IsUnique();
+
+                    b.ToTable("InspectionOrderItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResult", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CorrectionNote")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("InspectedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("InspectedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("InspectionDeviceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("InspectionItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Judgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("MeasuredValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SampleNo")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("TextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectedByUserId");
+
+                    b.HasIndex("InspectionDeviceId");
+
+                    b.HasIndex("InspectionItemId");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.ToTable("InspectionResults");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResultCorrection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AfterJudgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("AfterMeasuredValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AfterTextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("BeforeJudgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("BeforeMeasuredValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("BeforeTextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CorrectedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CorrectedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("InspectionResultId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrectedByUserId");
+
+                    b.HasIndex("InspectionResultId");
+
+                    b.HasIndex("InspectionOrderId", "Id");
+
+                    b.ToTable("InspectionResultCorrections");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryStock", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId", "LocationId")
+                        .IsUnique();
+
+                    b.HasIndex("ProductId", "LocationId");
+
+                    b.ToTable("InventoryStocks");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryTransaction", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("FromLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("PickingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ToLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FromLocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("Timestamp");
+
+                    b.HasIndex("ToLocationId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("InventoryTransactions");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Location", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AreaType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ShelfNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Lot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("ExpiresOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Grade")
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("InitialQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LotNumber")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("ManufacturedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OriginType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ParentLotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SourceWorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("StockStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LotNumber")
+                        .IsUnique();
+
+                    b.HasIndex("ParentLotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SourceWorkOrderId");
+
+                    b.ToTable("Lots");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotGenealogy", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChildLotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ParentLotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RelationType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildLotId");
+
+                    b.HasIndex("ParentLotId");
+
+                    b.ToTable("LotGenealogies");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotStatusHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("ChangedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ChangedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FromStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("NonconformanceReportId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ToStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LotId", "Id");
+
+                    b.ToTable("LotStatusHistories");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MaintenancePlanId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ProcedureId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("ScheduledDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ToolId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedByUserId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("MaintenancePlanId");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("ProcedureId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("ToolId");
+
+                    b.ToTable("MaintenanceOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenancePlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("CycleDays")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlanYear")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly?>("ScheduledDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId", "PlanYear");
+
+                    b.ToTable("MaintenancePlans");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceProcedure", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ProcedureNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Steps")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TargetEquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("TargetToolId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcedureNo")
+                        .IsUnique();
+
+                    b.HasIndex("TargetEquipmentId");
+
+                    b.HasIndex("TargetToolId");
+
+                    b.ToTable("MaintenanceProcedures");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MaintenanceOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PartsUsed")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MaintenanceOrderId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.ToTable("MaintenanceRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecordPart", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MaintenanceRecordId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("MaintenanceRecordId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("MaintenanceRecordParts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OrderType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OutputLotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SourceOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputLotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SourceOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("ManufacturingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrderMaterial", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AlternativeGroup")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ChildProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsAlternative")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ManufacturingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("RoutingSequence")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildProductId");
+
+                    b.HasIndex("ManufacturingOrderId", "ChildProductId")
+                        .IsUnique();
+
+                    b.ToTable("ManufacturingOrderMaterials");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaterialConsumption", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("ConsumedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsSubstitute")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Method")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SubstituteReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("MaterialConsumptions");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NonconformanceReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Action")
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ActionCompletedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ActionCompletedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ActionInstructedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ActionInstructedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ActionInstruction")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ActionRecord")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CauseCategory")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CauseDetail")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ReportNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ReportedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ReworkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ReportNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReportedByUserId");
+
+                    b.HasIndex("ReworkOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("NonconformanceReports");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LastValue")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Prefix")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Prefix")
+                        .IsUnique();
+
+                    b.ToTable("NumberSequences");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PickingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("PickingOrderId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("PickingLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ExecutedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExecutedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("PickingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProcessMaster", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Processes", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Product", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DefaultLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Specification")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("StandardDefectRate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Unit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("DefaultLocationId");
+
+                    b.ToTable("Products");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDataRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsDeviation")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Item")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("NumericValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderControlItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderControlItemId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ProductionDataRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDefect", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("DefectReasonId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProductionRecordId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DefectReasonId");
+
+                    b.HasIndex("ProductionRecordId");
+
+                    b.ToTable("ProductionDefects");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionPlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("BusinessDate", "ProductId", "ProcessId", "WorkCenterId")
+                        .IsUnique();
+
+                    b.ToTable("ProductionPlans");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("DefectQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("GoodQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OutputLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("OutputLotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("ReworkQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("ScrapQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ShiftId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OutputLotId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("ShiftId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ProductionRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecordCorrection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("AfterDefectQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("AfterGoodQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("AfterReworkQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("AfterScrapQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("BeforeDefectQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("BeforeGoodQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("BeforeReworkQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("BeforeScrapQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CorrectedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CorrectedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProductionRecordId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrectedByUserId");
+
+                    b.HasIndex("ProductionRecordId");
+
+                    b.HasIndex("WorkOrderId", "Id");
+
+                    b.ToTable("ProductionRecordCorrections");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RefreshToken", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("RevokedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TokenHash")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ChecklistId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ControlItems")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("RequiredSkillId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("StandardSetupMinutes")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("StandardWorkMinutes")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ToolId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("WorkProcedureId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("RequiredSkillId");
+
+                    b.HasIndex("ToolId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("WorkProcedureId");
+
+                    b.HasIndex("ProductId", "Sequence")
+                        .IsUnique();
+
+                    b.ToTable("Routings");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("RoutingId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("RoutingId", "EquipmentId")
+                        .IsUnique();
+
+                    b.ToTable("RoutingEquipments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SampleStorage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClosedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("ClosedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CollectedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly>("CollectedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("RetainUntil")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SampleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("StorageLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SampleNo")
+                        .IsUnique();
+
+                    b.HasIndex("StorageLocationId");
+
+                    b.HasIndex("Status", "RetainUntil");
+
+                    b.ToTable("SampleStorages");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SetupRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AbnormalityNote")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("SetupRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Shift", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Shifts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShipmentJudgment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("JudgedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("JudgedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("JudgmentNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Result")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JudgedByUserId");
+
+                    b.HasIndex("JudgmentNo")
+                        .IsUnique();
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.ToTable("ShipmentJudgments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("ShippedQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ShippingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.ToTable("ShippingLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Destination")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("PlannedDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ShippedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ShippedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ShippingNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ShippingNo")
+                        .IsUnique();
+
+                    b.ToTable("ShippingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SkillMaster", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("RequiresExpiry")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Skills", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("FinalizedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FinalizedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("StocktakeNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TargetLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StocktakeNo")
+                        .IsUnique();
+
+                    b.HasIndex("TargetLocationId");
+
+                    b.ToTable("Stocktakes");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.StocktakeLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("CountedQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsAdjusted")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("StocktakeId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("TheoreticalQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("StocktakeId");
+
+                    b.ToTable("StocktakeLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Tool", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LifeResetAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("LifeThresholdCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("LifeThresholdHours")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ToolType")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Tools");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolIssue", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("AllocatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AllocatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("IssuedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("IssuedToUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ReturnedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ReturnedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ToolId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IssuedToUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.HasIndex("ToolId", "Status");
+
+                    b.ToTable("ToolIssues");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolUsage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ToolId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("UsageCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("UsageHours")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ToolId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ToolUsages");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TransferOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ExecutedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExecutedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("FromLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ToLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FromLocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("ToLocationId");
+
+                    b.ToTable("TransferOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TroubleReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ReportedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ResponseHistory")
+                        .HasMaxLength(4000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("ReportedByUserId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("TroubleReports");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.UserSkill", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly?>("AcquiredOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("ExpiresOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SkillId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SkillId");
+
+                    b.HasIndex("UserId", "SkillId")
+                        .IsUnique();
+
+                    b.ToTable("UserSkills");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkCenter", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Level")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ParentId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("WorkCenters");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("AssignedEquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AssignedUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ControlItems")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DispatchOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ManufacturingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("RequiredSkillId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("RoutingChecklistId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("RoutingSequence")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("StandardSetupMinutes")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("StandardWorkMinutes")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("WorkOrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkProcedureId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("WorkProcedureVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignedEquipmentId");
+
+                    b.HasIndex("AssignedUserId");
+
+                    b.HasIndex("ManufacturingOrderId");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("RequiredSkillId");
+
+                    b.HasIndex("RoutingChecklistId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("WorkOrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("WorkProcedureId");
+
+                    b.ToTable("WorkOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ControlItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ItemCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ItemVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("TargetValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Unit")
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ControlItemId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("WorkOrderControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderStatusHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("ChangedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ChangedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FromStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ToStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChangedByUserId");
+
+                    b.HasIndex("WorkOrderId", "Id");
+
+                    b.ToTable("WorkOrderStatusHistories");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkProcedure", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ProcedureNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Steps")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcedureNo")
+                        .IsUnique();
+
+                    b.ToTable("WorkProcedures");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkTimeRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("IndirectCategory")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.HasIndex("UserId", "StartedAt");
+
+                    b.ToTable("WorkTimeRecords");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.AppUser", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Shift", "Shift")
+                        .WithMany()
+                        .HasForeignKey("ShiftId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Shift");
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.BomItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "ChildProduct")
+                        .WithMany()
+                        .HasForeignKey("ChildProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "ParentProduct")
+                        .WithMany()
+                        .HasForeignKey("ParentProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildProduct");
+
+                    b.Navigation("ParentProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", null)
+                        .WithMany("Items")
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", "Checklist")
+                        .WithMany()
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Checklist");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistResultItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ChecklistItem", "ChecklistItem")
+                        .WithMany()
+                        .HasForeignKey("ChecklistItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ChecklistRecord", null)
+                        .WithMany("Results")
+                        .HasForeignKey("ChecklistRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChecklistItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "TargetProcess")
+                        .WithMany()
+                        .HasForeignKey("TargetProcessId");
+
+                    b.HasOne("MesApp.Core.Entities.Product", "TargetProduct")
+                        .WithMany()
+                        .HasForeignKey("TargetProductId");
+
+                    b.Navigation("TargetProcess");
+
+                    b.Navigation("TargetProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentLog", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentPart", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany("Parts")
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDeviceCalibration", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionDevice", "InspectionDevice")
+                        .WithMany()
+                        .HasForeignKey("InspectionDeviceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("InspectionDevice");
+
+                    b.Navigation("PerformedBy");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "TargetProcess")
+                        .WithMany()
+                        .HasForeignKey("TargetProcessId");
+
+                    b.HasOne("MesApp.Core.Entities.Product", "TargetProduct")
+                        .WithMany()
+                        .HasForeignKey("TargetProductId");
+
+                    b.Navigation("TargetProcess");
+
+                    b.Navigation("TargetProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "RequestedBy")
+                        .WithMany()
+                        .HasForeignKey("RequestedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "TargetLot")
+                        .WithMany()
+                        .HasForeignKey("TargetLotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "TargetWorkOrder")
+                        .WithMany()
+                        .HasForeignKey("TargetWorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("RequestedBy");
+
+                    b.Navigation("TargetLot");
+
+                    b.Navigation("TargetWorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrderItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionItem", "InspectionItem")
+                        .WithMany()
+                        .HasForeignKey("InspectionItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", null)
+                        .WithMany("Items")
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResult", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "InspectedBy")
+                        .WithMany()
+                        .HasForeignKey("InspectedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionDevice", "InspectionDevice")
+                        .WithMany()
+                        .HasForeignKey("InspectionDeviceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.InspectionItem", "InspectionItem")
+                        .WithMany()
+                        .HasForeignKey("InspectionItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", null)
+                        .WithMany("Results")
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectedBy");
+
+                    b.Navigation("InspectionDevice");
+
+                    b.Navigation("InspectionItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResultCorrection", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CorrectedBy")
+                        .WithMany()
+                        .HasForeignKey("CorrectedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.InspectionResult", "InspectionResult")
+                        .WithMany()
+                        .HasForeignKey("InspectionResultId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CorrectedBy");
+
+                    b.Navigation("InspectionResult");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryStock", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryTransaction", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "FromLocation")
+                        .WithMany()
+                        .HasForeignKey("FromLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "ToLocation")
+                        .WithMany()
+                        .HasForeignKey("ToLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("FromLocation");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("ToLocation");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Location", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Lot", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "ParentLot")
+                        .WithMany()
+                        .HasForeignKey("ParentLotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "SourceWorkOrder")
+                        .WithMany()
+                        .HasForeignKey("SourceWorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("ParentLot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("SourceWorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotGenealogy", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "ChildLot")
+                        .WithMany()
+                        .HasForeignKey("ChildLotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "ParentLot")
+                        .WithMany()
+                        .HasForeignKey("ParentLotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ChildLot");
+
+                    b.Navigation("ParentLot");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotStatusHistory", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Lot");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.MaintenancePlan", "MaintenancePlan")
+                        .WithMany()
+                        .HasForeignKey("MaintenancePlanId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.MaintenanceProcedure", "Procedure")
+                        .WithMany()
+                        .HasForeignKey("ProcedureId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("MaintenancePlan");
+
+                    b.Navigation("Procedure");
+
+                    b.Navigation("Tool");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenancePlan", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceProcedure", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "TargetEquipment")
+                        .WithMany()
+                        .HasForeignKey("TargetEquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "TargetTool")
+                        .WithMany()
+                        .HasForeignKey("TargetToolId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("TargetEquipment");
+
+                    b.Navigation("TargetTool");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.MaintenanceOrder", null)
+                        .WithMany("Records")
+                        .HasForeignKey("MaintenanceOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("PerformedBy");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecordPart", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.MaintenanceRecord", null)
+                        .WithMany("Parts")
+                        .HasForeignKey("MaintenanceRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "OutputLot")
+                        .WithMany()
+                        .HasForeignKey("OutputLotId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "SourceOrder")
+                        .WithMany()
+                        .HasForeignKey("SourceOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("OutputLot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("SourceOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrderMaterial", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "ChildProduct")
+                        .WithMany()
+                        .HasForeignKey("ChildProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ManufacturingOrder")
+                        .WithMany("Materials")
+                        .HasForeignKey("ManufacturingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildProduct");
+
+                    b.Navigation("ManufacturingOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaterialConsumption", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NonconformanceReport", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", "InspectionOrder")
+                        .WithMany()
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ReportedBy")
+                        .WithMany()
+                        .HasForeignKey("ReportedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ReworkOrder")
+                        .WithMany()
+                        .HasForeignKey("ReworkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("InspectionOrder");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ReportedBy");
+
+                    b.Navigation("ReworkOrder");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.PickingOrder", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("PickingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", "ShippingOrder")
+                        .WithMany()
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("ShippingOrder");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Product", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "DefaultLocation")
+                        .WithMany()
+                        .HasForeignKey("DefaultLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDataRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkOrderControlItem", "WorkOrderControlItem")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WorkOrder");
+
+                    b.Navigation("WorkOrderControlItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDefect", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.DefectReason", "DefectReason")
+                        .WithMany()
+                        .HasForeignKey("DefectReasonId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ProductionRecord", "ProductionRecord")
+                        .WithMany("Defects")
+                        .HasForeignKey("ProductionRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DefectReason");
+
+                    b.Navigation("ProductionRecord");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionPlan", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "OutputLot")
+                        .WithMany()
+                        .HasForeignKey("OutputLotId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Shift", "Shift")
+                        .WithMany()
+                        .HasForeignKey("ShiftId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OutputLot");
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("Shift");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecordCorrection", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CorrectedBy")
+                        .WithMany()
+                        .HasForeignKey("CorrectedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.ProductionRecord", "ProductionRecord")
+                        .WithMany()
+                        .HasForeignKey("ProductionRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CorrectedBy");
+
+                    b.Navigation("ProductionRecord");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RefreshToken", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", "Checklist")
+                        .WithMany()
+                        .HasForeignKey("ChecklistId");
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId");
+
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "RequiredSkill")
+                        .WithMany()
+                        .HasForeignKey("RequiredSkillId");
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId");
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkProcedure", "WorkProcedure")
+                        .WithMany()
+                        .HasForeignKey("WorkProcedureId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Checklist");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("RequiredSkill");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkCenter");
+
+                    b.Navigation("WorkProcedure");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Routing", "Routing")
+                        .WithMany("EquipmentCandidates")
+                        .HasForeignKey("RoutingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Routing");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SampleStorage", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", "InspectionOrder")
+                        .WithMany()
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "StorageLocation")
+                        .WithMany()
+                        .HasForeignKey("StorageLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("InspectionOrder");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("StorageLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SetupRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShipmentJudgment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "JudgedBy")
+                        .WithMany()
+                        .HasForeignKey("JudgedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", "ShippingOrder")
+                        .WithMany()
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("JudgedBy");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ShippingOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "TargetLocation")
+                        .WithMany()
+                        .HasForeignKey("TargetLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("TargetLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.StocktakeLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Stocktake", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("StocktakeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolIssue", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "IssuedTo")
+                        .WithMany()
+                        .HasForeignKey("IssuedToUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("IssuedTo");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolUsage", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TransferOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "FromLocation")
+                        .WithMany()
+                        .HasForeignKey("FromLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "ToLocation")
+                        .WithMany()
+                        .HasForeignKey("ToLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("FromLocation");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ToLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TroubleReport", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ReportedBy")
+                        .WithMany()
+                        .HasForeignKey("ReportedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("ReportedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.UserSkill", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "Skill")
+                        .WithMany()
+                        .HasForeignKey("SkillId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Skill");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkCenter", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "Parent")
+                        .WithMany()
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "AssignedEquipment")
+                        .WithMany()
+                        .HasForeignKey("AssignedEquipmentId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "AssignedUser")
+                        .WithMany()
+                        .HasForeignKey("AssignedUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ManufacturingOrder")
+                        .WithMany("WorkOrders")
+                        .HasForeignKey("ManufacturingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "RequiredSkill")
+                        .WithMany()
+                        .HasForeignKey("RequiredSkillId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Checklist", "RoutingChecklist")
+                        .WithMany()
+                        .HasForeignKey("RoutingChecklistId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkProcedure", "WorkProcedure")
+                        .WithMany()
+                        .HasForeignKey("WorkProcedureId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("AssignedEquipment");
+
+                    b.Navigation("AssignedUser");
+
+                    b.Navigation("ManufacturingOrder");
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("RequiredSkill");
+
+                    b.Navigation("RoutingChecklist");
+
+                    b.Navigation("WorkCenter");
+
+                    b.Navigation("WorkProcedure");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ControlItem", "ControlItem")
+                        .WithMany()
+                        .HasForeignKey("ControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany("ControlItemSnapshots")
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ControlItem");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderStatusHistory", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ChangedBy")
+                        .WithMany()
+                        .HasForeignKey("ChangedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChangedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkTimeRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Checklist", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.Navigation("Results");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.Navigation("Parts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("Results");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.Navigation("Records");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.Navigation("Parts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.Navigation("Materials");
+
+                    b.Navigation("WorkOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.Navigation("Defects");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.Navigation("EquipmentCandidates");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.Navigation("ControlItemSnapshots");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/MesApp.Infrastructure/Migrations/20260923080825_WidenWorkOrderControlItems.cs b/src/MesApp.Infrastructure/Migrations/20260923080825_WidenWorkOrderControlItems.cs
new file mode 100644
index 0000000..2cf6257
--- /dev/null
+++ b/src/MesApp.Infrastructure/Migrations/20260923080825_WidenWorkOrderControlItems.cs
@@ -0,0 +1,22 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MesApp.Infrastructure.Migrations
+{
+    /// <inheritdoc />
+    public partial class WidenWorkOrderControlItems : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}
diff --git a/src/MesApp.Infrastructure/Migrations/20260923081738_LinkControlItemsToRouting.Designer.cs b/src/MesApp.Infrastructure/Migrations/20260923081738_LinkControlItemsToRouting.Designer.cs
new file mode 100644
index 0000000..28cc2f9
--- /dev/null
+++ b/src/MesApp.Infrastructure/Migrations/20260923081738_LinkControlItemsToRouting.Designer.cs
@@ -0,0 +1,4771 @@
+// <auto-generated />
+using System;
+using MesApp.Infrastructure;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace MesApp.Infrastructure.Migrations
+{
+    [DbContext(typeof(MesAppDbContext))]
+    [Migration("20260923081738_LinkControlItemsToRouting")]
+    partial class LinkControlItemsToRouting
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.10");
+
+            modelBuilder.Entity("MesApp.Core.Entities.AppUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Department")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("MustChangePassword")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ShiftId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.HasIndex("ShiftId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.AuditLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Detail")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("IpAddress")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly>("RecordedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetId")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TargetType")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserName")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RecordedOn");
+
+                    b.HasIndex("Timestamp");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("Category", "Action");
+
+                    b.HasIndex("TargetType", "TargetId");
+
+                    b.ToTable("AuditLogs");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.BomItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AlternativeGroup")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ChildProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsAlternative")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MakeOrBuy")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ParentProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("RoutingSequence")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildProductId");
+
+                    b.HasIndex("ParentProductId", "ChildProductId")
+                        .IsUnique();
+
+                    b.ToTable("BomItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Checklist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Checklists");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsRequired")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.ToTable("ChecklistItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("PerformedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ChecklistRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistResultItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChecklistItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChecklistRecordId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsChecked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistItemId");
+
+                    b.HasIndex("ChecklistRecordId");
+
+                    b.ToTable("ChecklistResultItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("TargetValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Unit")
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("ControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.DefectReason", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("DefectReasons");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MaintenanceParts")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("MaintenanceThreshold")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("MaintenanceType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Site")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetNo")
+                        .IsUnique();
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("Equipments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("StopCause")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("EquipmentLogs");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentPart", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("EquipmentId", "ProductId")
+                        .IsUnique();
+
+                    b.ToTable("EquipmentParts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDevice", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly?>("CalibratedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("CalibrationCycleDays")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly?>("CalibrationDueOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Location")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SerialNo")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("InspectionDevices");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDeviceCalibration", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("CalibratedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("InspectionDeviceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly?>("NextDueOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("InspectionDeviceId", "CalibratedOn");
+
+                    b.ToTable("InspectionDeviceCalibrations");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Method")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SamplingCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("StandardValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TargetProcessId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("TargetProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("TargetProcessId");
+
+                    b.HasIndex("TargetProductId");
+
+                    b.ToTable("InspectionItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("JudgedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("JudgedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OverallJudgment")
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RequestedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TargetLotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("TargetWorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedByUserId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("TargetLotId");
+
+                    b.HasIndex("TargetWorkOrderId");
+
+                    b.ToTable("InspectionOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrderItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("InspectionItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ItemCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ItemVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Method")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SamplingCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("StandardValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionItemId");
+
+                    b.HasIndex("InspectionOrderId", "InspectionItemId")
+                        .IsUnique();
+
+                    b.ToTable("InspectionOrderItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResult", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CorrectionNote")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("InspectedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("InspectedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("InspectionDeviceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("InspectionItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Judgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("MeasuredValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SampleNo")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("TextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectedByUserId");
+
+                    b.HasIndex("InspectionDeviceId");
+
+                    b.HasIndex("InspectionItemId");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.ToTable("InspectionResults");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResultCorrection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AfterJudgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("AfterMeasuredValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AfterTextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("BeforeJudgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("BeforeMeasuredValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("BeforeTextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CorrectedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CorrectedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("InspectionResultId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrectedByUserId");
+
+                    b.HasIndex("InspectionResultId");
+
+                    b.HasIndex("InspectionOrderId", "Id");
+
+                    b.ToTable("InspectionResultCorrections");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryStock", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId", "LocationId")
+                        .IsUnique();
+
+                    b.HasIndex("ProductId", "LocationId");
+
+                    b.ToTable("InventoryStocks");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryTransaction", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("FromLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("PickingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ToLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FromLocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("Timestamp");
+
+                    b.HasIndex("ToLocationId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("InventoryTransactions");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Location", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AreaType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ShelfNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Lot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("ExpiresOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Grade")
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("InitialQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LotNumber")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("ManufacturedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OriginType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ParentLotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SourceWorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("StockStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LotNumber")
+                        .IsUnique();
+
+                    b.HasIndex("ParentLotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SourceWorkOrderId");
+
+                    b.ToTable("Lots");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotGenealogy", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChildLotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ParentLotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RelationType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildLotId");
+
+                    b.HasIndex("ParentLotId");
+
+                    b.ToTable("LotGenealogies");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotStatusHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("ChangedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ChangedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FromStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("NonconformanceReportId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ToStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LotId", "Id");
+
+                    b.ToTable("LotStatusHistories");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MaintenancePlanId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ProcedureId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("ScheduledDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ToolId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedByUserId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("MaintenancePlanId");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("ProcedureId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("ToolId");
+
+                    b.ToTable("MaintenanceOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenancePlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("CycleDays")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlanYear")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly?>("ScheduledDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId", "PlanYear");
+
+                    b.ToTable("MaintenancePlans");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceProcedure", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ProcedureNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Steps")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TargetEquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("TargetToolId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcedureNo")
+                        .IsUnique();
+
+                    b.HasIndex("TargetEquipmentId");
+
+                    b.HasIndex("TargetToolId");
+
+                    b.ToTable("MaintenanceProcedures");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MaintenanceOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PartsUsed")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MaintenanceOrderId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.ToTable("MaintenanceRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecordPart", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MaintenanceRecordId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("MaintenanceRecordId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("MaintenanceRecordParts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OrderType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OutputLotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SourceOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputLotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SourceOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("ManufacturingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrderMaterial", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AlternativeGroup")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ChildProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsAlternative")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ManufacturingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("RoutingSequence")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildProductId");
+
+                    b.HasIndex("ManufacturingOrderId", "ChildProductId")
+                        .IsUnique();
+
+                    b.ToTable("ManufacturingOrderMaterials");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaterialConsumption", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("ConsumedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsSubstitute")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Method")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SubstituteReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("MaterialConsumptions");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NonconformanceReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Action")
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ActionCompletedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ActionCompletedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ActionInstructedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ActionInstructedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ActionInstruction")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ActionRecord")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CauseCategory")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CauseDetail")
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ReportNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ReportedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ReworkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ReportNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReportedByUserId");
+
+                    b.HasIndex("ReworkOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("NonconformanceReports");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LastValue")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Prefix")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Prefix")
+                        .IsUnique();
+
+                    b.ToTable("NumberSequences");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PickingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("PickingOrderId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("PickingLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ExecutedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExecutedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("PickingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProcessMaster", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Processes", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Product", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DefaultLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Specification")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("StandardDefectRate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Unit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("DefaultLocationId");
+
+                    b.ToTable("Products");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDataRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsDeviation")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Item")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("NumericValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderControlItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderControlItemId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ProductionDataRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDefect", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("DefectReasonId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProductionRecordId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DefectReasonId");
+
+                    b.HasIndex("ProductionRecordId");
+
+                    b.ToTable("ProductionDefects");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionPlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("BusinessDate", "ProductId", "ProcessId", "WorkCenterId")
+                        .IsUnique();
+
+                    b.ToTable("ProductionPlans");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("DefectQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("GoodQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OutputLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("OutputLotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("ReworkQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("ScrapQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ShiftId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OutputLotId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("ShiftId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ProductionRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecordCorrection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("AfterDefectQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("AfterGoodQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("AfterReworkQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("AfterScrapQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("BeforeDefectQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("BeforeGoodQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("BeforeReworkQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("BeforeScrapQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CorrectedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CorrectedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProductionRecordId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrectedByUserId");
+
+                    b.HasIndex("ProductionRecordId");
+
+                    b.HasIndex("WorkOrderId", "Id");
+
+                    b.ToTable("ProductionRecordCorrections");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RefreshToken", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("RevokedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TokenHash")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ChecklistId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ControlItems")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("RequiredSkillId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("StandardSetupMinutes")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("StandardWorkMinutes")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ToolId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("WorkProcedureId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("RequiredSkillId");
+
+                    b.HasIndex("ToolId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("WorkProcedureId");
+
+                    b.HasIndex("ProductId", "Sequence")
+                        .IsUnique();
+
+                    b.ToTable("Routings");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ControlItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("RoutingId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ControlItemId");
+
+                    b.HasIndex("RoutingId", "ControlItemId")
+                        .IsUnique();
+
+                    b.ToTable("RoutingControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("RoutingId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("RoutingId", "EquipmentId")
+                        .IsUnique();
+
+                    b.ToTable("RoutingEquipments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SampleStorage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClosedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("ClosedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CollectedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly>("CollectedOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("RetainUntil")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SampleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("StorageLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SampleNo")
+                        .IsUnique();
+
+                    b.HasIndex("StorageLocationId");
+
+                    b.HasIndex("Status", "RetainUntil");
+
+                    b.ToTable("SampleStorages");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SetupRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AbnormalityNote")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("SetupRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Shift", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Shifts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShipmentJudgment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("JudgedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("JudgedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("JudgmentNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Result")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JudgedByUserId");
+
+                    b.HasIndex("JudgmentNo")
+                        .IsUnique();
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.ToTable("ShipmentJudgments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("ShippedQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ShippingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.ToTable("ShippingLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Destination")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("PlannedDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ShippedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ShippedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ShippingNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ShippingNo")
+                        .IsUnique();
+
+                    b.ToTable("ShippingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SkillMaster", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("RequiresExpiry")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Skills", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("FinalizedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FinalizedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("StocktakeNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TargetLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StocktakeNo")
+                        .IsUnique();
+
+                    b.HasIndex("TargetLocationId");
+
+                    b.ToTable("Stocktakes");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.StocktakeLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("CountedQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsAdjusted")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("StocktakeId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("TheoreticalQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("StocktakeId");
+
+                    b.ToTable("StocktakeLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Tool", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LifeResetAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("LifeThresholdCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("LifeThresholdHours")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ToolType")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Tools");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolIssue", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("AllocatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AllocatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("IssuedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("IssuedToUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ReturnedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ReturnedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ToolId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IssuedToUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.HasIndex("ToolId", "Status");
+
+                    b.ToTable("ToolIssues");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolUsage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ToolId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("UsageCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("UsageHours")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ToolId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ToolUsages");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TransferOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset?>("ExecutedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExecutedByUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("FromLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("Quantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ToLocationId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FromLocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("ToLocationId");
+
+                    b.ToTable("TransferOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TroubleReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ReportedByUserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ResponseHistory")
+                        .HasMaxLength(4000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("ReportedByUserId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("TroubleReports");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.UserSkill", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly?>("AcquiredOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly?>("ExpiresOn")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SkillId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SkillId");
+
+                    b.HasIndex("UserId", "SkillId")
+                        .IsUnique();
+
+                    b.ToTable("UserSkills");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkCenter", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Level")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ParentId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("WorkCenters");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("AssignedEquipmentId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AssignedUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ControlItems")
+                        .HasMaxLength(1000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DispatchOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ManufacturingOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("RequiredSkillId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("RoutingChecklistId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("RoutingSequence")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal>("StandardSetupMinutes")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("StandardWorkMinutes")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("WorkOrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkProcedureId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("WorkProcedureVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignedEquipmentId");
+
+                    b.HasIndex("AssignedUserId");
+
+                    b.HasIndex("ManufacturingOrderId");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("RequiredSkillId");
+
+                    b.HasIndex("RoutingChecklistId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("WorkOrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("WorkProcedureId");
+
+                    b.ToTable("WorkOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ControlItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ItemCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ItemVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("TargetValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Unit")
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ControlItemId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("WorkOrderControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderStatusHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("ChangedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ChangedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FromStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ToStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChangedByUserId");
+
+                    b.HasIndex("WorkOrderId", "Id");
+
+                    b.ToTable("WorkOrderStatusHistories");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkProcedure", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ProcedureNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Steps")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcedureNo")
+                        .IsUnique();
+
+                    b.ToTable("WorkProcedures");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkTimeRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("IndirectCategory")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.HasIndex("UserId", "StartedAt");
+
+                    b.ToTable("WorkTimeRecords");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.AppUser", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Shift", "Shift")
+                        .WithMany()
+                        .HasForeignKey("ShiftId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Shift");
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.BomItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "ChildProduct")
+                        .WithMany()
+                        .HasForeignKey("ChildProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "ParentProduct")
+                        .WithMany()
+                        .HasForeignKey("ParentProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildProduct");
+
+                    b.Navigation("ParentProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", null)
+                        .WithMany("Items")
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", "Checklist")
+                        .WithMany()
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Checklist");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistResultItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ChecklistItem", "ChecklistItem")
+                        .WithMany()
+                        .HasForeignKey("ChecklistItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ChecklistRecord", null)
+                        .WithMany("Results")
+                        .HasForeignKey("ChecklistRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChecklistItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentLog", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentPart", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany("Parts")
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDeviceCalibration", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionDevice", "InspectionDevice")
+                        .WithMany()
+                        .HasForeignKey("InspectionDeviceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("InspectionDevice");
+
+                    b.Navigation("PerformedBy");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "TargetProcess")
+                        .WithMany()
+                        .HasForeignKey("TargetProcessId");
+
+                    b.HasOne("MesApp.Core.Entities.Product", "TargetProduct")
+                        .WithMany()
+                        .HasForeignKey("TargetProductId");
+
+                    b.Navigation("TargetProcess");
+
+                    b.Navigation("TargetProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "RequestedBy")
+                        .WithMany()
+                        .HasForeignKey("RequestedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "TargetLot")
+                        .WithMany()
+                        .HasForeignKey("TargetLotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "TargetWorkOrder")
+                        .WithMany()
+                        .HasForeignKey("TargetWorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("RequestedBy");
+
+                    b.Navigation("TargetLot");
+
+                    b.Navigation("TargetWorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrderItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionItem", "InspectionItem")
+                        .WithMany()
+                        .HasForeignKey("InspectionItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", null)
+                        .WithMany("Items")
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResult", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "InspectedBy")
+                        .WithMany()
+                        .HasForeignKey("InspectedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionDevice", "InspectionDevice")
+                        .WithMany()
+                        .HasForeignKey("InspectionDeviceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.InspectionItem", "InspectionItem")
+                        .WithMany()
+                        .HasForeignKey("InspectionItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", null)
+                        .WithMany("Results")
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectedBy");
+
+                    b.Navigation("InspectionDevice");
+
+                    b.Navigation("InspectionItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResultCorrection", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CorrectedBy")
+                        .WithMany()
+                        .HasForeignKey("CorrectedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.InspectionResult", "InspectionResult")
+                        .WithMany()
+                        .HasForeignKey("InspectionResultId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CorrectedBy");
+
+                    b.Navigation("InspectionResult");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryStock", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryTransaction", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "FromLocation")
+                        .WithMany()
+                        .HasForeignKey("FromLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "ToLocation")
+                        .WithMany()
+                        .HasForeignKey("ToLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("FromLocation");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("ToLocation");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Location", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Lot", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "ParentLot")
+                        .WithMany()
+                        .HasForeignKey("ParentLotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "SourceWorkOrder")
+                        .WithMany()
+                        .HasForeignKey("SourceWorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("ParentLot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("SourceWorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotGenealogy", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "ChildLot")
+                        .WithMany()
+                        .HasForeignKey("ChildLotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "ParentLot")
+                        .WithMany()
+                        .HasForeignKey("ParentLotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ChildLot");
+
+                    b.Navigation("ParentLot");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotStatusHistory", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Lot");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.MaintenancePlan", "MaintenancePlan")
+                        .WithMany()
+                        .HasForeignKey("MaintenancePlanId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.MaintenanceProcedure", "Procedure")
+                        .WithMany()
+                        .HasForeignKey("ProcedureId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("MaintenancePlan");
+
+                    b.Navigation("Procedure");
+
+                    b.Navigation("Tool");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenancePlan", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceProcedure", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "TargetEquipment")
+                        .WithMany()
+                        .HasForeignKey("TargetEquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "TargetTool")
+                        .WithMany()
+                        .HasForeignKey("TargetToolId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("TargetEquipment");
+
+                    b.Navigation("TargetTool");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.MaintenanceOrder", null)
+                        .WithMany("Records")
+                        .HasForeignKey("MaintenanceOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("PerformedBy");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecordPart", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.MaintenanceRecord", null)
+                        .WithMany("Parts")
+                        .HasForeignKey("MaintenanceRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "OutputLot")
+                        .WithMany()
+                        .HasForeignKey("OutputLotId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "SourceOrder")
+                        .WithMany()
+                        .HasForeignKey("SourceOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("OutputLot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("SourceOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrderMaterial", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "ChildProduct")
+                        .WithMany()
+                        .HasForeignKey("ChildProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ManufacturingOrder")
+                        .WithMany("Materials")
+                        .HasForeignKey("ManufacturingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildProduct");
+
+                    b.Navigation("ManufacturingOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaterialConsumption", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NonconformanceReport", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", "InspectionOrder")
+                        .WithMany()
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ReportedBy")
+                        .WithMany()
+                        .HasForeignKey("ReportedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ReworkOrder")
+                        .WithMany()
+                        .HasForeignKey("ReworkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("InspectionOrder");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ReportedBy");
+
+                    b.Navigation("ReworkOrder");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.PickingOrder", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("PickingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", "ShippingOrder")
+                        .WithMany()
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("ShippingOrder");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Product", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "DefaultLocation")
+                        .WithMany()
+                        .HasForeignKey("DefaultLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDataRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkOrderControlItem", "WorkOrderControlItem")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WorkOrder");
+
+                    b.Navigation("WorkOrderControlItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDefect", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.DefectReason", "DefectReason")
+                        .WithMany()
+                        .HasForeignKey("DefectReasonId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ProductionRecord", "ProductionRecord")
+                        .WithMany("Defects")
+                        .HasForeignKey("ProductionRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DefectReason");
+
+                    b.Navigation("ProductionRecord");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionPlan", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "OutputLot")
+                        .WithMany()
+                        .HasForeignKey("OutputLotId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Shift", "Shift")
+                        .WithMany()
+                        .HasForeignKey("ShiftId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OutputLot");
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("Shift");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecordCorrection", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CorrectedBy")
+                        .WithMany()
+                        .HasForeignKey("CorrectedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.ProductionRecord", "ProductionRecord")
+                        .WithMany()
+                        .HasForeignKey("ProductionRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CorrectedBy");
+
+                    b.Navigation("ProductionRecord");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RefreshToken", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", "Checklist")
+                        .WithMany()
+                        .HasForeignKey("ChecklistId");
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId");
+
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "RequiredSkill")
+                        .WithMany()
+                        .HasForeignKey("RequiredSkillId");
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId");
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkProcedure", "WorkProcedure")
+                        .WithMany()
+                        .HasForeignKey("WorkProcedureId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Checklist");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("RequiredSkill");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkCenter");
+
+                    b.Navigation("WorkProcedure");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ControlItem", "ControlItem")
+                        .WithMany()
+                        .HasForeignKey("ControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Routing", "Routing")
+                        .WithMany("ControlItemLinks")
+                        .HasForeignKey("RoutingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ControlItem");
+
+                    b.Navigation("Routing");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Routing", "Routing")
+                        .WithMany("EquipmentCandidates")
+                        .HasForeignKey("RoutingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Routing");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SampleStorage", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", "InspectionOrder")
+                        .WithMany()
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "StorageLocation")
+                        .WithMany()
+                        .HasForeignKey("StorageLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("InspectionOrder");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("StorageLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SetupRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShipmentJudgment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "JudgedBy")
+                        .WithMany()
+                        .HasForeignKey("JudgedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", "ShippingOrder")
+                        .WithMany()
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("JudgedBy");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ShippingOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "TargetLocation")
+                        .WithMany()
+                        .HasForeignKey("TargetLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("TargetLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.StocktakeLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Stocktake", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("StocktakeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolIssue", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "IssuedTo")
+                        .WithMany()
+                        .HasForeignKey("IssuedToUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("IssuedTo");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolUsage", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TransferOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "FromLocation")
+                        .WithMany()
+                        .HasForeignKey("FromLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "ToLocation")
+                        .WithMany()
+                        .HasForeignKey("ToLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("FromLocation");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ToLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TroubleReport", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ReportedBy")
+                        .WithMany()
+                        .HasForeignKey("ReportedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("ReportedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.UserSkill", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "Skill")
+                        .WithMany()
+                        .HasForeignKey("SkillId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Skill");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkCenter", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "Parent")
+                        .WithMany()
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "AssignedEquipment")
+                        .WithMany()
+                        .HasForeignKey("AssignedEquipmentId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "AssignedUser")
+                        .WithMany()
+                        .HasForeignKey("AssignedUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ManufacturingOrder")
+                        .WithMany("WorkOrders")
+                        .HasForeignKey("ManufacturingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "RequiredSkill")
+                        .WithMany()
+                        .HasForeignKey("RequiredSkillId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Checklist", "RoutingChecklist")
+                        .WithMany()
+                        .HasForeignKey("RoutingChecklistId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkProcedure", "WorkProcedure")
+                        .WithMany()
+                        .HasForeignKey("WorkProcedureId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("AssignedEquipment");
+
+                    b.Navigation("AssignedUser");
+
+                    b.Navigation("ManufacturingOrder");
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("RequiredSkill");
+
+                    b.Navigation("RoutingChecklist");
+
+                    b.Navigation("WorkCenter");
+
+                    b.Navigation("WorkProcedure");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ControlItem", "ControlItem")
+                        .WithMany()
+                        .HasForeignKey("ControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany("ControlItemSnapshots")
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ControlItem");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderStatusHistory", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ChangedBy")
+                        .WithMany()
+                        .HasForeignKey("ChangedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChangedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkTimeRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Checklist", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.Navigation("Results");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.Navigation("Parts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("Results");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.Navigation("Records");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.Navigation("Parts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.Navigation("Materials");
+
+                    b.Navigation("WorkOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.Navigation("Defects");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.Navigation("ControlItemLinks");
+
+                    b.Navigation("EquipmentCandidates");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.Navigation("ControlItemSnapshots");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/MesApp.Infrastructure/Migrations/20260923081738_LinkControlItemsToRouting.cs b/src/MesApp.Infrastructure/Migrations/20260923081738_LinkControlItemsToRouting.cs
new file mode 100644
index 0000000..f24ff37
--- /dev/null
+++ b/src/MesApp.Infrastructure/Migrations/20260923081738_LinkControlItemsToRouting.cs
@@ -0,0 +1,118 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MesApp.Infrastructure.Migrations
+{
+    /// <inheritdoc />
+    public partial class LinkControlItemsToRouting : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ControlItems_Processes_TargetProcessId",
+                table: "ControlItems");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_ControlItems_Products_TargetProductId",
+                table: "ControlItems");
+
+            migrationBuilder.DropIndex(
+                name: "IX_ControlItems_TargetProcessId",
+                table: "ControlItems");
+
+            migrationBuilder.DropIndex(
+                name: "IX_ControlItems_TargetProductId",
+                table: "ControlItems");
+
+            migrationBuilder.DropColumn(
+                name: "TargetProcessId",
+                table: "ControlItems");
+
+            migrationBuilder.DropColumn(
+                name: "TargetProductId",
+                table: "ControlItems");
+
+            migrationBuilder.CreateTable(
+                name: "RoutingControlItems",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    RoutingId = table.Column<int>(type: "INTEGER", nullable: false),
+                    ControlItemId = table.Column<int>(type: "INTEGER", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_RoutingControlItems", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_RoutingControlItems_ControlItems_ControlItemId",
+                        column: x => x.ControlItemId,
+                        principalTable: "ControlItems",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_RoutingControlItems_Routings_RoutingId",
+                        column: x => x.RoutingId,
+                        principalTable: "Routings",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_RoutingControlItems_ControlItemId",
+                table: "RoutingControlItems",
+                column: "ControlItemId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_RoutingControlItems_RoutingId_ControlItemId",
+                table: "RoutingControlItems",
+                columns: new[] { "RoutingId", "ControlItemId" },
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "RoutingControlItems");
+
+            migrationBuilder.AddColumn<int>(
+                name: "TargetProcessId",
+                table: "ControlItems",
+                type: "INTEGER",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "TargetProductId",
+                table: "ControlItems",
+                type: "INTEGER",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ControlItems_TargetProcessId",
+                table: "ControlItems",
+                column: "TargetProcessId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ControlItems_TargetProductId",
+                table: "ControlItems",
+                column: "TargetProductId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ControlItems_Processes_TargetProcessId",
+                table: "ControlItems",
+                column: "TargetProcessId",
+                principalTable: "Processes",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ControlItems_Products_TargetProductId",
+                table: "ControlItems",
+                column: "TargetProductId",
+                principalTable: "Products",
+                principalColumn: "Id");
+        }
+    }
+}
diff --git a/src/MesApp.Infrastructure/Migrations/MesAppDbContextModelSnapshot.cs b/src/MesApp.Infrastructure/Migrations/MesAppDbContextModelSnapshot.cs
index 2b78802..19d0494 100644
--- a/src/MesApp.Infrastructure/Migrations/MesAppDbContextModelSnapshot.cs
+++ b/src/MesApp.Infrastructure/Migrations/MesAppDbContextModelSnapshot.cs
@@ -349,12 +349,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasMaxLength(200)
                         .HasColumnType("TEXT");
 
-                    b.Property<int?>("TargetProcessId")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<int?>("TargetProductId")
-                        .HasColumnType("INTEGER");
-
                     b.Property<decimal?>("TargetValue")
                         .HasColumnType("TEXT");
 
@@ -373,10 +367,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.HasIndex("Code")
                         .IsUnique();
 
-                    b.HasIndex("TargetProcessId");
-
-                    b.HasIndex("TargetProductId");
-
                     b.ToTable("ControlItems");
                 });
 
@@ -2231,6 +2221,28 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Routings");
                 });
 
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ControlItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("RoutingId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ControlItemId");
+
+                    b.HasIndex("RoutingId", "ControlItemId")
+                        .IsUnique();
+
+                    b.ToTable("RoutingControlItems");
+                });
+
             modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
                 {
                     b.Property<int>("Id")
@@ -2943,7 +2955,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("TEXT");
 
                     b.Property<string>("ControlItems")
-                        .HasMaxLength(500)
+                        .HasMaxLength(1000)
                         .HasColumnType("TEXT");
 
                     b.Property<DateTimeOffset>("CreatedAt")
@@ -3420,21 +3432,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("ChecklistItem");
                 });
 
-            modelBuilder.Entity("MesApp.Core.Entities.ControlItem", b =>
-                {
-                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "TargetProcess")
-                        .WithMany()
-                        .HasForeignKey("TargetProcessId");
-
-                    b.HasOne("MesApp.Core.Entities.Product", "TargetProduct")
-                        .WithMany()
-                        .HasForeignKey("TargetProductId");
-
-                    b.Navigation("TargetProcess");
-
-                    b.Navigation("TargetProduct");
-                });
-
             modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
                 {
                     b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
@@ -4220,6 +4217,25 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("WorkProcedure");
                 });
 
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ControlItem", "ControlItem")
+                        .WithMany()
+                        .HasForeignKey("ControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Routing", "Routing")
+                        .WithMany("ControlItemLinks")
+                        .HasForeignKey("RoutingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ControlItem");
+
+                    b.Navigation("Routing");
+                });
+
             modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
                 {
                     b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
@@ -4727,6 +4743,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
             modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
                 {
+                    b.Navigation("ControlItemLinks");
+
                     b.Navigation("EquipmentCandidates");
                 });
 
diff --git a/src/MesApp.Migrations.PostgreSql/Migrations/20260923080828_WidenWorkOrderControlItems.Designer.cs b/src/MesApp.Migrations.PostgreSql/Migrations/20260923080828_WidenWorkOrderControlItems.Designer.cs
new file mode 100644
index 0000000..d4a2fa2
--- /dev/null
+++ b/src/MesApp.Migrations.PostgreSql/Migrations/20260923080828_WidenWorkOrderControlItems.Designer.cs
@@ -0,0 +1,4950 @@
+// <auto-generated />
+using System;
+using MesApp.Infrastructure;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MesApp.Migrations.PostgreSql.Migrations
+{
+    [DbContext(typeof(MesAppDbContext))]
+    [Migration("20260923080828_WidenWorkOrderControlItems")]
+    partial class WidenWorkOrderControlItems
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.10")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MesApp.Core.Entities.AppUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Department")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("MustChangePassword")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ShiftId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.HasIndex("ShiftId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.AuditLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Detail")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IpAddress")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly>("RecordedOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("TargetId")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("TargetType")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RecordedOn");
+
+                    b.HasIndex("Timestamp");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("Category", "Action");
+
+                    b.HasIndex("TargetType", "TargetId");
+
+                    b.ToTable("AuditLogs");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.BomItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlternativeGroup")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("ChildProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsAlternative")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("MakeOrBuy")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int>("ParentProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("RoutingSequence")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildProductId");
+
+                    b.HasIndex("ParentProductId", "ChildProductId")
+                        .IsUnique();
+
+                    b.ToTable("BomItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Checklist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Checklists");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRequired")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.ToTable("ChecklistItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("PerformedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ChecklistRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistResultItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistItemId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ChecklistRecordId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsChecked")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistItemId");
+
+                    b.HasIndex("ChecklistRecordId");
+
+                    b.ToTable("ChecklistResultItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int?>("TargetProcessId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("TargetProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("TargetValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Unit")
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("TargetProcessId");
+
+                    b.HasIndex("TargetProductId");
+
+                    b.ToTable("ControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.DefectReason", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("DefectReasons");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("MaintenanceParts")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<decimal?>("MaintenanceThreshold")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("MaintenanceType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Site")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetNo")
+                        .IsUnique();
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("Equipments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("StopCause")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("EquipmentLogs");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentPart", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("numeric(18,4)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("EquipmentId", "ProductId")
+                        .IsUnique();
+
+                    b.ToTable("EquipmentParts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDevice", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly?>("CalibratedOn")
+                        .HasColumnType("date");
+
+                    b.Property<int?>("CalibrationCycleDays")
+                        .HasColumnType("integer");
+
+                    b.Property<DateOnly?>("CalibrationDueOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Location")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("SerialNo")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("InspectionDevices");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDeviceCalibration", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly>("CalibratedOn")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("InspectionDeviceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateOnly?>("NextDueOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("InspectionDeviceId", "CalibratedOn");
+
+                    b.ToTable("InspectionDeviceCalibrations");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Method")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int?>("SamplingCount")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("StandardValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("TargetProcessId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("TargetProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("TargetProcessId");
+
+                    b.HasIndex("TargetProductId");
+
+                    b.ToTable("InspectionItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("JudgedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("JudgedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OverallJudgment")
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("RequestedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("TargetLotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("TargetWorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedByUserId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("TargetLotId");
+
+                    b.HasIndex("TargetWorkOrderId");
+
+                    b.ToTable("InspectionOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrderItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("InspectionItemId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ItemCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ItemName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("ItemVersion")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Method")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("SamplingCount")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("StandardValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionItemId");
+
+                    b.HasIndex("InspectionOrderId", "InspectionItemId")
+                        .IsUnique();
+
+                    b.ToTable("InspectionOrderItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResult", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CorrectionNote")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<DateTimeOffset>("InspectedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("InspectedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("InspectionDeviceId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("InspectionItemId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Judgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal?>("MeasuredValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("SampleNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectedByUserId");
+
+                    b.HasIndex("InspectionDeviceId");
+
+                    b.HasIndex("InspectionItemId");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.ToTable("InspectionResults");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResultCorrection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AfterJudgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal?>("AfterMeasuredValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("AfterTextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("BeforeJudgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal?>("BeforeMeasuredValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("BeforeTextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<DateTimeOffset>("CorrectedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CorrectedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("InspectionResultId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrectedByUserId");
+
+                    b.HasIndex("InspectionResultId");
+
+                    b.HasIndex("InspectionOrderId", "Id");
+
+                    b.ToTable("InspectionResultCorrections");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryStock", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId", "LocationId")
+                        .IsUnique();
+
+                    b.HasIndex("ProductId", "LocationId");
+
+                    b.ToTable("InventoryStocks");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryTransaction", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("FromLocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PickingOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("ToLocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FromLocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("Timestamp");
+
+                    b.HasIndex("ToLocationId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("InventoryTransactions");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Location", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AreaType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ShelfNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Lot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateOnly?>("ExpiresOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Grade")
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal>("InitialQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("LotNumber")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("character varying(60)");
+
+                    b.Property<DateOnly?>("ManufacturedOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("OriginType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("ParentLotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SourceWorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("StockStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LotNumber")
+                        .IsUnique();
+
+                    b.HasIndex("ParentLotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SourceWorkOrderId");
+
+                    b.ToTable("Lots");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotGenealogy", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChildLotId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("ParentLotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("RelationType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildLotId");
+
+                    b.HasIndex("ParentLotId");
+
+                    b.ToTable("LotGenealogies");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotStatusHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("ChangedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ChangedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.Property<string>("FromStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("NonconformanceReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("ToStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LotId", "Id");
+
+                    b.ToTable("LotStatusHistories");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("MaintenancePlanId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int?>("ProcedureId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<DateOnly?>("ScheduledDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("ToolId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedByUserId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("MaintenancePlanId");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("ProcedureId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("ToolId");
+
+                    b.ToTable("MaintenanceOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenancePlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("CycleDays")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<int>("PlanYear")
+                        .HasColumnType("integer");
+
+                    b.Property<DateOnly?>("ScheduledDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId", "PlanYear");
+
+                    b.ToTable("MaintenancePlans");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceProcedure", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ProcedureNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Steps")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<int?>("TargetEquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("TargetToolId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcedureNo")
+                        .IsUnique();
+
+                    b.HasIndex("TargetEquipmentId");
+
+                    b.HasIndex("TargetToolId");
+
+                    b.ToTable("MaintenanceProcedures");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MaintenanceOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("PartsUsed")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MaintenanceOrderId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.ToTable("MaintenanceRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecordPart", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaintenanceRecordId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("numeric(18,4)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("MaintenanceRecordId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("MaintenanceRecordParts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OrderType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("OutputLotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("SourceOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputLotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SourceOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("ManufacturingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrderMaterial", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlternativeGroup")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("ChildProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsAlternative")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("ManufacturingOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("RoutingSequence")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildProductId");
+
+                    b.HasIndex("ManufacturingOrderId", "ChildProductId")
+                        .IsUnique();
+
+                    b.ToTable("ManufacturingOrderMaterials");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaterialConsumption", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("ConsumedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsSubstitute")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Method")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubstituteReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("MaterialConsumptions");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NonconformanceReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Action")
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<DateTimeOffset?>("ActionCompletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ActionCompletedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("ActionInstructedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ActionInstructedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ActionInstruction")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("ActionRecord")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CauseCategory")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("CauseDetail")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReportNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ReportedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ReworkOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ReportNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReportedByUserId");
+
+                    b.HasIndex("ReworkOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("NonconformanceReports");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("LastValue")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Prefix")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("character varying(60)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Prefix")
+                        .IsUnique();
+
+                    b.ToTable("NumberSequences");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PickingOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("PickingOrderId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("PickingLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("ExecutedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ExecutedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("PickingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProcessMaster", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Processes", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Product", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("DefaultLocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Specification")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<decimal>("StandardDefectRate")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Unit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("DefaultLocationId");
+
+                    b.ToTable("Products");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDataRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<bool?>("IsDeviation")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Item")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("NumericValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("WorkOrderControlItemId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderControlItemId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ProductionDataRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDefect", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("DefectReasonId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int>("ProductionRecordId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DefectReasonId");
+
+                    b.HasIndex("ProductionRecordId");
+
+                    b.ToTable("ProductionDefects");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionPlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("BusinessDate", "ProductId", "ProcessId", "WorkCenterId")
+                        .IsUnique();
+
+                    b.ToTable("ProductionPlans");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("DefectQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("GoodQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("OutputLocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("OutputLotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("ReworkQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("ScrapQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("ShiftId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OutputLotId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("ShiftId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ProductionRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecordCorrection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("AfterDefectQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("AfterGoodQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("AfterReworkQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("AfterScrapQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("BeforeDefectQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("BeforeGoodQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("BeforeReworkQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("BeforeScrapQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<DateTimeOffset>("CorrectedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CorrectedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.Property<int>("ProductionRecordId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrectedByUserId");
+
+                    b.HasIndex("ProductionRecordId");
+
+                    b.HasIndex("WorkOrderId", "Id");
+
+                    b.ToTable("ProductionRecordCorrections");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RefreshToken", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("RevokedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TokenHash")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("ChecklistId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ControlItems")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("RequiredSkillId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("StandardSetupMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("StandardWorkMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("ToolId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("WorkProcedureId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("RequiredSkillId");
+
+                    b.HasIndex("ToolId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("WorkProcedureId");
+
+                    b.HasIndex("ProductId", "Sequence")
+                        .IsUnique();
+
+                    b.ToTable("Routings");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RoutingId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("RoutingId", "EquipmentId")
+                        .IsUnique();
+
+                    b.ToTable("RoutingEquipments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SampleStorage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClosedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly?>("ClosedOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("CollectedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly>("CollectedOn")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("numeric(18,4)");
+
+                    b.Property<DateOnly?>("RetainUntil")
+                        .HasColumnType("date");
+
+                    b.Property<string>("SampleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("StorageLocationId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SampleNo")
+                        .IsUnique();
+
+                    b.HasIndex("StorageLocationId");
+
+                    b.HasIndex("Status", "RetainUntil");
+
+                    b.ToTable("SampleStorages");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SetupRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AbnormalityNote")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("SetupRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Shift", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)");
+
+                    b.Property<TimeOnly>("EndTime")
+                        .HasColumnType("time without time zone");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<TimeOnly>("StartTime")
+                        .HasColumnType("time without time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Shifts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShipmentJudgment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("JudgedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("JudgedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("JudgmentNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int?>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("Result")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JudgedByUserId");
+
+                    b.HasIndex("JudgmentNo")
+                        .IsUnique();
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.ToTable("ShipmentJudgments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("ShippedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("ShippingOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.ToTable("ShippingLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Destination")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateOnly?>("PlannedDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset?>("ShippedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ShippedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShippingNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ShippingNo")
+                        .IsUnique();
+
+                    b.ToTable("ShippingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SkillMaster", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<bool>("RequiresExpiry")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Skills", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("FinalizedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FinalizedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("StocktakeNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int?>("TargetLocationId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StocktakeNo")
+                        .IsUnique();
+
+                    b.HasIndex("TargetLocationId");
+
+                    b.ToTable("Stocktakes");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.StocktakeLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal?>("CountedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<bool>("IsAdjusted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("StocktakeId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("TheoreticalQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("StocktakeId");
+
+                    b.ToTable("StocktakeLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Tool", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LifeResetAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("LifeThresholdCount")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("LifeThresholdHours")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("ToolType")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Tools");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolIssue", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("AllocatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("AllocatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("IssuedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("IssuedToUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<DateTimeOffset?>("ReturnedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ReturnedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ToolId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IssuedToUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.HasIndex("ToolId", "Status");
+
+                    b.ToTable("ToolIssues");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolUsage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ToolId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("UsageCount")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("UsageHours")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ToolId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ToolUsages");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TransferOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("ExecutedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ExecutedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("FromLocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int>("ToLocationId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FromLocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("ToLocationId");
+
+                    b.ToTable("TransferOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TroubleReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ReportedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ResponseHistory")
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("ReportedByUserId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("TroubleReports");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.UserSkill", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly?>("AcquiredOn")
+                        .HasColumnType("date");
+
+                    b.Property<DateOnly?>("ExpiresOn")
+                        .HasColumnType("date");
+
+                    b.Property<int>("SkillId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SkillId");
+
+                    b.HasIndex("UserId", "SkillId")
+                        .IsUnique();
+
+                    b.ToTable("UserSkills");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkCenter", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Level")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int?>("ParentId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("WorkCenters");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AssignedEquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AssignedUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ControlItems")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("DispatchOrder")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ManufacturingOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("RequiredSkillId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("RoutingChecklistId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RoutingSequence")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("StandardSetupMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("StandardWorkMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("WorkOrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int?>("WorkProcedureId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("WorkProcedureVersion")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignedEquipmentId");
+
+                    b.HasIndex("AssignedUserId");
+
+                    b.HasIndex("ManufacturingOrderId");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("RequiredSkillId");
+
+                    b.HasIndex("RoutingChecklistId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("WorkOrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("WorkProcedureId");
+
+                    b.ToTable("WorkOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("ControlItemId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ItemCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ItemName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("ItemVersion")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal?>("TargetValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Unit")
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ControlItemId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("WorkOrderControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderStatusHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("ChangedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ChangedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.Property<string>("FromStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("ToStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChangedByUserId");
+
+                    b.HasIndex("WorkOrderId", "Id");
+
+                    b.ToTable("WorkOrderStatusHistories");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkProcedure", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ProcedureNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Steps")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcedureNo")
+                        .IsUnique();
+
+                    b.ToTable("WorkProcedures");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkTimeRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("IndirectCategory")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.HasIndex("UserId", "StartedAt");
+
+                    b.ToTable("WorkTimeRecords");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.AppUser", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Shift", "Shift")
+                        .WithMany()
+                        .HasForeignKey("ShiftId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Shift");
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.BomItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "ChildProduct")
+                        .WithMany()
+                        .HasForeignKey("ChildProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "ParentProduct")
+                        .WithMany()
+                        .HasForeignKey("ParentProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildProduct");
+
+                    b.Navigation("ParentProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", null)
+                        .WithMany("Items")
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", "Checklist")
+                        .WithMany()
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Checklist");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistResultItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ChecklistItem", "ChecklistItem")
+                        .WithMany()
+                        .HasForeignKey("ChecklistItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ChecklistRecord", null)
+                        .WithMany("Results")
+                        .HasForeignKey("ChecklistRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChecklistItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "TargetProcess")
+                        .WithMany()
+                        .HasForeignKey("TargetProcessId");
+
+                    b.HasOne("MesApp.Core.Entities.Product", "TargetProduct")
+                        .WithMany()
+                        .HasForeignKey("TargetProductId");
+
+                    b.Navigation("TargetProcess");
+
+                    b.Navigation("TargetProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentLog", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentPart", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany("Parts")
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDeviceCalibration", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionDevice", "InspectionDevice")
+                        .WithMany()
+                        .HasForeignKey("InspectionDeviceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("InspectionDevice");
+
+                    b.Navigation("PerformedBy");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "TargetProcess")
+                        .WithMany()
+                        .HasForeignKey("TargetProcessId");
+
+                    b.HasOne("MesApp.Core.Entities.Product", "TargetProduct")
+                        .WithMany()
+                        .HasForeignKey("TargetProductId");
+
+                    b.Navigation("TargetProcess");
+
+                    b.Navigation("TargetProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "RequestedBy")
+                        .WithMany()
+                        .HasForeignKey("RequestedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "TargetLot")
+                        .WithMany()
+                        .HasForeignKey("TargetLotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "TargetWorkOrder")
+                        .WithMany()
+                        .HasForeignKey("TargetWorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("RequestedBy");
+
+                    b.Navigation("TargetLot");
+
+                    b.Navigation("TargetWorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrderItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionItem", "InspectionItem")
+                        .WithMany()
+                        .HasForeignKey("InspectionItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", null)
+                        .WithMany("Items")
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResult", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "InspectedBy")
+                        .WithMany()
+                        .HasForeignKey("InspectedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionDevice", "InspectionDevice")
+                        .WithMany()
+                        .HasForeignKey("InspectionDeviceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.InspectionItem", "InspectionItem")
+                        .WithMany()
+                        .HasForeignKey("InspectionItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", null)
+                        .WithMany("Results")
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectedBy");
+
+                    b.Navigation("InspectionDevice");
+
+                    b.Navigation("InspectionItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResultCorrection", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CorrectedBy")
+                        .WithMany()
+                        .HasForeignKey("CorrectedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.InspectionResult", "InspectionResult")
+                        .WithMany()
+                        .HasForeignKey("InspectionResultId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CorrectedBy");
+
+                    b.Navigation("InspectionResult");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryStock", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryTransaction", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "FromLocation")
+                        .WithMany()
+                        .HasForeignKey("FromLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "ToLocation")
+                        .WithMany()
+                        .HasForeignKey("ToLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("FromLocation");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("ToLocation");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Location", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Lot", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "ParentLot")
+                        .WithMany()
+                        .HasForeignKey("ParentLotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "SourceWorkOrder")
+                        .WithMany()
+                        .HasForeignKey("SourceWorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("ParentLot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("SourceWorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotGenealogy", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "ChildLot")
+                        .WithMany()
+                        .HasForeignKey("ChildLotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "ParentLot")
+                        .WithMany()
+                        .HasForeignKey("ParentLotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ChildLot");
+
+                    b.Navigation("ParentLot");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotStatusHistory", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Lot");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.MaintenancePlan", "MaintenancePlan")
+                        .WithMany()
+                        .HasForeignKey("MaintenancePlanId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.MaintenanceProcedure", "Procedure")
+                        .WithMany()
+                        .HasForeignKey("ProcedureId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("MaintenancePlan");
+
+                    b.Navigation("Procedure");
+
+                    b.Navigation("Tool");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenancePlan", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceProcedure", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "TargetEquipment")
+                        .WithMany()
+                        .HasForeignKey("TargetEquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "TargetTool")
+                        .WithMany()
+                        .HasForeignKey("TargetToolId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("TargetEquipment");
+
+                    b.Navigation("TargetTool");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.MaintenanceOrder", null)
+                        .WithMany("Records")
+                        .HasForeignKey("MaintenanceOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("PerformedBy");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecordPart", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.MaintenanceRecord", null)
+                        .WithMany("Parts")
+                        .HasForeignKey("MaintenanceRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "OutputLot")
+                        .WithMany()
+                        .HasForeignKey("OutputLotId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "SourceOrder")
+                        .WithMany()
+                        .HasForeignKey("SourceOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("OutputLot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("SourceOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrderMaterial", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "ChildProduct")
+                        .WithMany()
+                        .HasForeignKey("ChildProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ManufacturingOrder")
+                        .WithMany("Materials")
+                        .HasForeignKey("ManufacturingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildProduct");
+
+                    b.Navigation("ManufacturingOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaterialConsumption", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NonconformanceReport", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", "InspectionOrder")
+                        .WithMany()
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ReportedBy")
+                        .WithMany()
+                        .HasForeignKey("ReportedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ReworkOrder")
+                        .WithMany()
+                        .HasForeignKey("ReworkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("InspectionOrder");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ReportedBy");
+
+                    b.Navigation("ReworkOrder");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.PickingOrder", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("PickingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", "ShippingOrder")
+                        .WithMany()
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("ShippingOrder");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Product", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "DefaultLocation")
+                        .WithMany()
+                        .HasForeignKey("DefaultLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDataRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkOrderControlItem", "WorkOrderControlItem")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WorkOrder");
+
+                    b.Navigation("WorkOrderControlItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDefect", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.DefectReason", "DefectReason")
+                        .WithMany()
+                        .HasForeignKey("DefectReasonId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ProductionRecord", "ProductionRecord")
+                        .WithMany("Defects")
+                        .HasForeignKey("ProductionRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DefectReason");
+
+                    b.Navigation("ProductionRecord");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionPlan", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "OutputLot")
+                        .WithMany()
+                        .HasForeignKey("OutputLotId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Shift", "Shift")
+                        .WithMany()
+                        .HasForeignKey("ShiftId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OutputLot");
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("Shift");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecordCorrection", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CorrectedBy")
+                        .WithMany()
+                        .HasForeignKey("CorrectedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.ProductionRecord", "ProductionRecord")
+                        .WithMany()
+                        .HasForeignKey("ProductionRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CorrectedBy");
+
+                    b.Navigation("ProductionRecord");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RefreshToken", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", "Checklist")
+                        .WithMany()
+                        .HasForeignKey("ChecklistId");
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId");
+
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "RequiredSkill")
+                        .WithMany()
+                        .HasForeignKey("RequiredSkillId");
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId");
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkProcedure", "WorkProcedure")
+                        .WithMany()
+                        .HasForeignKey("WorkProcedureId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Checklist");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("RequiredSkill");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkCenter");
+
+                    b.Navigation("WorkProcedure");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Routing", "Routing")
+                        .WithMany("EquipmentCandidates")
+                        .HasForeignKey("RoutingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Routing");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SampleStorage", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", "InspectionOrder")
+                        .WithMany()
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "StorageLocation")
+                        .WithMany()
+                        .HasForeignKey("StorageLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("InspectionOrder");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("StorageLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SetupRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShipmentJudgment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "JudgedBy")
+                        .WithMany()
+                        .HasForeignKey("JudgedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", "ShippingOrder")
+                        .WithMany()
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("JudgedBy");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ShippingOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "TargetLocation")
+                        .WithMany()
+                        .HasForeignKey("TargetLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("TargetLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.StocktakeLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Stocktake", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("StocktakeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolIssue", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "IssuedTo")
+                        .WithMany()
+                        .HasForeignKey("IssuedToUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("IssuedTo");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolUsage", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TransferOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "FromLocation")
+                        .WithMany()
+                        .HasForeignKey("FromLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "ToLocation")
+                        .WithMany()
+                        .HasForeignKey("ToLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("FromLocation");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ToLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TroubleReport", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ReportedBy")
+                        .WithMany()
+                        .HasForeignKey("ReportedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("ReportedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.UserSkill", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "Skill")
+                        .WithMany()
+                        .HasForeignKey("SkillId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Skill");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkCenter", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "Parent")
+                        .WithMany()
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "AssignedEquipment")
+                        .WithMany()
+                        .HasForeignKey("AssignedEquipmentId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "AssignedUser")
+                        .WithMany()
+                        .HasForeignKey("AssignedUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ManufacturingOrder")
+                        .WithMany("WorkOrders")
+                        .HasForeignKey("ManufacturingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "RequiredSkill")
+                        .WithMany()
+                        .HasForeignKey("RequiredSkillId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Checklist", "RoutingChecklist")
+                        .WithMany()
+                        .HasForeignKey("RoutingChecklistId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkProcedure", "WorkProcedure")
+                        .WithMany()
+                        .HasForeignKey("WorkProcedureId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("AssignedEquipment");
+
+                    b.Navigation("AssignedUser");
+
+                    b.Navigation("ManufacturingOrder");
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("RequiredSkill");
+
+                    b.Navigation("RoutingChecklist");
+
+                    b.Navigation("WorkCenter");
+
+                    b.Navigation("WorkProcedure");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ControlItem", "ControlItem")
+                        .WithMany()
+                        .HasForeignKey("ControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany("ControlItemSnapshots")
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ControlItem");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderStatusHistory", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ChangedBy")
+                        .WithMany()
+                        .HasForeignKey("ChangedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChangedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkTimeRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Checklist", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.Navigation("Results");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.Navigation("Parts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("Results");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.Navigation("Records");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.Navigation("Parts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.Navigation("Materials");
+
+                    b.Navigation("WorkOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.Navigation("Defects");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.Navigation("EquipmentCandidates");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.Navigation("ControlItemSnapshots");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/MesApp.Migrations.PostgreSql/Migrations/20260923080828_WidenWorkOrderControlItems.cs b/src/MesApp.Migrations.PostgreSql/Migrations/20260923080828_WidenWorkOrderControlItems.cs
new file mode 100644
index 0000000..2ec991b
--- /dev/null
+++ b/src/MesApp.Migrations.PostgreSql/Migrations/20260923080828_WidenWorkOrderControlItems.cs
@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MesApp.Migrations.PostgreSql.Migrations
+{
+    /// <inheritdoc />
+    public partial class WidenWorkOrderControlItems : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "ControlItems",
+                table: "WorkOrders",
+                type: "character varying(1000)",
+                maxLength: 1000,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(500)",
+                oldMaxLength: 500,
+                oldNullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "ControlItems",
+                table: "WorkOrders",
+                type: "character varying(500)",
+                maxLength: 500,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "character varying(1000)",
+                oldMaxLength: 1000,
+                oldNullable: true);
+        }
+    }
+}
diff --git a/src/MesApp.Migrations.PostgreSql/Migrations/20260923081741_LinkControlItemsToRouting.Designer.cs b/src/MesApp.Migrations.PostgreSql/Migrations/20260923081741_LinkControlItemsToRouting.Designer.cs
new file mode 100644
index 0000000..59e50c9
--- /dev/null
+++ b/src/MesApp.Migrations.PostgreSql/Migrations/20260923081741_LinkControlItemsToRouting.Designer.cs
@@ -0,0 +1,4970 @@
+// <auto-generated />
+using System;
+using MesApp.Infrastructure;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MesApp.Migrations.PostgreSql.Migrations
+{
+    [DbContext(typeof(MesAppDbContext))]
+    [Migration("20260923081741_LinkControlItemsToRouting")]
+    partial class LinkControlItemsToRouting
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.10")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("MesApp.Core.Entities.AppUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Department")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("MustChangePassword")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ShiftId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.HasIndex("ShiftId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.AuditLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Detail")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IpAddress")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly>("RecordedOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("TargetId")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("TargetType")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RecordedOn");
+
+                    b.HasIndex("Timestamp");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("Category", "Action");
+
+                    b.HasIndex("TargetType", "TargetId");
+
+                    b.ToTable("AuditLogs");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.BomItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlternativeGroup")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("ChildProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsAlternative")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("MakeOrBuy")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int>("ParentProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("RoutingSequence")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildProductId");
+
+                    b.HasIndex("ParentProductId", "ChildProductId")
+                        .IsUnique();
+
+                    b.ToTable("BomItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Checklist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Checklists");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRequired")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.ToTable("ChecklistItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("PerformedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ChecklistRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistResultItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistItemId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ChecklistRecordId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsChecked")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistItemId");
+
+                    b.HasIndex("ChecklistRecordId");
+
+                    b.ToTable("ChecklistResultItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<decimal?>("TargetValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Unit")
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("ControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.DefectReason", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("DefectReasons");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("MaintenanceParts")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<decimal?>("MaintenanceThreshold")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("MaintenanceType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Site")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetNo")
+                        .IsUnique();
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("Equipments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("StopCause")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("EquipmentLogs");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentPart", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("numeric(18,4)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("EquipmentId", "ProductId")
+                        .IsUnique();
+
+                    b.ToTable("EquipmentParts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDevice", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly?>("CalibratedOn")
+                        .HasColumnType("date");
+
+                    b.Property<int?>("CalibrationCycleDays")
+                        .HasColumnType("integer");
+
+                    b.Property<DateOnly?>("CalibrationDueOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Location")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("SerialNo")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("InspectionDevices");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDeviceCalibration", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly>("CalibratedOn")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("InspectionDeviceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateOnly?>("NextDueOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("InspectionDeviceId", "CalibratedOn");
+
+                    b.ToTable("InspectionDeviceCalibrations");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Method")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int?>("SamplingCount")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("StandardValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("TargetProcessId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("TargetProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("TargetProcessId");
+
+                    b.HasIndex("TargetProductId");
+
+                    b.ToTable("InspectionItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("JudgedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("JudgedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OverallJudgment")
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("RequestedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("TargetLotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("TargetWorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedByUserId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("TargetLotId");
+
+                    b.HasIndex("TargetWorkOrderId");
+
+                    b.ToTable("InspectionOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrderItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("InspectionItemId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ItemCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ItemName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("ItemVersion")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Method")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("SamplingCount")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("StandardValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionItemId");
+
+                    b.HasIndex("InspectionOrderId", "InspectionItemId")
+                        .IsUnique();
+
+                    b.ToTable("InspectionOrderItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResult", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CorrectionNote")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<DateTimeOffset>("InspectedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("InspectedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("InspectionDeviceId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("InspectionItemId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Judgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal?>("MeasuredValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("SampleNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectedByUserId");
+
+                    b.HasIndex("InspectionDeviceId");
+
+                    b.HasIndex("InspectionItemId");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.ToTable("InspectionResults");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResultCorrection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AfterJudgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal?>("AfterMeasuredValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("AfterTextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("BeforeJudgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal?>("BeforeMeasuredValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("BeforeTextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<DateTimeOffset>("CorrectedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CorrectedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("InspectionResultId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrectedByUserId");
+
+                    b.HasIndex("InspectionResultId");
+
+                    b.HasIndex("InspectionOrderId", "Id");
+
+                    b.ToTable("InspectionResultCorrections");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryStock", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId", "LocationId")
+                        .IsUnique();
+
+                    b.HasIndex("ProductId", "LocationId");
+
+                    b.ToTable("InventoryStocks");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryTransaction", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("FromLocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PickingOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("ToLocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FromLocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("Timestamp");
+
+                    b.HasIndex("ToLocationId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("InventoryTransactions");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Location", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AreaType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ShelfNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Lot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateOnly?>("ExpiresOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Grade")
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal>("InitialQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("LotNumber")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("character varying(60)");
+
+                    b.Property<DateOnly?>("ManufacturedOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("OriginType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("ParentLotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SourceWorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("StockStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LotNumber")
+                        .IsUnique();
+
+                    b.HasIndex("ParentLotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SourceWorkOrderId");
+
+                    b.ToTable("Lots");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotGenealogy", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChildLotId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("ParentLotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("RelationType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildLotId");
+
+                    b.HasIndex("ParentLotId");
+
+                    b.ToTable("LotGenealogies");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotStatusHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("ChangedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ChangedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.Property<string>("FromStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("NonconformanceReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("ToStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LotId", "Id");
+
+                    b.ToTable("LotStatusHistories");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("MaintenancePlanId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int?>("ProcedureId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<DateOnly?>("ScheduledDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("ToolId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedByUserId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("MaintenancePlanId");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("ProcedureId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("ToolId");
+
+                    b.ToTable("MaintenanceOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenancePlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("CycleDays")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<int>("PlanYear")
+                        .HasColumnType("integer");
+
+                    b.Property<DateOnly?>("ScheduledDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId", "PlanYear");
+
+                    b.ToTable("MaintenancePlans");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceProcedure", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ProcedureNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Steps")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<int?>("TargetEquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("TargetToolId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcedureNo")
+                        .IsUnique();
+
+                    b.HasIndex("TargetEquipmentId");
+
+                    b.HasIndex("TargetToolId");
+
+                    b.ToTable("MaintenanceProcedures");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MaintenanceOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("PartsUsed")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MaintenanceOrderId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.ToTable("MaintenanceRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecordPart", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaintenanceRecordId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("numeric(18,4)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("MaintenanceRecordId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("MaintenanceRecordParts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OrderType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("OutputLotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("SourceOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputLotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SourceOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("ManufacturingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrderMaterial", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlternativeGroup")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("ChildProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsAlternative")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("ManufacturingOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("RoutingSequence")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildProductId");
+
+                    b.HasIndex("ManufacturingOrderId", "ChildProductId")
+                        .IsUnique();
+
+                    b.ToTable("ManufacturingOrderMaterials");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaterialConsumption", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("ConsumedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsSubstitute")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Method")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubstituteReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("MaterialConsumptions");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NonconformanceReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Action")
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<DateTimeOffset?>("ActionCompletedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ActionCompletedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("ActionInstructedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ActionInstructedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ActionInstruction")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("ActionRecord")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CauseCategory")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("CauseDetail")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReportNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ReportedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ReworkOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ReportNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReportedByUserId");
+
+                    b.HasIndex("ReworkOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("NonconformanceReports");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("LastValue")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Prefix")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("character varying(60)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Prefix")
+                        .IsUnique();
+
+                    b.ToTable("NumberSequences");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PickingOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("PickingOrderId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("PickingLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("ExecutedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ExecutedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("PickingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProcessMaster", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Processes", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Product", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("DefaultLocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Specification")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<decimal>("StandardDefectRate")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Unit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("DefaultLocationId");
+
+                    b.ToTable("Products");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDataRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<bool?>("IsDeviation")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Item")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("NumericValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("WorkOrderControlItemId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderControlItemId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ProductionDataRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDefect", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("DefectReasonId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int>("ProductionRecordId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DefectReasonId");
+
+                    b.HasIndex("ProductionRecordId");
+
+                    b.ToTable("ProductionDefects");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionPlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("BusinessDate", "ProductId", "ProcessId", "WorkCenterId")
+                        .IsUnique();
+
+                    b.ToTable("ProductionPlans");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("DefectQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("GoodQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("OutputLocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("OutputLotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("ReworkQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("ScrapQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("ShiftId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OutputLotId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("ShiftId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ProductionRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecordCorrection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("AfterDefectQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("AfterGoodQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("AfterReworkQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("AfterScrapQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("BeforeDefectQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("BeforeGoodQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("BeforeReworkQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("BeforeScrapQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<DateTimeOffset>("CorrectedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CorrectedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.Property<int>("ProductionRecordId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrectedByUserId");
+
+                    b.HasIndex("ProductionRecordId");
+
+                    b.HasIndex("WorkOrderId", "Id");
+
+                    b.ToTable("ProductionRecordCorrections");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RefreshToken", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("RevokedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TokenHash")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("ChecklistId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ControlItems")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("RequiredSkillId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("StandardSetupMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("StandardWorkMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("ToolId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("WorkProcedureId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("RequiredSkillId");
+
+                    b.HasIndex("ToolId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("WorkProcedureId");
+
+                    b.HasIndex("ProductId", "Sequence")
+                        .IsUnique();
+
+                    b.ToTable("Routings");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ControlItemId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RoutingId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ControlItemId");
+
+                    b.HasIndex("RoutingId", "ControlItemId")
+                        .IsUnique();
+
+                    b.ToTable("RoutingControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RoutingId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("RoutingId", "EquipmentId")
+                        .IsUnique();
+
+                    b.ToTable("RoutingEquipments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SampleStorage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClosedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly?>("ClosedOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("CollectedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly>("CollectedOn")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("numeric(18,4)");
+
+                    b.Property<DateOnly?>("RetainUntil")
+                        .HasColumnType("date");
+
+                    b.Property<string>("SampleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("StorageLocationId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SampleNo")
+                        .IsUnique();
+
+                    b.HasIndex("StorageLocationId");
+
+                    b.HasIndex("Status", "RetainUntil");
+
+                    b.ToTable("SampleStorages");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SetupRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AbnormalityNote")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("SetupRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Shift", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)");
+
+                    b.Property<TimeOnly>("EndTime")
+                        .HasColumnType("time without time zone");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<TimeOnly>("StartTime")
+                        .HasColumnType("time without time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Shifts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShipmentJudgment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("JudgedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("JudgedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("JudgmentNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int?>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("Result")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JudgedByUserId");
+
+                    b.HasIndex("JudgmentNo")
+                        .IsUnique();
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.ToTable("ShipmentJudgments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("ShippedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("ShippingOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.ToTable("ShippingLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Destination")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateOnly?>("PlannedDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset?>("ShippedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ShippedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShippingNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ShippingNo")
+                        .IsUnique();
+
+                    b.ToTable("ShippingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SkillMaster", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<bool>("RequiresExpiry")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Skills", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("FinalizedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FinalizedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("StocktakeNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int?>("TargetLocationId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StocktakeNo")
+                        .IsUnique();
+
+                    b.HasIndex("TargetLocationId");
+
+                    b.ToTable("Stocktakes");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.StocktakeLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal?>("CountedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<bool>("IsAdjusted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("StocktakeId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("TheoreticalQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("StocktakeId");
+
+                    b.ToTable("StocktakeLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Tool", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LifeResetAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("LifeThresholdCount")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("LifeThresholdHours")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("ToolType")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Tools");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolIssue", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("AllocatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("AllocatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("IssuedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("IssuedToUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<DateTimeOffset?>("ReturnedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ReturnedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ToolId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IssuedToUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.HasIndex("ToolId", "Status");
+
+                    b.ToTable("ToolIssues");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolUsage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ToolId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("UsageCount")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("UsageHours")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ToolId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ToolUsages");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TransferOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("ExecutedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ExecutedByUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("FromLocationId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int>("ToLocationId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FromLocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("ToLocationId");
+
+                    b.ToTable("TransferOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TroubleReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ReportedByUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ResponseHistory")
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("ReportedByUserId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("TroubleReports");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.UserSkill", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly?>("AcquiredOn")
+                        .HasColumnType("date");
+
+                    b.Property<DateOnly?>("ExpiresOn")
+                        .HasColumnType("date");
+
+                    b.Property<int>("SkillId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SkillId");
+
+                    b.HasIndex("UserId", "SkillId")
+                        .IsUnique();
+
+                    b.ToTable("UserSkills");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkCenter", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Level")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int?>("ParentId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("WorkCenters");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AssignedEquipmentId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AssignedUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ControlItems")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("DispatchOrder")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ManufacturingOrderId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("RequiredSkillId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("RoutingChecklistId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RoutingSequence")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("StandardSetupMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal>("StandardWorkMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("WorkOrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int?>("WorkProcedureId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("WorkProcedureVersion")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignedEquipmentId");
+
+                    b.HasIndex("AssignedUserId");
+
+                    b.HasIndex("ManufacturingOrderId");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("RequiredSkillId");
+
+                    b.HasIndex("RoutingChecklistId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("WorkOrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("WorkProcedureId");
+
+                    b.ToTable("WorkOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("ControlItemId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ItemCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ItemName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("ItemVersion")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<decimal?>("TargetValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<string>("Unit")
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("numeric(18,6)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ControlItemId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("WorkOrderControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderStatusHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("ChangedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ChangedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.Property<string>("FromStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("ToStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChangedByUserId");
+
+                    b.HasIndex("WorkOrderId", "Id");
+
+                    b.ToTable("WorkOrderStatusHistories");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkProcedure", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ProcedureNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Steps")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcedureNo")
+                        .IsUnique();
+
+                    b.ToTable("WorkProcedures");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkTimeRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("IndirectCategory")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("character varying(30)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.HasIndex("UserId", "StartedAt");
+
+                    b.ToTable("WorkTimeRecords");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.AppUser", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Shift", "Shift")
+                        .WithMany()
+                        .HasForeignKey("ShiftId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Shift");
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.BomItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "ChildProduct")
+                        .WithMany()
+                        .HasForeignKey("ChildProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "ParentProduct")
+                        .WithMany()
+                        .HasForeignKey("ParentProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildProduct");
+
+                    b.Navigation("ParentProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", null)
+                        .WithMany("Items")
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", "Checklist")
+                        .WithMany()
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Checklist");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistResultItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ChecklistItem", "ChecklistItem")
+                        .WithMany()
+                        .HasForeignKey("ChecklistItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ChecklistRecord", null)
+                        .WithMany("Results")
+                        .HasForeignKey("ChecklistRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChecklistItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentLog", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentPart", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany("Parts")
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDeviceCalibration", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionDevice", "InspectionDevice")
+                        .WithMany()
+                        .HasForeignKey("InspectionDeviceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("InspectionDevice");
+
+                    b.Navigation("PerformedBy");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "TargetProcess")
+                        .WithMany()
+                        .HasForeignKey("TargetProcessId");
+
+                    b.HasOne("MesApp.Core.Entities.Product", "TargetProduct")
+                        .WithMany()
+                        .HasForeignKey("TargetProductId");
+
+                    b.Navigation("TargetProcess");
+
+                    b.Navigation("TargetProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "RequestedBy")
+                        .WithMany()
+                        .HasForeignKey("RequestedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "TargetLot")
+                        .WithMany()
+                        .HasForeignKey("TargetLotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "TargetWorkOrder")
+                        .WithMany()
+                        .HasForeignKey("TargetWorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("RequestedBy");
+
+                    b.Navigation("TargetLot");
+
+                    b.Navigation("TargetWorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrderItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionItem", "InspectionItem")
+                        .WithMany()
+                        .HasForeignKey("InspectionItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", null)
+                        .WithMany("Items")
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResult", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "InspectedBy")
+                        .WithMany()
+                        .HasForeignKey("InspectedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionDevice", "InspectionDevice")
+                        .WithMany()
+                        .HasForeignKey("InspectionDeviceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.InspectionItem", "InspectionItem")
+                        .WithMany()
+                        .HasForeignKey("InspectionItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", null)
+                        .WithMany("Results")
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectedBy");
+
+                    b.Navigation("InspectionDevice");
+
+                    b.Navigation("InspectionItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResultCorrection", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CorrectedBy")
+                        .WithMany()
+                        .HasForeignKey("CorrectedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.InspectionResult", "InspectionResult")
+                        .WithMany()
+                        .HasForeignKey("InspectionResultId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CorrectedBy");
+
+                    b.Navigation("InspectionResult");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryStock", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryTransaction", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "FromLocation")
+                        .WithMany()
+                        .HasForeignKey("FromLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "ToLocation")
+                        .WithMany()
+                        .HasForeignKey("ToLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("FromLocation");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("ToLocation");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Location", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Lot", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "ParentLot")
+                        .WithMany()
+                        .HasForeignKey("ParentLotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "SourceWorkOrder")
+                        .WithMany()
+                        .HasForeignKey("SourceWorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("ParentLot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("SourceWorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotGenealogy", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "ChildLot")
+                        .WithMany()
+                        .HasForeignKey("ChildLotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "ParentLot")
+                        .WithMany()
+                        .HasForeignKey("ParentLotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ChildLot");
+
+                    b.Navigation("ParentLot");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotStatusHistory", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Lot");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.MaintenancePlan", "MaintenancePlan")
+                        .WithMany()
+                        .HasForeignKey("MaintenancePlanId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.MaintenanceProcedure", "Procedure")
+                        .WithMany()
+                        .HasForeignKey("ProcedureId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("MaintenancePlan");
+
+                    b.Navigation("Procedure");
+
+                    b.Navigation("Tool");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenancePlan", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceProcedure", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "TargetEquipment")
+                        .WithMany()
+                        .HasForeignKey("TargetEquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "TargetTool")
+                        .WithMany()
+                        .HasForeignKey("TargetToolId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("TargetEquipment");
+
+                    b.Navigation("TargetTool");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.MaintenanceOrder", null)
+                        .WithMany("Records")
+                        .HasForeignKey("MaintenanceOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("PerformedBy");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecordPart", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.MaintenanceRecord", null)
+                        .WithMany("Parts")
+                        .HasForeignKey("MaintenanceRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "OutputLot")
+                        .WithMany()
+                        .HasForeignKey("OutputLotId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "SourceOrder")
+                        .WithMany()
+                        .HasForeignKey("SourceOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("OutputLot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("SourceOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrderMaterial", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "ChildProduct")
+                        .WithMany()
+                        .HasForeignKey("ChildProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ManufacturingOrder")
+                        .WithMany("Materials")
+                        .HasForeignKey("ManufacturingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildProduct");
+
+                    b.Navigation("ManufacturingOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaterialConsumption", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NonconformanceReport", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", "InspectionOrder")
+                        .WithMany()
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ReportedBy")
+                        .WithMany()
+                        .HasForeignKey("ReportedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ReworkOrder")
+                        .WithMany()
+                        .HasForeignKey("ReworkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("InspectionOrder");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ReportedBy");
+
+                    b.Navigation("ReworkOrder");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.PickingOrder", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("PickingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", "ShippingOrder")
+                        .WithMany()
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("ShippingOrder");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Product", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "DefaultLocation")
+                        .WithMany()
+                        .HasForeignKey("DefaultLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDataRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkOrderControlItem", "WorkOrderControlItem")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WorkOrder");
+
+                    b.Navigation("WorkOrderControlItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDefect", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.DefectReason", "DefectReason")
+                        .WithMany()
+                        .HasForeignKey("DefectReasonId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ProductionRecord", "ProductionRecord")
+                        .WithMany("Defects")
+                        .HasForeignKey("ProductionRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DefectReason");
+
+                    b.Navigation("ProductionRecord");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionPlan", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "OutputLot")
+                        .WithMany()
+                        .HasForeignKey("OutputLotId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Shift", "Shift")
+                        .WithMany()
+                        .HasForeignKey("ShiftId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OutputLot");
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("Shift");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecordCorrection", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CorrectedBy")
+                        .WithMany()
+                        .HasForeignKey("CorrectedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.ProductionRecord", "ProductionRecord")
+                        .WithMany()
+                        .HasForeignKey("ProductionRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CorrectedBy");
+
+                    b.Navigation("ProductionRecord");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RefreshToken", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", "Checklist")
+                        .WithMany()
+                        .HasForeignKey("ChecklistId");
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId");
+
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "RequiredSkill")
+                        .WithMany()
+                        .HasForeignKey("RequiredSkillId");
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId");
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkProcedure", "WorkProcedure")
+                        .WithMany()
+                        .HasForeignKey("WorkProcedureId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Checklist");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("RequiredSkill");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkCenter");
+
+                    b.Navigation("WorkProcedure");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ControlItem", "ControlItem")
+                        .WithMany()
+                        .HasForeignKey("ControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Routing", "Routing")
+                        .WithMany("ControlItemLinks")
+                        .HasForeignKey("RoutingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ControlItem");
+
+                    b.Navigation("Routing");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Routing", "Routing")
+                        .WithMany("EquipmentCandidates")
+                        .HasForeignKey("RoutingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Routing");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SampleStorage", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", "InspectionOrder")
+                        .WithMany()
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "StorageLocation")
+                        .WithMany()
+                        .HasForeignKey("StorageLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("InspectionOrder");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("StorageLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SetupRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShipmentJudgment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "JudgedBy")
+                        .WithMany()
+                        .HasForeignKey("JudgedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", "ShippingOrder")
+                        .WithMany()
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("JudgedBy");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ShippingOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "TargetLocation")
+                        .WithMany()
+                        .HasForeignKey("TargetLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("TargetLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.StocktakeLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Stocktake", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("StocktakeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolIssue", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "IssuedTo")
+                        .WithMany()
+                        .HasForeignKey("IssuedToUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("IssuedTo");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolUsage", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TransferOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "FromLocation")
+                        .WithMany()
+                        .HasForeignKey("FromLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "ToLocation")
+                        .WithMany()
+                        .HasForeignKey("ToLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("FromLocation");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ToLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TroubleReport", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ReportedBy")
+                        .WithMany()
+                        .HasForeignKey("ReportedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("ReportedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.UserSkill", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "Skill")
+                        .WithMany()
+                        .HasForeignKey("SkillId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Skill");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkCenter", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "Parent")
+                        .WithMany()
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "AssignedEquipment")
+                        .WithMany()
+                        .HasForeignKey("AssignedEquipmentId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "AssignedUser")
+                        .WithMany()
+                        .HasForeignKey("AssignedUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ManufacturingOrder")
+                        .WithMany("WorkOrders")
+                        .HasForeignKey("ManufacturingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "RequiredSkill")
+                        .WithMany()
+                        .HasForeignKey("RequiredSkillId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Checklist", "RoutingChecklist")
+                        .WithMany()
+                        .HasForeignKey("RoutingChecklistId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkProcedure", "WorkProcedure")
+                        .WithMany()
+                        .HasForeignKey("WorkProcedureId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("AssignedEquipment");
+
+                    b.Navigation("AssignedUser");
+
+                    b.Navigation("ManufacturingOrder");
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("RequiredSkill");
+
+                    b.Navigation("RoutingChecklist");
+
+                    b.Navigation("WorkCenter");
+
+                    b.Navigation("WorkProcedure");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ControlItem", "ControlItem")
+                        .WithMany()
+                        .HasForeignKey("ControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany("ControlItemSnapshots")
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ControlItem");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderStatusHistory", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ChangedBy")
+                        .WithMany()
+                        .HasForeignKey("ChangedByUserId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChangedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkTimeRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Checklist", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.Navigation("Results");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.Navigation("Parts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("Results");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.Navigation("Records");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.Navigation("Parts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.Navigation("Materials");
+
+                    b.Navigation("WorkOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.Navigation("Defects");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.Navigation("ControlItemLinks");
+
+                    b.Navigation("EquipmentCandidates");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.Navigation("ControlItemSnapshots");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/MesApp.Migrations.PostgreSql/Migrations/20260923081741_LinkControlItemsToRouting.cs b/src/MesApp.Migrations.PostgreSql/Migrations/20260923081741_LinkControlItemsToRouting.cs
new file mode 100644
index 0000000..bb7773e
--- /dev/null
+++ b/src/MesApp.Migrations.PostgreSql/Migrations/20260923081741_LinkControlItemsToRouting.cs
@@ -0,0 +1,119 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace MesApp.Migrations.PostgreSql.Migrations
+{
+    /// <inheritdoc />
+    public partial class LinkControlItemsToRouting : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ControlItems_Processes_TargetProcessId",
+                table: "ControlItems");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_ControlItems_Products_TargetProductId",
+                table: "ControlItems");
+
+            migrationBuilder.DropIndex(
+                name: "IX_ControlItems_TargetProcessId",
+                table: "ControlItems");
+
+            migrationBuilder.DropIndex(
+                name: "IX_ControlItems_TargetProductId",
+                table: "ControlItems");
+
+            migrationBuilder.DropColumn(
+                name: "TargetProcessId",
+                table: "ControlItems");
+
+            migrationBuilder.DropColumn(
+                name: "TargetProductId",
+                table: "ControlItems");
+
+            migrationBuilder.CreateTable(
+                name: "RoutingControlItems",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    RoutingId = table.Column<int>(type: "integer", nullable: false),
+                    ControlItemId = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_RoutingControlItems", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_RoutingControlItems_ControlItems_ControlItemId",
+                        column: x => x.ControlItemId,
+                        principalTable: "ControlItems",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_RoutingControlItems_Routings_RoutingId",
+                        column: x => x.RoutingId,
+                        principalTable: "Routings",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_RoutingControlItems_ControlItemId",
+                table: "RoutingControlItems",
+                column: "ControlItemId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_RoutingControlItems_RoutingId_ControlItemId",
+                table: "RoutingControlItems",
+                columns: new[] { "RoutingId", "ControlItemId" },
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "RoutingControlItems");
+
+            migrationBuilder.AddColumn<int>(
+                name: "TargetProcessId",
+                table: "ControlItems",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "TargetProductId",
+                table: "ControlItems",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ControlItems_TargetProcessId",
+                table: "ControlItems",
+                column: "TargetProcessId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ControlItems_TargetProductId",
+                table: "ControlItems",
+                column: "TargetProductId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ControlItems_Processes_TargetProcessId",
+                table: "ControlItems",
+                column: "TargetProcessId",
+                principalTable: "Processes",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ControlItems_Products_TargetProductId",
+                table: "ControlItems",
+                column: "TargetProductId",
+                principalTable: "Products",
+                principalColumn: "Id");
+        }
+    }
+}
diff --git a/src/MesApp.Migrations.PostgreSql/Migrations/MesAppDbContextModelSnapshot.cs b/src/MesApp.Migrations.PostgreSql/Migrations/MesAppDbContextModelSnapshot.cs
index 6d6b506..e6882d5 100644
--- a/src/MesApp.Migrations.PostgreSql/Migrations/MesAppDbContextModelSnapshot.cs
+++ b/src/MesApp.Migrations.PostgreSql/Migrations/MesAppDbContextModelSnapshot.cs
@@ -370,12 +370,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasMaxLength(200)
                         .HasColumnType("character varying(200)");
 
-                    b.Property<int?>("TargetProcessId")
-                        .HasColumnType("integer");
-
-                    b.Property<int?>("TargetProductId")
-                        .HasColumnType("integer");
-
                     b.Property<decimal?>("TargetValue")
                         .HasPrecision(18, 6)
                         .HasColumnType("numeric(18,6)");
@@ -396,10 +390,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.HasIndex("Code")
                         .IsUnique();
 
-                    b.HasIndex("TargetProcessId");
-
-                    b.HasIndex("TargetProductId");
-
                     b.ToTable("ControlItems");
                 });
 
@@ -2367,6 +2357,30 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Routings");
                 });
 
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ControlItemId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RoutingId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ControlItemId");
+
+                    b.HasIndex("RoutingId", "ControlItemId")
+                        .IsUnique();
+
+                    b.ToTable("RoutingControlItems");
+                });
+
             modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
                 {
                     b.Property<int>("Id")
@@ -3122,8 +3136,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("text");
 
                     b.Property<string>("ControlItems")
-                        .HasMaxLength(500)
-                        .HasColumnType("character varying(500)");
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
 
                     b.Property<DateTimeOffset>("CreatedAt")
                         .HasColumnType("timestamp with time zone");
@@ -3617,21 +3631,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("ChecklistItem");
                 });
 
-            modelBuilder.Entity("MesApp.Core.Entities.ControlItem", b =>
-                {
-                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "TargetProcess")
-                        .WithMany()
-                        .HasForeignKey("TargetProcessId");
-
-                    b.HasOne("MesApp.Core.Entities.Product", "TargetProduct")
-                        .WithMany()
-                        .HasForeignKey("TargetProductId");
-
-                    b.Navigation("TargetProcess");
-
-                    b.Navigation("TargetProduct");
-                });
-
             modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
                 {
                     b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
@@ -4417,6 +4416,25 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("WorkProcedure");
                 });
 
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ControlItem", "ControlItem")
+                        .WithMany()
+                        .HasForeignKey("ControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Routing", "Routing")
+                        .WithMany("ControlItemLinks")
+                        .HasForeignKey("RoutingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ControlItem");
+
+                    b.Navigation("Routing");
+                });
+
             modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
                 {
                     b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
@@ -4924,6 +4942,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
             modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
                 {
+                    b.Navigation("ControlItemLinks");
+
                     b.Navigation("EquipmentCandidates");
                 });
 
diff --git a/src/MesApp.Migrations.SqlServer/Migrations/20260923080830_WidenWorkOrderControlItems.Designer.cs b/src/MesApp.Migrations.SqlServer/Migrations/20260923080830_WidenWorkOrderControlItems.Designer.cs
new file mode 100644
index 0000000..2d43211
--- /dev/null
+++ b/src/MesApp.Migrations.SqlServer/Migrations/20260923080830_WidenWorkOrderControlItems.Designer.cs
@@ -0,0 +1,4929 @@
+// <auto-generated />
+using System;
+using MesApp.Infrastructure;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace MesApp.Migrations.SqlServer.Migrations
+{
+    [DbContext(typeof(MesAppDbContext))]
+    [Migration("20260923080830_WidenWorkOrderControlItems")]
+    partial class WidenWorkOrderControlItems
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.10")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("MesApp.Core.Entities.AppUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("Department")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<bool>("MustChangePassword")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("ShiftId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex")
+                        .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+                    b.HasIndex("ShiftId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.AuditLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Detail")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("IpAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly>("RecordedOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("TargetId")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("TargetType")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("UserName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RecordedOn");
+
+                    b.HasIndex("Timestamp");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("Category", "Action");
+
+                    b.HasIndex("TargetType", "TargetId");
+
+                    b.ToTable("AuditLogs");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.BomItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlternativeGroup")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int>("ChildProductId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsAlternative")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("MakeOrBuy")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int>("ParentProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("RoutingSequence")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildProductId");
+
+                    b.HasIndex("ParentProductId", "ChildProductId")
+                        .IsUnique();
+
+                    b.ToTable("BomItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Checklist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Checklists");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsRequired")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.ToTable("ChecklistItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("PerformedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ChecklistRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistResultItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ChecklistRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsChecked")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistItemId");
+
+                    b.HasIndex("ChecklistRecordId");
+
+                    b.ToTable("ChecklistResultItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int?>("TargetProcessId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TargetProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("TargetValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Unit")
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("TargetProcessId");
+
+                    b.HasIndex("TargetProductId");
+
+                    b.ToTable("ControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.DefectReason", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("DefectReasons");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("MaintenanceParts")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<decimal?>("MaintenanceThreshold")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("MaintenanceType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Site")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetNo")
+                        .IsUnique();
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("Equipments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("StopCause")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("EquipmentLogs");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentPart", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("EquipmentId", "ProductId")
+                        .IsUnique();
+
+                    b.ToTable("EquipmentParts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDevice", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly?>("CalibratedOn")
+                        .HasColumnType("date");
+
+                    b.Property<int?>("CalibrationCycleDays")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly?>("CalibrationDueOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Location")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("SerialNo")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("InspectionDevices");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDeviceCalibration", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly>("CalibratedOn")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("InspectionDeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly?>("NextDueOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("InspectionDeviceId", "CalibratedOn");
+
+                    b.ToTable("InspectionDeviceCalibrations");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Method")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int?>("SamplingCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("StandardValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("TargetProcessId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TargetProductId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("TargetProcessId");
+
+                    b.HasIndex("TargetProductId");
+
+                    b.ToTable("InspectionItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("JudgedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("JudgedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("OverallJudgment")
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("RequestedByUserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("TargetLotId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TargetWorkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedByUserId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("TargetLotId");
+
+                    b.HasIndex("TargetWorkOrderId");
+
+                    b.ToTable("InspectionOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrderItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("InspectionItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ItemCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("ItemName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("ItemVersion")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Method")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int?>("SamplingCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("StandardValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionItemId");
+
+                    b.HasIndex("InspectionOrderId", "InspectionItemId")
+                        .IsUnique();
+
+                    b.ToTable("InspectionOrderItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResult", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CorrectionNote")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<DateTimeOffset>("InspectedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("InspectedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int?>("InspectionDeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InspectionItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Judgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal?>("MeasuredValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("SampleNo")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectedByUserId");
+
+                    b.HasIndex("InspectionDeviceId");
+
+                    b.HasIndex("InspectionItemId");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.ToTable("InspectionResults");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResultCorrection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AfterJudgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal?>("AfterMeasuredValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("AfterTextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("BeforeJudgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal?>("BeforeMeasuredValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("BeforeTextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<DateTimeOffset>("CorrectedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CorrectedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InspectionResultId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrectedByUserId");
+
+                    b.HasIndex("InspectionResultId");
+
+                    b.HasIndex("InspectionOrderId", "Id");
+
+                    b.ToTable("InspectionResultCorrections");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryStock", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("nvarchar(32)");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId", "LocationId")
+                        .IsUnique();
+
+                    b.HasIndex("ProductId", "LocationId");
+
+                    b.ToTable("InventoryStocks");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryTransaction", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("FromLocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("PickingOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("ToLocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FromLocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("Timestamp");
+
+                    b.HasIndex("ToLocationId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("InventoryTransactions");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Location", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AreaType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ShelfNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Lot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateOnly?>("ExpiresOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Grade")
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal>("InitialQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("LotNumber")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("nvarchar(60)");
+
+                    b.Property<DateOnly?>("ManufacturedOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("OriginType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("ParentLotId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SourceWorkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StockStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LotNumber")
+                        .IsUnique();
+
+                    b.HasIndex("ParentLotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SourceWorkOrderId");
+
+                    b.ToTable("Lots");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotGenealogy", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChildLotId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("ParentLotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("RelationType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildLotId");
+
+                    b.HasIndex("ParentLotId");
+
+                    b.ToTable("LotGenealogies");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotStatusHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("ChangedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ChangedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("FromStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("NonconformanceReportId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("ToStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LotId", "Id");
+
+                    b.ToTable("LotStatusHistories");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MaintenancePlanId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int?>("ProcedureId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<DateOnly?>("ScheduledDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("ToolId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedByUserId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("MaintenancePlanId");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("ProcedureId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("ToolId");
+
+                    b.ToTable("MaintenanceOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenancePlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("CycleDays")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<int>("PlanYear")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly?>("ScheduledDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId", "PlanYear");
+
+                    b.ToTable("MaintenancePlans");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceProcedure", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ProcedureNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Steps")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<int?>("TargetEquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TargetToolId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcedureNo")
+                        .IsUnique();
+
+                    b.HasIndex("TargetEquipmentId");
+
+                    b.HasIndex("TargetToolId");
+
+                    b.ToTable("MaintenanceProcedures");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("MaintenanceOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("PartsUsed")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MaintenanceOrderId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.ToTable("MaintenanceRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecordPart", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MaintenanceRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("MaintenanceRecordId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("MaintenanceRecordParts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("OrderType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("OutputLotId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("SourceOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputLotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SourceOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("ManufacturingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrderMaterial", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlternativeGroup")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int>("ChildProductId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsAlternative")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("ManufacturingOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("RoutingSequence")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildProductId");
+
+                    b.HasIndex("ManufacturingOrderId", "ChildProductId")
+                        .IsUnique();
+
+                    b.ToTable("ManufacturingOrderMaterials");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaterialConsumption", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("ConsumedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<bool>("IsSubstitute")
+                        .HasColumnType("bit");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Method")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SubstituteReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("MaterialConsumptions");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NonconformanceReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Action")
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<DateTimeOffset?>("ActionCompletedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ActionCompletedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset?>("ActionInstructedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ActionInstructedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ActionInstruction")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("ActionRecord")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CauseCategory")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("CauseDetail")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ReportNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("ReportedByUserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int?>("ReworkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ReportNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReportedByUserId");
+
+                    b.HasIndex("ReworkOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("NonconformanceReports");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("LastValue")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Prefix")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("nvarchar(60)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Prefix")
+                        .IsUnique();
+
+                    b.ToTable("NumberSequences");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PickingOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("PickingOrderId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("PickingLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset?>("ExecutedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ExecutedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("PickingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProcessMaster", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Processes", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Product", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("DefaultLocationId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Specification")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<decimal>("StandardDefectRate")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Unit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("DefaultLocationId");
+
+                    b.ToTable("Products");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDataRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool?>("IsDeviation")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Item")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<decimal?>("NumericValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int?>("WorkOrderControlItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderControlItemId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ProductionDataRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDefect", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("DefectReasonId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("ProductionRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DefectReasonId");
+
+                    b.HasIndex("ProductionRecordId");
+
+                    b.ToTable("ProductionDefects");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionPlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("BusinessDate", "ProductId", "ProcessId", "WorkCenterId")
+                        .IsUnique()
+                        .HasFilter("[WorkCenterId] IS NOT NULL");
+
+                    b.ToTable("ProductionPlans");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<decimal>("DefectQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<decimal>("GoodQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("OutputLocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("OutputLotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<decimal>("ReworkQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("ScrapQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("ShiftId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OutputLotId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("ShiftId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ProductionRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecordCorrection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("AfterDefectQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("AfterGoodQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("AfterReworkQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("AfterScrapQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("BeforeDefectQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("BeforeGoodQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("BeforeReworkQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("BeforeScrapQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<DateTimeOffset>("CorrectedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CorrectedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("ProductionRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrectedByUserId");
+
+                    b.HasIndex("ProductionRecordId");
+
+                    b.HasIndex("WorkOrderId", "Id");
+
+                    b.ToTable("ProductionRecordCorrections");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RefreshToken", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("RevokedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TokenHash")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("ChecklistId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ControlItems")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RequiredSkillId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("StandardSetupMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("StandardWorkMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("ToolId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WorkProcedureId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("RequiredSkillId");
+
+                    b.HasIndex("ToolId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("WorkProcedureId");
+
+                    b.HasIndex("ProductId", "Sequence")
+                        .IsUnique();
+
+                    b.ToTable("Routings");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RoutingId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("RoutingId", "EquipmentId")
+                        .IsUnique();
+
+                    b.ToTable("RoutingEquipments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SampleStorage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClosedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly?>("ClosedOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("CollectedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly>("CollectedOn")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateOnly?>("RetainUntil")
+                        .HasColumnType("date");
+
+                    b.Property<string>("SampleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StorageLocationId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SampleNo")
+                        .IsUnique();
+
+                    b.HasIndex("StorageLocationId");
+
+                    b.HasIndex("Status", "RetainUntil");
+
+                    b.ToTable("SampleStorages");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SetupRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AbnormalityNote")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("SetupRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Shift", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<TimeOnly>("EndTime")
+                        .HasColumnType("time");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<TimeOnly>("StartTime")
+                        .HasColumnType("time");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Shifts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShipmentJudgment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("JudgedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("JudgedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("JudgmentNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int?>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("Result")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JudgedByUserId");
+
+                    b.HasIndex("JudgmentNo")
+                        .IsUnique();
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.ToTable("ShipmentJudgments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("ShippedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("ShippingOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.ToTable("ShippingLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Destination")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<DateOnly?>("PlannedDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset?>("ShippedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ShippedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ShippingNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ShippingNo")
+                        .IsUnique();
+
+                    b.ToTable("ShippingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SkillMaster", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<bool>("RequiresExpiry")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Skills", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset?>("FinalizedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("FinalizedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("StocktakeNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int?>("TargetLocationId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StocktakeNo")
+                        .IsUnique();
+
+                    b.HasIndex("TargetLocationId");
+
+                    b.ToTable("Stocktakes");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.StocktakeLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal?>("CountedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<bool>("IsAdjusted")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StocktakeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TheoreticalQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("StocktakeId");
+
+                    b.ToTable("StocktakeLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Tool", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LifeResetAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("LifeThresholdCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("LifeThresholdHours")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("ToolType")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Tools");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolIssue", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("AllocatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("AllocatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset?>("IssuedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("IssuedToUserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<DateTimeOffset?>("ReturnedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ReturnedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ToolId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IssuedToUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.HasIndex("ToolId", "Status");
+
+                    b.ToTable("ToolIssues");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolUsage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ToolId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UsageCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UsageHours")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ToolId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ToolUsages");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TransferOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset?>("ExecutedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ExecutedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("FromLocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int>("ToLocationId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FromLocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("ToLocationId");
+
+                    b.ToTable("TransferOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TroubleReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ReportedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ResponseHistory")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("ReportedByUserId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("TroubleReports");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.UserSkill", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly?>("AcquiredOn")
+                        .HasColumnType("date");
+
+                    b.Property<DateOnly?>("ExpiresOn")
+                        .HasColumnType("date");
+
+                    b.Property<int>("SkillId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SkillId");
+
+                    b.HasIndex("UserId", "SkillId")
+                        .IsUnique();
+
+                    b.ToTable("UserSkills");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkCenter", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Level")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int?>("ParentId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("WorkCenters");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AssignedEquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("AssignedUserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ControlItems")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("DispatchOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ManufacturingOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RequiredSkillId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RoutingChecklistId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RoutingSequence")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("StandardSetupMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("StandardWorkMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WorkOrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int?>("WorkProcedureId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WorkProcedureVersion")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignedEquipmentId");
+
+                    b.HasIndex("AssignedUserId");
+
+                    b.HasIndex("ManufacturingOrderId");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("RequiredSkillId");
+
+                    b.HasIndex("RoutingChecklistId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("WorkOrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("WorkProcedureId");
+
+                    b.ToTable("WorkOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("ControlItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ItemCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("ItemName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("ItemVersion")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal?>("TargetValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Unit")
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ControlItemId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("WorkOrderControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderStatusHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("ChangedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ChangedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("FromStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("ToStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChangedByUserId");
+
+                    b.HasIndex("WorkOrderId", "Id");
+
+                    b.ToTable("WorkOrderStatusHistories");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkProcedure", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ProcedureNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Steps")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcedureNo")
+                        .IsUnique();
+
+                    b.ToTable("WorkProcedures");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkTimeRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("IndirectCategory")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.HasIndex("UserId", "StartedAt");
+
+                    b.ToTable("WorkTimeRecords");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex")
+                        .HasFilter("[NormalizedName] IS NOT NULL");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.AppUser", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Shift", "Shift")
+                        .WithMany()
+                        .HasForeignKey("ShiftId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Shift");
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.BomItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "ChildProduct")
+                        .WithMany()
+                        .HasForeignKey("ChildProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "ParentProduct")
+                        .WithMany()
+                        .HasForeignKey("ParentProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildProduct");
+
+                    b.Navigation("ParentProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", null)
+                        .WithMany("Items")
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", "Checklist")
+                        .WithMany()
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Checklist");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistResultItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ChecklistItem", "ChecklistItem")
+                        .WithMany()
+                        .HasForeignKey("ChecklistItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ChecklistRecord", null)
+                        .WithMany("Results")
+                        .HasForeignKey("ChecklistRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChecklistItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "TargetProcess")
+                        .WithMany()
+                        .HasForeignKey("TargetProcessId");
+
+                    b.HasOne("MesApp.Core.Entities.Product", "TargetProduct")
+                        .WithMany()
+                        .HasForeignKey("TargetProductId");
+
+                    b.Navigation("TargetProcess");
+
+                    b.Navigation("TargetProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentLog", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentPart", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany("Parts")
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDeviceCalibration", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionDevice", "InspectionDevice")
+                        .WithMany()
+                        .HasForeignKey("InspectionDeviceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("InspectionDevice");
+
+                    b.Navigation("PerformedBy");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "TargetProcess")
+                        .WithMany()
+                        .HasForeignKey("TargetProcessId");
+
+                    b.HasOne("MesApp.Core.Entities.Product", "TargetProduct")
+                        .WithMany()
+                        .HasForeignKey("TargetProductId");
+
+                    b.Navigation("TargetProcess");
+
+                    b.Navigation("TargetProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "RequestedBy")
+                        .WithMany()
+                        .HasForeignKey("RequestedByUserId");
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "TargetLot")
+                        .WithMany()
+                        .HasForeignKey("TargetLotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "TargetWorkOrder")
+                        .WithMany()
+                        .HasForeignKey("TargetWorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("RequestedBy");
+
+                    b.Navigation("TargetLot");
+
+                    b.Navigation("TargetWorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrderItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionItem", "InspectionItem")
+                        .WithMany()
+                        .HasForeignKey("InspectionItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", null)
+                        .WithMany("Items")
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResult", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "InspectedBy")
+                        .WithMany()
+                        .HasForeignKey("InspectedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionDevice", "InspectionDevice")
+                        .WithMany()
+                        .HasForeignKey("InspectionDeviceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.InspectionItem", "InspectionItem")
+                        .WithMany()
+                        .HasForeignKey("InspectionItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", null)
+                        .WithMany("Results")
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectedBy");
+
+                    b.Navigation("InspectionDevice");
+
+                    b.Navigation("InspectionItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResultCorrection", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CorrectedBy")
+                        .WithMany()
+                        .HasForeignKey("CorrectedByUserId");
+
+                    b.HasOne("MesApp.Core.Entities.InspectionResult", "InspectionResult")
+                        .WithMany()
+                        .HasForeignKey("InspectionResultId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CorrectedBy");
+
+                    b.Navigation("InspectionResult");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryStock", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryTransaction", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "FromLocation")
+                        .WithMany()
+                        .HasForeignKey("FromLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "ToLocation")
+                        .WithMany()
+                        .HasForeignKey("ToLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("FromLocation");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("ToLocation");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Location", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Lot", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "ParentLot")
+                        .WithMany()
+                        .HasForeignKey("ParentLotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "SourceWorkOrder")
+                        .WithMany()
+                        .HasForeignKey("SourceWorkOrderId");
+
+                    b.Navigation("ParentLot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("SourceWorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotGenealogy", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "ChildLot")
+                        .WithMany()
+                        .HasForeignKey("ChildLotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "ParentLot")
+                        .WithMany()
+                        .HasForeignKey("ParentLotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ChildLot");
+
+                    b.Navigation("ParentLot");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotStatusHistory", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Lot");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedByUserId");
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.MaintenancePlan", "MaintenancePlan")
+                        .WithMany()
+                        .HasForeignKey("MaintenancePlanId");
+
+                    b.HasOne("MesApp.Core.Entities.MaintenanceProcedure", "Procedure")
+                        .WithMany()
+                        .HasForeignKey("ProcedureId");
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("MaintenancePlan");
+
+                    b.Navigation("Procedure");
+
+                    b.Navigation("Tool");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenancePlan", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceProcedure", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "TargetEquipment")
+                        .WithMany()
+                        .HasForeignKey("TargetEquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "TargetTool")
+                        .WithMany()
+                        .HasForeignKey("TargetToolId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("TargetEquipment");
+
+                    b.Navigation("TargetTool");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.MaintenanceOrder", null)
+                        .WithMany("Records")
+                        .HasForeignKey("MaintenanceOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("PerformedBy");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecordPart", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.MaintenanceRecord", null)
+                        .WithMany("Parts")
+                        .HasForeignKey("MaintenanceRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "OutputLot")
+                        .WithMany()
+                        .HasForeignKey("OutputLotId");
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "SourceOrder")
+                        .WithMany()
+                        .HasForeignKey("SourceOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("OutputLot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("SourceOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrderMaterial", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "ChildProduct")
+                        .WithMany()
+                        .HasForeignKey("ChildProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ManufacturingOrder")
+                        .WithMany("Materials")
+                        .HasForeignKey("ManufacturingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildProduct");
+
+                    b.Navigation("ManufacturingOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaterialConsumption", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NonconformanceReport", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", "InspectionOrder")
+                        .WithMany()
+                        .HasForeignKey("InspectionOrderId");
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ReportedBy")
+                        .WithMany()
+                        .HasForeignKey("ReportedByUserId");
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ReworkOrder")
+                        .WithMany()
+                        .HasForeignKey("ReworkOrderId");
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("InspectionOrder");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ReportedBy");
+
+                    b.Navigation("ReworkOrder");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.PickingOrder", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("PickingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", "ShippingOrder")
+                        .WithMany()
+                        .HasForeignKey("ShippingOrderId");
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("ShippingOrder");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Product", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "DefaultLocation")
+                        .WithMany()
+                        .HasForeignKey("DefaultLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDataRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkOrderControlItem", "WorkOrderControlItem")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WorkOrder");
+
+                    b.Navigation("WorkOrderControlItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDefect", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.DefectReason", "DefectReason")
+                        .WithMany()
+                        .HasForeignKey("DefectReasonId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ProductionRecord", "ProductionRecord")
+                        .WithMany("Defects")
+                        .HasForeignKey("ProductionRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DefectReason");
+
+                    b.Navigation("ProductionRecord");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionPlan", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "OutputLot")
+                        .WithMany()
+                        .HasForeignKey("OutputLotId");
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Shift", "Shift")
+                        .WithMany()
+                        .HasForeignKey("ShiftId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OutputLot");
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("Shift");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecordCorrection", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CorrectedBy")
+                        .WithMany()
+                        .HasForeignKey("CorrectedByUserId");
+
+                    b.HasOne("MesApp.Core.Entities.ProductionRecord", "ProductionRecord")
+                        .WithMany()
+                        .HasForeignKey("ProductionRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CorrectedBy");
+
+                    b.Navigation("ProductionRecord");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RefreshToken", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", "Checklist")
+                        .WithMany()
+                        .HasForeignKey("ChecklistId");
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId");
+
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "RequiredSkill")
+                        .WithMany()
+                        .HasForeignKey("RequiredSkillId");
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId");
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkProcedure", "WorkProcedure")
+                        .WithMany()
+                        .HasForeignKey("WorkProcedureId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Checklist");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("RequiredSkill");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkCenter");
+
+                    b.Navigation("WorkProcedure");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Routing", "Routing")
+                        .WithMany("EquipmentCandidates")
+                        .HasForeignKey("RoutingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Routing");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SampleStorage", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", "InspectionOrder")
+                        .WithMany()
+                        .HasForeignKey("InspectionOrderId");
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "StorageLocation")
+                        .WithMany()
+                        .HasForeignKey("StorageLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("InspectionOrder");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("StorageLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SetupRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShipmentJudgment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "JudgedBy")
+                        .WithMany()
+                        .HasForeignKey("JudgedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", "ShippingOrder")
+                        .WithMany()
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("JudgedBy");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ShippingOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "TargetLocation")
+                        .WithMany()
+                        .HasForeignKey("TargetLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("TargetLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.StocktakeLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Stocktake", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("StocktakeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolIssue", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "IssuedTo")
+                        .WithMany()
+                        .HasForeignKey("IssuedToUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("IssuedTo");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolUsage", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TransferOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "FromLocation")
+                        .WithMany()
+                        .HasForeignKey("FromLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "ToLocation")
+                        .WithMany()
+                        .HasForeignKey("ToLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("FromLocation");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ToLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TroubleReport", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId");
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ReportedBy")
+                        .WithMany()
+                        .HasForeignKey("ReportedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("ReportedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.UserSkill", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "Skill")
+                        .WithMany()
+                        .HasForeignKey("SkillId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Skill");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkCenter", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "Parent")
+                        .WithMany()
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "AssignedEquipment")
+                        .WithMany()
+                        .HasForeignKey("AssignedEquipmentId");
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "AssignedUser")
+                        .WithMany()
+                        .HasForeignKey("AssignedUserId");
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ManufacturingOrder")
+                        .WithMany("WorkOrders")
+                        .HasForeignKey("ManufacturingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "RequiredSkill")
+                        .WithMany()
+                        .HasForeignKey("RequiredSkillId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Checklist", "RoutingChecklist")
+                        .WithMany()
+                        .HasForeignKey("RoutingChecklistId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkProcedure", "WorkProcedure")
+                        .WithMany()
+                        .HasForeignKey("WorkProcedureId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("AssignedEquipment");
+
+                    b.Navigation("AssignedUser");
+
+                    b.Navigation("ManufacturingOrder");
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("RequiredSkill");
+
+                    b.Navigation("RoutingChecklist");
+
+                    b.Navigation("WorkCenter");
+
+                    b.Navigation("WorkProcedure");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ControlItem", "ControlItem")
+                        .WithMany()
+                        .HasForeignKey("ControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany("ControlItemSnapshots")
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ControlItem");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderStatusHistory", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ChangedBy")
+                        .WithMany()
+                        .HasForeignKey("ChangedByUserId");
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChangedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkTimeRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Checklist", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.Navigation("Results");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.Navigation("Parts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("Results");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.Navigation("Records");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.Navigation("Parts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.Navigation("Materials");
+
+                    b.Navigation("WorkOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.Navigation("Defects");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.Navigation("EquipmentCandidates");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.Navigation("ControlItemSnapshots");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/MesApp.Migrations.SqlServer/Migrations/20260923080830_WidenWorkOrderControlItems.cs b/src/MesApp.Migrations.SqlServer/Migrations/20260923080830_WidenWorkOrderControlItems.cs
new file mode 100644
index 0000000..fceb2b9
--- /dev/null
+++ b/src/MesApp.Migrations.SqlServer/Migrations/20260923080830_WidenWorkOrderControlItems.cs
@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MesApp.Migrations.SqlServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class WidenWorkOrderControlItems : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "ControlItems",
+                table: "WorkOrders",
+                type: "nvarchar(1000)",
+                maxLength: 1000,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(500)",
+                oldMaxLength: 500,
+                oldNullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterColumn<string>(
+                name: "ControlItems",
+                table: "WorkOrders",
+                type: "nvarchar(500)",
+                maxLength: 500,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(1000)",
+                oldMaxLength: 1000,
+                oldNullable: true);
+        }
+    }
+}
diff --git a/src/MesApp.Migrations.SqlServer/Migrations/20260923081743_LinkControlItemsToRouting.Designer.cs b/src/MesApp.Migrations.SqlServer/Migrations/20260923081743_LinkControlItemsToRouting.Designer.cs
new file mode 100644
index 0000000..8334649
--- /dev/null
+++ b/src/MesApp.Migrations.SqlServer/Migrations/20260923081743_LinkControlItemsToRouting.Designer.cs
@@ -0,0 +1,4949 @@
+// <auto-generated />
+using System;
+using MesApp.Infrastructure;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace MesApp.Migrations.SqlServer.Migrations
+{
+    [DbContext(typeof(MesAppDbContext))]
+    [Migration("20260923081743_LinkControlItemsToRouting")]
+    partial class LinkControlItemsToRouting
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.10")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("MesApp.Core.Entities.AppUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("Department")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<bool>("MustChangePassword")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("ShiftId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex")
+                        .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+                    b.HasIndex("ShiftId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.AuditLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Detail")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("IpAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly>("RecordedOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("TargetId")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("TargetType")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("UserName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RecordedOn");
+
+                    b.HasIndex("Timestamp");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("Category", "Action");
+
+                    b.HasIndex("TargetType", "TargetId");
+
+                    b.ToTable("AuditLogs");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.BomItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlternativeGroup")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int>("ChildProductId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsAlternative")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("MakeOrBuy")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int>("ParentProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("RoutingSequence")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildProductId");
+
+                    b.HasIndex("ParentProductId", "ChildProductId")
+                        .IsUnique();
+
+                    b.ToTable("BomItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Checklist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Checklists");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsRequired")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Text")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.ToTable("ChecklistItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("PerformedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ChecklistRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistResultItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChecklistItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ChecklistRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsChecked")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistItemId");
+
+                    b.HasIndex("ChecklistRecordId");
+
+                    b.ToTable("ChecklistResultItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<decimal?>("TargetValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Unit")
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("ControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.DefectReason", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("DefectReasons");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("MaintenanceParts")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<decimal?>("MaintenanceThreshold")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("MaintenanceType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Site")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetNo")
+                        .IsUnique();
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("Equipments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("StopCause")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("EquipmentLogs");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentPart", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("EquipmentId", "ProductId")
+                        .IsUnique();
+
+                    b.ToTable("EquipmentParts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDevice", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly?>("CalibratedOn")
+                        .HasColumnType("date");
+
+                    b.Property<int?>("CalibrationCycleDays")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly?>("CalibrationDueOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Location")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("SerialNo")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("InspectionDevices");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDeviceCalibration", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly>("CalibratedOn")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("InspectionDeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly?>("NextDueOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("InspectionDeviceId", "CalibratedOn");
+
+                    b.ToTable("InspectionDeviceCalibrations");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Method")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int?>("SamplingCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("StandardValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("TargetProcessId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TargetProductId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("TargetProcessId");
+
+                    b.HasIndex("TargetProductId");
+
+                    b.ToTable("InspectionItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("JudgedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("JudgedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("OverallJudgment")
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("RequestedByUserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("TargetLotId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TargetWorkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("RequestedByUserId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("TargetLotId");
+
+                    b.HasIndex("TargetWorkOrderId");
+
+                    b.ToTable("InspectionOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrderItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("InspectionItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ItemCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("ItemName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("ItemVersion")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Method")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int?>("SamplingCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("StandardValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionItemId");
+
+                    b.HasIndex("InspectionOrderId", "InspectionItemId")
+                        .IsUnique();
+
+                    b.ToTable("InspectionOrderItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResult", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CorrectionNote")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<DateTimeOffset>("InspectedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("InspectedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int?>("InspectionDeviceId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InspectionItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Judgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal?>("MeasuredValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("SampleNo")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectedByUserId");
+
+                    b.HasIndex("InspectionDeviceId");
+
+                    b.HasIndex("InspectionItemId");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.ToTable("InspectionResults");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResultCorrection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AfterJudgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal?>("AfterMeasuredValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("AfterTextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("BeforeJudgment")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal?>("BeforeMeasuredValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("BeforeTextValue")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<DateTimeOffset>("CorrectedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CorrectedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("InspectionOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("InspectionResultId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrectedByUserId");
+
+                    b.HasIndex("InspectionResultId");
+
+                    b.HasIndex("InspectionOrderId", "Id");
+
+                    b.ToTable("InspectionResultCorrections");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryStock", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("nvarchar(32)");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId", "LocationId")
+                        .IsUnique();
+
+                    b.HasIndex("ProductId", "LocationId");
+
+                    b.ToTable("InventoryStocks");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryTransaction", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<int?>("FromLocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("PickingOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("ToLocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FromLocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("Timestamp");
+
+                    b.HasIndex("ToLocationId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("InventoryTransactions");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Location", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AreaType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ShelfNo")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Lot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateOnly?>("ExpiresOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Grade")
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal>("InitialQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("LotNumber")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("nvarchar(60)");
+
+                    b.Property<DateOnly?>("ManufacturedOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("OriginType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("ParentLotId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SourceWorkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StockStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LotNumber")
+                        .IsUnique();
+
+                    b.HasIndex("ParentLotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SourceWorkOrderId");
+
+                    b.ToTable("Lots");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotGenealogy", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ChildLotId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("ParentLotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PerformedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("RelationType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildLotId");
+
+                    b.HasIndex("ParentLotId");
+
+                    b.ToTable("LotGenealogies");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotStatusHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("ChangedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ChangedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("FromStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("NonconformanceReportId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("ToStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LotId", "Id");
+
+                    b.ToTable("LotStatusHistories");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MaintenancePlanId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int?>("ProcedureId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<DateOnly?>("ScheduledDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("ToolId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedByUserId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("MaintenancePlanId");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("ProcedureId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("ToolId");
+
+                    b.ToTable("MaintenanceOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenancePlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("CycleDays")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<int>("PlanYear")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly?>("ScheduledDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId", "PlanYear");
+
+                    b.ToTable("MaintenancePlans");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceProcedure", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ProcedureNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Steps")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<int?>("TargetEquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TargetToolId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcedureNo")
+                        .IsUnique();
+
+                    b.HasIndex("TargetEquipmentId");
+
+                    b.HasIndex("TargetToolId");
+
+                    b.ToTable("MaintenanceProcedures");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("MaintenanceOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("PartsUsed")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Result")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MaintenanceOrderId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.ToTable("MaintenanceRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecordPart", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MaintenanceRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("MaintenanceRecordId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("MaintenanceRecordParts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly?>("DueDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("OrderType")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("OutputLotId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("SourceOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("OutputLotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SourceOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("ManufacturingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrderMaterial", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlternativeGroup")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int>("ChildProductId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsAlternative")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("ManufacturingOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("QuantityPer")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("RoutingSequence")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildProductId");
+
+                    b.HasIndex("ManufacturingOrderId", "ChildProductId")
+                        .IsUnique();
+
+                    b.ToTable("ManufacturingOrderMaterials");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaterialConsumption", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("ConsumedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<bool>("IsSubstitute")
+                        .HasColumnType("bit");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Method")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SubstituteReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("MaterialConsumptions");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NonconformanceReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Action")
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<DateTimeOffset?>("ActionCompletedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ActionCompletedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset?>("ActionInstructedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ActionInstructedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ActionInstruction")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("ActionRecord")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CauseCategory")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("CauseDetail")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ReportNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("ReportedByUserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int?>("ReworkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ReportNo")
+                        .IsUnique();
+
+                    b.HasIndex("ReportedByUserId");
+
+                    b.HasIndex("ReworkOrderId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("NonconformanceReports");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NumberSequence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("LastValue")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Prefix")
+                        .IsRequired()
+                        .HasMaxLength(60)
+                        .HasColumnType("nvarchar(60)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Prefix")
+                        .IsUnique();
+
+                    b.ToTable("NumberSequences");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PickingOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("PickingOrderId");
+
+                    b.HasIndex("ProductId");
+
+                    b.ToTable("PickingLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset?>("ExecutedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ExecutedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("PickingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProcessMaster", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Processes", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Product", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("DefaultLocationId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Specification")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<decimal>("StandardDefectRate")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Unit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("DefaultLocationId");
+
+                    b.ToTable("Products");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDataRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool?>("IsDeviation")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Item")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<decimal?>("NumericValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int?>("WorkOrderControlItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderControlItemId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ProductionDataRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDefect", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("DefectReasonId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("ProductionRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DefectReasonId");
+
+                    b.HasIndex("ProductionRecordId");
+
+                    b.ToTable("ProductionDefects");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionPlan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly>("BusinessDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("BusinessDate", "ProductId", "ProcessId", "WorkCenterId")
+                        .IsUnique()
+                        .HasFilter("[WorkCenterId] IS NOT NULL");
+
+                    b.ToTable("ProductionPlans");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<decimal>("DefectQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<decimal>("GoodQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("OutputLocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("OutputLotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<decimal>("ReworkQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("ScrapQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("ShiftId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OutputLotId");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("ShiftId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ProductionRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecordCorrection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("AfterDefectQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("AfterGoodQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("AfterReworkQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("AfterScrapQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("BeforeDefectQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("BeforeGoodQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("BeforeReworkQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("BeforeScrapQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<DateTimeOffset>("CorrectedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CorrectedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("ProductionRecordId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrectedByUserId");
+
+                    b.HasIndex("ProductionRecordId");
+
+                    b.HasIndex("WorkOrderId", "Id");
+
+                    b.ToTable("ProductionRecordCorrections");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RefreshToken", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("RevokedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TokenHash")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("ChecklistId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ControlItems")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RequiredSkillId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("StandardSetupMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("StandardWorkMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("ToolId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WorkProcedureId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChecklistId");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("RequiredSkillId");
+
+                    b.HasIndex("ToolId");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("WorkProcedureId");
+
+                    b.HasIndex("ProductId", "Sequence")
+                        .IsUnique();
+
+                    b.ToTable("Routings");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ControlItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RoutingId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ControlItemId");
+
+                    b.HasIndex("RoutingId", "ControlItemId")
+                        .IsUnique();
+
+                    b.ToTable("RoutingControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RoutingId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("RoutingId", "EquipmentId")
+                        .IsUnique();
+
+                    b.ToTable("RoutingEquipments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SampleStorage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClosedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly?>("ClosedOn")
+                        .HasColumnType("date");
+
+                    b.Property<string>("CollectedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly>("CollectedOn")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("InspectionOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 4)
+                        .HasColumnType("decimal(18,4)");
+
+                    b.Property<DateOnly?>("RetainUntil")
+                        .HasColumnType("date");
+
+                    b.Property<string>("SampleNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StorageLocationId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionOrderId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("SampleNo")
+                        .IsUnique();
+
+                    b.HasIndex("StorageLocationId");
+
+                    b.HasIndex("Status", "RetainUntil");
+
+                    b.ToTable("SampleStorages");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SetupRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AbnormalityNote")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("PerformedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PerformedByUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("SetupRecords");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Shift", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<TimeOnly>("EndTime")
+                        .HasColumnType("time");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<TimeOnly>("StartTime")
+                        .HasColumnType("time");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Shifts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShipmentJudgment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("ApprovedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ApprovedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("JudgedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("JudgedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("JudgmentNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int?>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("Result")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("ShippingOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JudgedByUserId");
+
+                    b.HasIndex("JudgmentNo")
+                        .IsUnique();
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.ToTable("ShipmentJudgments");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("ShippedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("ShippingOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("ShippingOrderId");
+
+                    b.ToTable("ShippingLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Destination")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<DateOnly?>("PlannedDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateTimeOffset?>("ShippedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ShippedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ShippingNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ShippingNo")
+                        .IsUnique();
+
+                    b.ToTable("ShippingOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SkillMaster", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<bool>("RequiresExpiry")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Skills", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset?>("FinalizedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("FinalizedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("StocktakeNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int?>("TargetLocationId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StocktakeNo")
+                        .IsUnique();
+
+                    b.HasIndex("TargetLocationId");
+
+                    b.ToTable("Stocktakes");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.StocktakeLine", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal?>("CountedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<bool>("IsAdjusted")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StocktakeId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("TheoreticalQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("StocktakeId");
+
+                    b.ToTable("StocktakeLine");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Tool", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LifeResetAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("LifeThresholdCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("LifeThresholdHours")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("ToolType")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("Tools");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolIssue", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("AllocatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("AllocatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset?>("IssuedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("IssuedToUserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<DateTimeOffset?>("ReturnedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ReturnedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ToolId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IssuedToUserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.HasIndex("ToolId", "Status");
+
+                    b.ToTable("ToolIssues");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolUsage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("RecordedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ToolId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("UsageCount")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("UsageHours")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ToolId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("ToolUsages");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TransferOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("CreatedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset?>("ExecutedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ExecutedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("FromLocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("LotId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("Quantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int>("ToLocationId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FromLocationId");
+
+                    b.HasIndex("LotId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("ToLocationId");
+
+                    b.ToTable("TransferOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TroubleReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("EquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("OccurredAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ReportedByUserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ResponseHistory")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EquipmentId");
+
+                    b.HasIndex("ReportedByUserId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("TroubleReports");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.UserSkill", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateOnly?>("AcquiredOn")
+                        .HasColumnType("date");
+
+                    b.Property<DateOnly?>("ExpiresOn")
+                        .HasColumnType("date");
+
+                    b.Property<int>("SkillId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SkillId");
+
+                    b.HasIndex("UserId", "SkillId")
+                        .IsUnique();
+
+                    b.ToTable("UserSkills");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkCenter", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Level")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int?>("ParentId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("WorkCenters");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AssignedEquipmentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("AssignedUserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ControlItems")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int?>("DispatchOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ManufacturingOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("PlannedQuantity")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("ProcessId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RequiredSkillId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RoutingChecklistId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RoutingSequence")
+                        .HasColumnType("int");
+
+                    b.Property<decimal>("StandardSetupMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal>("StandardWorkMinutes")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int?>("WorkCenterId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WorkOrderNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int?>("WorkProcedureId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WorkProcedureVersion")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignedEquipmentId");
+
+                    b.HasIndex("AssignedUserId");
+
+                    b.HasIndex("ManufacturingOrderId");
+
+                    b.HasIndex("ProcessId");
+
+                    b.HasIndex("ProductId");
+
+                    b.HasIndex("RequiredSkillId");
+
+                    b.HasIndex("RoutingChecklistId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("WorkCenterId");
+
+                    b.HasIndex("WorkOrderNo")
+                        .IsUnique();
+
+                    b.HasIndex("WorkProcedureId");
+
+                    b.ToTable("WorkOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("ControlItemId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ItemCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("ItemName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("ItemVersion")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("LowerLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<decimal?>("TargetValue")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<string>("Unit")
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<decimal?>("UpperLimit")
+                        .HasPrecision(18, 6)
+                        .HasColumnType("decimal(18,6)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ControlItemId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("WorkOrderControlItems");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderStatusHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset>("ChangedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("ChangedByUserId")
+                        .HasMaxLength(450)
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("FromStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("ToStatus")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChangedByUserId");
+
+                    b.HasIndex("WorkOrderId", "Id");
+
+                    b.ToTable("WorkOrderStatusHistories");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkProcedure", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ProcedureNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Reference")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Steps")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProcedureNo")
+                        .IsUnique();
+
+                    b.ToTable("WorkProcedures");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkTimeRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("EndedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("IndirectCategory")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Note")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<DateTimeOffset>("StartedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(30)
+                        .HasColumnType("nvarchar(30)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.HasIndex("UserId", "StartedAt");
+
+                    b.ToTable("WorkTimeRecords");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex")
+                        .HasFilter("[NormalizedName] IS NOT NULL");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.AppUser", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Shift", "Shift")
+                        .WithMany()
+                        .HasForeignKey("ShiftId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Shift");
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.BomItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "ChildProduct")
+                        .WithMany()
+                        .HasForeignKey("ChildProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "ParentProduct")
+                        .WithMany()
+                        .HasForeignKey("ParentProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildProduct");
+
+                    b.Navigation("ParentProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", null)
+                        .WithMany("Items")
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", "Checklist")
+                        .WithMany()
+                        .HasForeignKey("ChecklistId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Checklist");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistResultItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ChecklistItem", "ChecklistItem")
+                        .WithMany()
+                        .HasForeignKey("ChecklistItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ChecklistRecord", null)
+                        .WithMany("Results")
+                        .HasForeignKey("ChecklistRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChecklistItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentLog", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.EquipmentPart", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany("Parts")
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionDeviceCalibration", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionDevice", "InspectionDevice")
+                        .WithMany()
+                        .HasForeignKey("InspectionDeviceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("InspectionDevice");
+
+                    b.Navigation("PerformedBy");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "TargetProcess")
+                        .WithMany()
+                        .HasForeignKey("TargetProcessId");
+
+                    b.HasOne("MesApp.Core.Entities.Product", "TargetProduct")
+                        .WithMany()
+                        .HasForeignKey("TargetProductId");
+
+                    b.Navigation("TargetProcess");
+
+                    b.Navigation("TargetProduct");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "RequestedBy")
+                        .WithMany()
+                        .HasForeignKey("RequestedByUserId");
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "TargetLot")
+                        .WithMany()
+                        .HasForeignKey("TargetLotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "TargetWorkOrder")
+                        .WithMany()
+                        .HasForeignKey("TargetWorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("RequestedBy");
+
+                    b.Navigation("TargetLot");
+
+                    b.Navigation("TargetWorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrderItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionItem", "InspectionItem")
+                        .WithMany()
+                        .HasForeignKey("InspectionItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", null)
+                        .WithMany("Items")
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResult", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "InspectedBy")
+                        .WithMany()
+                        .HasForeignKey("InspectedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionDevice", "InspectionDevice")
+                        .WithMany()
+                        .HasForeignKey("InspectionDeviceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.InspectionItem", "InspectionItem")
+                        .WithMany()
+                        .HasForeignKey("InspectionItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", null)
+                        .WithMany("Results")
+                        .HasForeignKey("InspectionOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectedBy");
+
+                    b.Navigation("InspectionDevice");
+
+                    b.Navigation("InspectionItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionResultCorrection", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CorrectedBy")
+                        .WithMany()
+                        .HasForeignKey("CorrectedByUserId");
+
+                    b.HasOne("MesApp.Core.Entities.InspectionResult", "InspectionResult")
+                        .WithMany()
+                        .HasForeignKey("InspectionResultId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("CorrectedBy");
+
+                    b.Navigation("InspectionResult");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryStock", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InventoryTransaction", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "FromLocation")
+                        .WithMany()
+                        .HasForeignKey("FromLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "ToLocation")
+                        .WithMany()
+                        .HasForeignKey("ToLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("FromLocation");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("ToLocation");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Location", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Lot", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "ParentLot")
+                        .WithMany()
+                        .HasForeignKey("ParentLotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "SourceWorkOrder")
+                        .WithMany()
+                        .HasForeignKey("SourceWorkOrderId");
+
+                    b.Navigation("ParentLot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("SourceWorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotGenealogy", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "ChildLot")
+                        .WithMany()
+                        .HasForeignKey("ChildLotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "ParentLot")
+                        .WithMany()
+                        .HasForeignKey("ParentLotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ChildLot");
+
+                    b.Navigation("ParentLot");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.LotStatusHistory", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Lot");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CreatedBy")
+                        .WithMany()
+                        .HasForeignKey("CreatedByUserId");
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.MaintenancePlan", "MaintenancePlan")
+                        .WithMany()
+                        .HasForeignKey("MaintenancePlanId");
+
+                    b.HasOne("MesApp.Core.Entities.MaintenanceProcedure", "Procedure")
+                        .WithMany()
+                        .HasForeignKey("ProcedureId");
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CreatedBy");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("MaintenancePlan");
+
+                    b.Navigation("Procedure");
+
+                    b.Navigation("Tool");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenancePlan", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceProcedure", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "TargetEquipment")
+                        .WithMany()
+                        .HasForeignKey("TargetEquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "TargetTool")
+                        .WithMany()
+                        .HasForeignKey("TargetToolId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("TargetEquipment");
+
+                    b.Navigation("TargetTool");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.MaintenanceOrder", null)
+                        .WithMany("Records")
+                        .HasForeignKey("MaintenanceOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("PerformedBy");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecordPart", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.MaintenanceRecord", null)
+                        .WithMany("Parts")
+                        .HasForeignKey("MaintenanceRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "OutputLot")
+                        .WithMany()
+                        .HasForeignKey("OutputLotId");
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "SourceOrder")
+                        .WithMany()
+                        .HasForeignKey("SourceOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("OutputLot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("SourceOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrderMaterial", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "ChildProduct")
+                        .WithMany()
+                        .HasForeignKey("ChildProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ManufacturingOrder")
+                        .WithMany("Materials")
+                        .HasForeignKey("ManufacturingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildProduct");
+
+                    b.Navigation("ManufacturingOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaterialConsumption", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.NonconformanceReport", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", "InspectionOrder")
+                        .WithMany()
+                        .HasForeignKey("InspectionOrderId");
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ReportedBy")
+                        .WithMany()
+                        .HasForeignKey("ReportedByUserId");
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ReworkOrder")
+                        .WithMany()
+                        .HasForeignKey("ReworkOrderId");
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("InspectionOrder");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ReportedBy");
+
+                    b.Navigation("ReworkOrder");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.PickingOrder", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("PickingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", "ShippingOrder")
+                        .WithMany()
+                        .HasForeignKey("ShippingOrderId");
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("ShippingOrder");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Product", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "DefaultLocation")
+                        .WithMany()
+                        .HasForeignKey("DefaultLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DefaultLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDataRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkOrderControlItem", "WorkOrderControlItem")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WorkOrder");
+
+                    b.Navigation("WorkOrderControlItem");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionDefect", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.DefectReason", "DefectReason")
+                        .WithMany()
+                        .HasForeignKey("DefectReasonId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ProductionRecord", "ProductionRecord")
+                        .WithMany("Defects")
+                        .HasForeignKey("ProductionRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DefectReason");
+
+                    b.Navigation("ProductionRecord");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionPlan", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("WorkCenter");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Lot", "OutputLot")
+                        .WithMany()
+                        .HasForeignKey("OutputLotId");
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Shift", "Shift")
+                        .WithMany()
+                        .HasForeignKey("ShiftId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OutputLot");
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("Shift");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecordCorrection", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "CorrectedBy")
+                        .WithMany()
+                        .HasForeignKey("CorrectedByUserId");
+
+                    b.HasOne("MesApp.Core.Entities.ProductionRecord", "ProductionRecord")
+                        .WithMany()
+                        .HasForeignKey("ProductionRecordId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("CorrectedBy");
+
+                    b.Navigation("ProductionRecord");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RefreshToken", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Checklist", "Checklist")
+                        .WithMany()
+                        .HasForeignKey("ChecklistId");
+
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId");
+
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "RequiredSkill")
+                        .WithMany()
+                        .HasForeignKey("RequiredSkillId");
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId");
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkProcedure", "WorkProcedure")
+                        .WithMany()
+                        .HasForeignKey("WorkProcedureId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Checklist");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("RequiredSkill");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkCenter");
+
+                    b.Navigation("WorkProcedure");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ControlItem", "ControlItem")
+                        .WithMany()
+                        .HasForeignKey("ControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Routing", "Routing")
+                        .WithMany("ControlItemLinks")
+                        .HasForeignKey("RoutingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ControlItem");
+
+                    b.Navigation("Routing");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Routing", "Routing")
+                        .WithMany("EquipmentCandidates")
+                        .HasForeignKey("RoutingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("Routing");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SampleStorage", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.InspectionOrder", "InspectionOrder")
+                        .WithMany()
+                        .HasForeignKey("InspectionOrderId");
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "StorageLocation")
+                        .WithMany()
+                        .HasForeignKey("StorageLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("InspectionOrder");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("StorageLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.SetupRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "PerformedBy")
+                        .WithMany()
+                        .HasForeignKey("PerformedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PerformedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShipmentJudgment", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "JudgedBy")
+                        .WithMany()
+                        .HasForeignKey("JudgedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", "ShippingOrder")
+                        .WithMany()
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("JudgedBy");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ShippingOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ShippingOrder", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("ShippingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "TargetLocation")
+                        .WithMany()
+                        .HasForeignKey("TargetLocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("TargetLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.StocktakeLine", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Stocktake", null)
+                        .WithMany("Lines")
+                        .HasForeignKey("StocktakeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("Product");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolIssue", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "IssuedTo")
+                        .WithMany()
+                        .HasForeignKey("IssuedToUserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("IssuedTo");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ToolUsage", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Tool", "Tool")
+                        .WithMany()
+                        .HasForeignKey("ToolId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TransferOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Location", "FromLocation")
+                        .WithMany()
+                        .HasForeignKey("FromLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Lot", "Lot")
+                        .WithMany()
+                        .HasForeignKey("LotId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Location", "ToLocation")
+                        .WithMany()
+                        .HasForeignKey("ToLocationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("FromLocation");
+
+                    b.Navigation("Lot");
+
+                    b.Navigation("ToLocation");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.TroubleReport", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
+                        .WithMany()
+                        .HasForeignKey("EquipmentId");
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ReportedBy")
+                        .WithMany()
+                        .HasForeignKey("ReportedByUserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("Equipment");
+
+                    b.Navigation("ReportedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.UserSkill", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "Skill")
+                        .WithMany()
+                        .HasForeignKey("SkillId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Skill");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkCenter", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "Parent")
+                        .WithMany()
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.Equipment", "AssignedEquipment")
+                        .WithMany()
+                        .HasForeignKey("AssignedEquipmentId");
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", "AssignedUser")
+                        .WithMany()
+                        .HasForeignKey("AssignedUserId");
+
+                    b.HasOne("MesApp.Core.Entities.ManufacturingOrder", "ManufacturingOrder")
+                        .WithMany("WorkOrders")
+                        .HasForeignKey("ManufacturingOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "Process")
+                        .WithMany()
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Product", "Product")
+                        .WithMany()
+                        .HasForeignKey("ProductId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.SkillMaster", "RequiredSkill")
+                        .WithMany()
+                        .HasForeignKey("RequiredSkillId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.Checklist", "RoutingChecklist")
+                        .WithMany()
+                        .HasForeignKey("RoutingChecklistId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
+                        .WithMany()
+                        .HasForeignKey("WorkCenterId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkProcedure", "WorkProcedure")
+                        .WithMany()
+                        .HasForeignKey("WorkProcedureId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("AssignedEquipment");
+
+                    b.Navigation("AssignedUser");
+
+                    b.Navigation("ManufacturingOrder");
+
+                    b.Navigation("Process");
+
+                    b.Navigation("Product");
+
+                    b.Navigation("RequiredSkill");
+
+                    b.Navigation("RoutingChecklist");
+
+                    b.Navigation("WorkCenter");
+
+                    b.Navigation("WorkProcedure");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ControlItem", "ControlItem")
+                        .WithMany()
+                        .HasForeignKey("ControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany("ControlItemSnapshots")
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ControlItem");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrderStatusHistory", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "ChangedBy")
+                        .WithMany()
+                        .HasForeignKey("ChangedByUserId");
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChangedBy");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkTimeRecord", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Checklist", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ChecklistRecord", b =>
+                {
+                    b.Navigation("Results");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
+                {
+                    b.Navigation("Parts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.InspectionOrder", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("Results");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceOrder", b =>
+                {
+                    b.Navigation("Records");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.MaintenanceRecord", b =>
+                {
+                    b.Navigation("Parts");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ManufacturingOrder", b =>
+                {
+                    b.Navigation("Materials");
+
+                    b.Navigation("WorkOrders");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.PickingOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ProductionRecord", b =>
+                {
+                    b.Navigation("Defects");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
+                {
+                    b.Navigation("ControlItemLinks");
+
+                    b.Navigation("EquipmentCandidates");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.ShippingOrder", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.Stocktake", b =>
+                {
+                    b.Navigation("Lines");
+                });
+
+            modelBuilder.Entity("MesApp.Core.Entities.WorkOrder", b =>
+                {
+                    b.Navigation("ControlItemSnapshots");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/MesApp.Migrations.SqlServer/Migrations/20260923081743_LinkControlItemsToRouting.cs b/src/MesApp.Migrations.SqlServer/Migrations/20260923081743_LinkControlItemsToRouting.cs
new file mode 100644
index 0000000..0e95149
--- /dev/null
+++ b/src/MesApp.Migrations.SqlServer/Migrations/20260923081743_LinkControlItemsToRouting.cs
@@ -0,0 +1,118 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace MesApp.Migrations.SqlServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class LinkControlItemsToRouting : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_ControlItems_Processes_TargetProcessId",
+                table: "ControlItems");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_ControlItems_Products_TargetProductId",
+                table: "ControlItems");
+
+            migrationBuilder.DropIndex(
+                name: "IX_ControlItems_TargetProcessId",
+                table: "ControlItems");
+
+            migrationBuilder.DropIndex(
+                name: "IX_ControlItems_TargetProductId",
+                table: "ControlItems");
+
+            migrationBuilder.DropColumn(
+                name: "TargetProcessId",
+                table: "ControlItems");
+
+            migrationBuilder.DropColumn(
+                name: "TargetProductId",
+                table: "ControlItems");
+
+            migrationBuilder.CreateTable(
+                name: "RoutingControlItems",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    RoutingId = table.Column<int>(type: "int", nullable: false),
+                    ControlItemId = table.Column<int>(type: "int", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_RoutingControlItems", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_RoutingControlItems_ControlItems_ControlItemId",
+                        column: x => x.ControlItemId,
+                        principalTable: "ControlItems",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_RoutingControlItems_Routings_RoutingId",
+                        column: x => x.RoutingId,
+                        principalTable: "Routings",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_RoutingControlItems_ControlItemId",
+                table: "RoutingControlItems",
+                column: "ControlItemId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_RoutingControlItems_RoutingId_ControlItemId",
+                table: "RoutingControlItems",
+                columns: new[] { "RoutingId", "ControlItemId" },
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "RoutingControlItems");
+
+            migrationBuilder.AddColumn<int>(
+                name: "TargetProcessId",
+                table: "ControlItems",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "TargetProductId",
+                table: "ControlItems",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ControlItems_TargetProcessId",
+                table: "ControlItems",
+                column: "TargetProcessId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ControlItems_TargetProductId",
+                table: "ControlItems",
+                column: "TargetProductId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ControlItems_Processes_TargetProcessId",
+                table: "ControlItems",
+                column: "TargetProcessId",
+                principalTable: "Processes",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_ControlItems_Products_TargetProductId",
+                table: "ControlItems",
+                column: "TargetProductId",
+                principalTable: "Products",
+                principalColumn: "Id");
+        }
+    }
+}
diff --git a/src/MesApp.Migrations.SqlServer/Migrations/MesAppDbContextModelSnapshot.cs b/src/MesApp.Migrations.SqlServer/Migrations/MesAppDbContextModelSnapshot.cs
index d589440..0bdd2e6 100644
--- a/src/MesApp.Migrations.SqlServer/Migrations/MesAppDbContextModelSnapshot.cs
+++ b/src/MesApp.Migrations.SqlServer/Migrations/MesAppDbContextModelSnapshot.cs
@@ -371,12 +371,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasMaxLength(200)
                         .HasColumnType("nvarchar(200)");
 
-                    b.Property<int?>("TargetProcessId")
-                        .HasColumnType("int");
-
-                    b.Property<int?>("TargetProductId")
-                        .HasColumnType("int");
-
                     b.Property<decimal?>("TargetValue")
                         .HasPrecision(18, 6)
                         .HasColumnType("decimal(18,6)");
@@ -397,10 +391,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.HasIndex("Code")
                         .IsUnique();
 
-                    b.HasIndex("TargetProcessId");
-
-                    b.HasIndex("TargetProductId");
-
                     b.ToTable("ControlItems");
                 });
 
@@ -2369,6 +2359,30 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Routings");
                 });
 
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingControlItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ControlItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RoutingId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ControlItemId");
+
+                    b.HasIndex("RoutingId", "ControlItemId")
+                        .IsUnique();
+
+                    b.ToTable("RoutingControlItems");
+                });
+
             modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
                 {
                     b.Property<int>("Id")
@@ -3124,8 +3138,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("nvarchar(450)");
 
                     b.Property<string>("ControlItems")
-                        .HasMaxLength(500)
-                        .HasColumnType("nvarchar(500)");
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
 
                     b.Property<DateTimeOffset>("CreatedAt")
                         .HasColumnType("datetimeoffset");
@@ -3620,21 +3634,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("ChecklistItem");
                 });
 
-            modelBuilder.Entity("MesApp.Core.Entities.ControlItem", b =>
-                {
-                    b.HasOne("MesApp.Core.Entities.ProcessMaster", "TargetProcess")
-                        .WithMany()
-                        .HasForeignKey("TargetProcessId");
-
-                    b.HasOne("MesApp.Core.Entities.Product", "TargetProduct")
-                        .WithMany()
-                        .HasForeignKey("TargetProductId");
-
-                    b.Navigation("TargetProcess");
-
-                    b.Navigation("TargetProduct");
-                });
-
             modelBuilder.Entity("MesApp.Core.Entities.Equipment", b =>
                 {
                     b.HasOne("MesApp.Core.Entities.WorkCenter", "WorkCenter")
@@ -4404,6 +4403,25 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("WorkProcedure");
                 });
 
+            modelBuilder.Entity("MesApp.Core.Entities.RoutingControlItem", b =>
+                {
+                    b.HasOne("MesApp.Core.Entities.ControlItem", "ControlItem")
+                        .WithMany()
+                        .HasForeignKey("ControlItemId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("MesApp.Core.Entities.Routing", "Routing")
+                        .WithMany("ControlItemLinks")
+                        .HasForeignKey("RoutingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ControlItem");
+
+                    b.Navigation("Routing");
+                });
+
             modelBuilder.Entity("MesApp.Core.Entities.RoutingEquipment", b =>
                 {
                     b.HasOne("MesApp.Core.Entities.Equipment", "Equipment")
@@ -4903,6 +4921,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
             modelBuilder.Entity("MesApp.Core.Entities.Routing", b =>
                 {
+                    b.Navigation("ControlItemLinks");
+
                     b.Navigation("EquipmentCandidates");
                 });
 
diff --git a/tests/MesApp.Api.Tests/ExecutionTests.cs b/tests/MesApp.Api.Tests/ExecutionTests.cs
index c391e4d..55f14fa 100644
--- a/tests/MesApp.Api.Tests/ExecutionTests.cs
+++ b/tests/MesApp.Api.Tests/ExecutionTests.cs
@@ -103,7 +103,11 @@ await ImportAsync("masters/csv/checklists",
             "CL-T,段取り確認,Setup,true,1,治具の確認,true\nCL-T,段取り確認,Setup,true,2,清掃,false\n");
         await ImportAsync("masters/csv/defect-reasons", "Code,Name,Category\nDR-01,寸法不良,Process\n");
         await ImportAsync("masters/csv/control-items",
-            "Code,Name,Unit,TargetProductCode,TargetValue,LowerLimit,UpperLimit\nCI-T,温度,℃,FG-01,100,90,110\n");
+            "Code,Name,Unit,TargetValue,LowerLimit,UpperLimit\nCI-T,温度,℃,100,90,110\n");
+        // 工程管理項目は工順の工程に紐付けたものだけが作業指示へ写る（1工程目にだけ紐付ける）
+        await ImportAsync("masters/csv/routing",
+            "ProductCode,Sequence,ProcessCode,StandardWorkMinutes,StandardSetupMinutes,ControlItemCodes\n" +
+            "FG-01,1,PR-01,30,10,CI-T\nFG-01,2,PR-01,15,5,\n");
         await ImportAsync("actuals/csv/receiving", "ProductCode,Quantity,LocationCode,LotNumber\nRM-01,100,LOC-M,RM-LOT-1\n");
         await ImportAsync("actuals/csv/manufacturing-orders",
             "OrderNo,ProductCode,Quantity,Approve,Expand\nORD-1,FG-01,10,true,true\n");
@@ -728,6 +732,29 @@ await admin.PostAsJsonAsync("/api/inventory/status",
         Assert.Equal(HttpStatusCode.OK, unrestricted.StatusCode);
     }
 
+    [Fact]
+    public async Task 工順に登録できる長さの工程管理項目はそのまま作業指示へ展開できる()
+    {
+        using var factory = new ApiFactory();
+        using var admin = await TestAuth.CreateAdminClientAsync(factory);
+
+        var product = await MasterTests.CreateProductAsync(admin, "FG-01", "完成品", ProductType.Product);
+        var process = await MasterTests.CreateProcessAsync(admin, "PR-01", "加工");
+
+        // 上限を超える記述は工順の登録で止める（展開まで持ち越すと実DBで保存に失敗する）
+        var tooLong = await admin.PutAsJsonAsync($"/api/products/{product.Id}/routing",
+            new List<RoutingStepRequest> { new(1, process.Id, 30m, 10m, null, null, null, new string('あ', 1001), null) });
+        Assert.Equal(HttpStatusCode.BadRequest, tooLong.StatusCode);
+
+        // 上限いっぱいの記述は作業指示へ欠けずに写る（作業指示側の列が工順側より短いと展開に失敗していた）
+        var longest = new string('あ', 1000);
+        (await admin.PutAsJsonAsync($"/api/products/{product.Id}/routing",
+            new List<RoutingStepRequest> { new(1, process.Id, 30m, 10m, null, null, null, longest, null) }))
+            .EnsureSuccessStatusCode();
+        var order = await Phase3TestData.CreateReleasedOrderAsync(admin, product.Id, 10m);
+        Assert.Equal(longest, order.WorkOrders.Single().ControlItems);
+    }
+
     private static async Task<MesApp.Core.Contracts.Masters.EquipmentResponse> CreateEquipmentAsync(
         HttpClient admin, string assetNo, string name)
     {
@@ -745,16 +772,22 @@ await admin.PostAsJsonAsync("/api/inventory/status",
         using var admin = await TestAuth.CreateAdminClientAsync(factory);
         var ctx = await Phase3TestData.SetupAsync(admin);
 
-        // 指示（工程単位）を用意してから展開する。展開時点の値が作業指示へ写る
-        (await admin.PostAsJsonAsync("/api/control-items",
-            new Core.Contracts.Masters.ControlItemRequest(
-                "CI-01", "加熱温度", "℃", null, ctx.ProcessId, 180m, 175m, 185m)))
-            .EnsureSuccessStatusCode();
+        // 指示を用意して工順の1工程目に紐付けてから展開する。展開時点の値が作業指示へ写る
+        async Task<int> CreateItemAsync(Core.Contracts.Masters.ControlItemRequest request)
+        {
+            var created = await admin.PostAsJsonAsync("/api/control-items", request);
+            created.EnsureSuccessStatusCode();
+            return (await created.Content.ReadFromJsonAsync<Core.Contracts.Masters.ControlItemResponse>())!.Id;
+        }
+        var temperatureId = await CreateItemAsync(new("CI-01", "加熱温度", "℃", 180m, 175m, 185m));
         // 上下限を持たない項目は判定しない（記録だけが目的の条件）
-        (await admin.PostAsJsonAsync("/api/control-items",
-            new Core.Contracts.Masters.ControlItemRequest(
-                "CI-02", "作業者メモ", null, null, ctx.ProcessId, null, null, null)))
-            .EnsureSuccessStatusCode();
+        var memoId = await CreateItemAsync(new("CI-02", "作業者メモ", null, null, null, null));
+        (await admin.PutAsJsonAsync($"/api/products/{ctx.ProductId}/routing",
+            new List<RoutingStepRequest>
+            {
+                new(1, ctx.ProcessId, 30m, 10m, null, null, null, null, null, ControlItemIds: [temperatureId, memoId]),
+                new(2, ctx.ProcessId, 15m, 5m, null, null, null, null, null),
+            })).EnsureSuccessStatusCode();
 
         var order = await Phase3TestData.CreateReleasedOrderAsync(admin, ctx.ProductId, 10m);
         var workOrderId = order.WorkOrders[0].Id;
diff --git a/tests/MesApp.Api.Tests/MasterCsvTests.cs b/tests/MesApp.Api.Tests/MasterCsvTests.cs
index cd60e40..9e1ce58 100644
--- a/tests/MesApp.Api.Tests/MasterCsvTests.cs
+++ b/tests/MesApp.Api.Tests/MasterCsvTests.cs
@@ -810,13 +810,12 @@ private static string FindSampleDirectory(string name = "master-csv")
             """)).Succeeded);
 
         var result = await ImportAsync(client, "control-items", """
-            Code,Name,Unit,TargetProductCode,TargetProcessCode,TargetValue,LowerLimit,UpperLimit,IsActive
-            CI-01,加熱温度,℃,,PR-01,180,175,185,true
+            Code,Name,Unit,TargetValue,LowerLimit,UpperLimit,IsActive
+            CI-01,加熱温度,℃,180,175,185,true
             """);
         Assert.True(result.Succeeded, string.Join(" / ", result.Errors.Select(e => e.Message)));
         var items = await client.GetFromJsonAsync<List<ControlItemResponse>>("/api/control-items");
         Assert.Equal(180m, items!.Single().TargetValue);
-        Assert.Equal("PR-01", items!.Single().TargetProcessCode);
 
         // 単票APIと同じ条件で弾かれる
         var invalid = await ImportAsync(client, "control-items", """
@@ -837,6 +836,33 @@ private static string FindSampleDirectory(string name = "master-csv")
         Assert.Equal(1, revised.Updated);
         var after = await client.GetFromJsonAsync<List<ControlItemResponse>>("/api/control-items");
         Assert.Equal(2, after!.Single().Version);
+
+        // 工順CSVで工程に紐付ける。未登録のコードはその行の誤り
+        Assert.True((await ImportAsync(client, "products", """
+            Code,Name,Unit,Type
+            FG-01,完成品,個,Product
+            """)).Succeeded);
+        var unknown = await ImportAsync(client, "routing", """
+            ProductCode,Sequence,ProcessCode,ControlItemCodes
+            FG-01,1,PR-01,CI-01;CI-99
+            """);
+        Assert.False(unknown.Succeeded);
+        Assert.Contains(unknown.Errors, e => e.Line == 2 && e.Message.Contains("CI-99"));
+        var linked = await ImportAsync(client, "routing", """
+            ProductCode,Sequence,ProcessCode,ControlItemCodes
+            FG-01,1,PR-01,CI-01
+            """);
+        Assert.True(linked.Succeeded, string.Join(" / ", linked.Errors.Select(e => e.Message)));
+        var export = await (await client.GetAsync("/api/masters/csv/routing")).Content.ReadAsStringAsync();
+        Assert.Contains("CI-01", export);
+
+        // 紐付け中の項目はCSVからも無効化できない（単票APIと同じ条件）
+        var deactivate = await ImportAsync(client, "control-items", """
+            Code,Name,IsActive
+            CI-01,加熱温度,false
+            """);
+        Assert.False(deactivate.Succeeded);
+        Assert.Contains(deactivate.Errors, e => e.Message.Contains("FG-01"));
     }
 
     [Fact]
diff --git a/tests/MesApp.Api.Tests/MasterTests.cs b/tests/MesApp.Api.Tests/MasterTests.cs
index 7000e30..449d40f 100644
--- a/tests/MesApp.Api.Tests/MasterTests.cs
+++ b/tests/MesApp.Api.Tests/MasterTests.cs
@@ -453,38 +453,31 @@ public class MasterTests
     {
         using var factory = new ApiFactory();
         using var client = await TestAuth.CreateAdminClientAsync(factory);
-        var process = await CreateProcessAsync(client, "PR-01", "加熱");
 
         var created = await client.PostAsJsonAsync("/api/control-items",
-            new ControlItemRequest("CI-01", "加熱温度", "℃", null, process.Id, 180m, 175m, 185m));
+            new ControlItemRequest("CI-01", "加熱温度", "℃", 180m, 175m, 185m));
         Assert.Equal(HttpStatusCode.Created, created.StatusCode);
         var item = await created.Content.ReadFromJsonAsync<ControlItemResponse>();
         Assert.Equal(1, item!.Version);
-        Assert.Equal("PR-01", item.TargetProcessCode);
 
         // コード重複は409
         var duplicated = await client.PostAsJsonAsync("/api/control-items",
-            new ControlItemRequest("CI-01", "別項目", null, null, null, null, null, null));
+            new ControlItemRequest("CI-01", "別項目", null, null, null, null));
         Assert.Equal(HttpStatusCode.Conflict, duplicated.StatusCode);
 
         // 下限>上限は400
         var reversed = await client.PostAsJsonAsync("/api/control-items",
-            new ControlItemRequest("CI-02", "逆転", null, null, null, null, 200m, 100m));
+            new ControlItemRequest("CI-02", "逆転", null, null, 200m, 100m));
         Assert.Equal(HttpStatusCode.BadRequest, reversed.StatusCode);
 
         // 指示値が許容範囲の外は400（指示どおり作っても逸脱になってしまうため）
         var outOfRange = await client.PostAsJsonAsync("/api/control-items",
-            new ControlItemRequest("CI-03", "範囲外", null, null, null, 300m, 175m, 185m));
+            new ControlItemRequest("CI-03", "範囲外", null, 300m, 175m, 185m));
         Assert.Equal(HttpStatusCode.BadRequest, outOfRange.StatusCode);
 
-        // 存在しない対象工程は400
-        var missingProcess = await client.PostAsJsonAsync("/api/control-items",
-            new ControlItemRequest("CI-04", "工程なし", null, null, 9999, null, null, null));
-        Assert.Equal(HttpStatusCode.BadRequest, missingProcess.StatusCode);
-
         // 更新で版数が上がる
         var updated = await client.PutAsJsonAsync($"/api/control-items/{item.Id}",
-            new ControlItemRequest("CI-01", "加熱温度", "℃", null, process.Id, 182m, 178m, 186m));
+            new ControlItemRequest("CI-01", "加熱温度", "℃", 182m, 178m, 186m));
         var updatedBody = await updated.Content.ReadFromJsonAsync<ControlItemResponse>();
         Assert.Equal(2, updatedBody!.Version);
         Assert.Equal(182m, updatedBody.TargetValue);
@@ -496,6 +489,51 @@ public class MasterTests
         Assert.Empty(active!);
     }
 
+    [Fact]
+    public async Task 工順に紐付けた工程管理項目は無効化できず無効な項目は紐付けられない()
+    {
+        using var factory = new ApiFactory();
+        using var client = await TestAuth.CreateAdminClientAsync(factory);
+        var product = await CreateProductAsync(client, "FG-01", "完成品", ProductType.Product);
+        var process = await CreateProcessAsync(client, "PR-01", "加熱");
+        async Task<int> CreateItemAsync(string code)
+        {
+            var created = await client.PostAsJsonAsync("/api/control-items",
+                new ControlItemRequest(code, code, null, null, null, null));
+            created.EnsureSuccessStatusCode();
+            return (await created.Content.ReadFromJsonAsync<ControlItemResponse>())!.Id;
+        }
+        var linkedId = await CreateItemAsync("CI-02");
+        var otherId = await CreateItemAsync("CI-01");
+
+        // 紐付けは工程ごとにコード順で返る（同じ項目の二重指定は1つにまとめる）
+        var saved = await client.PutAsJsonAsync($"/api/products/{product.Id}/routing",
+            new List<RoutingStepRequest>
+            {
+                new(1, process.Id, 30m, 10m, null, null, null, null, null, ControlItemIds: [linkedId, otherId, linkedId]),
+            });
+        Assert.Equal(HttpStatusCode.OK, saved.StatusCode);
+        var steps = await saved.Content.ReadFromJsonAsync<List<RoutingStepResponse>>();
+        Assert.Equal(["CI-01", "CI-02"], steps!.Single().ControlItemCodes!);
+
+        // 紐付け中は無効化できない（展開する作業指示に使わせないはずの条件が載り続ける）
+        var inUse = await client.DeleteAsync($"/api/control-items/{linkedId}");
+        Assert.Equal(HttpStatusCode.Conflict, inUse.StatusCode);
+        Assert.Contains("FG-01", await inUse.Content.ReadAsStringAsync());
+
+        // 紐付けを外せば無効化でき、無効な項目は紐付けられない
+        (await client.PutAsJsonAsync($"/api/products/{product.Id}/routing",
+            new List<RoutingStepRequest> { new(1, process.Id, 30m, 10m, null, null, null, null, null) }))
+            .EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.NoContent, (await client.DeleteAsync($"/api/control-items/{linkedId}")).StatusCode);
+        var inactive = await client.PutAsJsonAsync($"/api/products/{product.Id}/routing",
+            new List<RoutingStepRequest>
+            {
+                new(1, process.Id, 30m, 10m, null, null, null, null, null, ControlItemIds: [linkedId]),
+            });
+        Assert.Equal(HttpStatusCode.BadRequest, inactive.StatusCode);
+    }
+
     internal static async Task<WorkCenterResponse> CreateWorkCenterAsync(
         HttpClient client, string code, string name, WorkCenterLevel level, int? parentId)
     {
diff --git a/tests/MesApp.Api.Tests/ProductionTests.cs b/tests/MesApp.Api.Tests/ProductionTests.cs
index b631df6..916fa50 100644
--- a/tests/MesApp.Api.Tests/ProductionTests.cs
+++ b/tests/MesApp.Api.Tests/ProductionTests.cs
@@ -105,29 +105,32 @@ private static async Task<ManufacturingOrderResponse> CreateOrderAsync(
     }
 
     [Fact]
-    public async Task 工程管理項目が展開時に固定され以降のマスタ改訂で指示が変わらない()
+    public async Task 工程管理項目は工順の工程ごとの紐付けどおりに展開され以降のマスタ改訂で指示が変わらない()
     {
         using var factory = new ApiFactory();
         using var admin = await TestAuth.CreateAdminClientAsync(factory);
 
         var product = await MasterTests.CreateProductAsync(admin, "FG-01", "完成品", ProductType.Product);
-        var process = await MasterTests.CreateProcessAsync(admin, "PR-01", "加熱");
-        (await admin.PutAsJsonAsync($"/api/products/{product.Id}/routing",
-            new List<RoutingStepRequest> { new(1, process.Id, 30m, 10m, null, null, null, null, null) }))
-            .EnsureSuccessStatusCode();
+        var heating = await MasterTests.CreateProcessAsync(admin, "PR-01", "加熱");
+        var inspection = await MasterTests.CreateProcessAsync(admin, "PR-02", "検査");
+        async Task<int> CreateItemAsync(ControlItemRequest request)
+        {
+            var created = await admin.PostAsJsonAsync("/api/control-items", request);
+            created.EnsureSuccessStatusCode();
+            return (await created.Content.ReadFromJsonAsync<ControlItemResponse>())!.Id;
+        }
+        var weightId = await CreateItemAsync(new("CI-01", "投入重量", "kg", 10m, 9.5m, 10.5m));
+        var temperatureId = await CreateItemAsync(new("CI-02", "加熱温度", "℃", 180m, 175m, 185m));
+        var reheatId = await CreateItemAsync(new("CI-03", "再加熱温度", "℃", 150m, 145m, 155m));
 
-        // 品目単位の項目と工程単位の項目を用意する（両方が作業指示へ写る）
-        var byProduct = await admin.PostAsJsonAsync("/api/control-items",
-            new ControlItemRequest("CI-01", "投入重量", "kg", product.Id, null, 10m, 9.5m, 10.5m));
-        byProduct.EnsureSuccessStatusCode();
-        var byProcess = await admin.PostAsJsonAsync("/api/control-items",
-            new ControlItemRequest("CI-02", "加熱温度", "℃", null, process.Id, 180m, 175m, 185m));
-        byProcess.EnsureSuccessStatusCode();
-        // 別工程の項目は写らない
-        var other = await MasterTests.CreateProcessAsync(admin, "PR-02", "検査");
-        (await admin.PostAsJsonAsync("/api/control-items",
-            new ControlItemRequest("CI-03", "別工程の項目", null, null, other.Id, null, null, null)))
-            .EnsureSuccessStatusCode();
+        // 同じ加熱工程が2回ある工順。工程ごとに別の条件を持たせ、検査工程には何も紐付けない
+        (await admin.PutAsJsonAsync($"/api/products/{product.Id}/routing",
+            new List<RoutingStepRequest>
+            {
+                new(1, heating.Id, 30m, 10m, null, null, null, null, null, ControlItemIds: [weightId, temperatureId]),
+                new(2, inspection.Id, 10m, 0m, null, null, null, null, null),
+                new(3, heating.Id, 20m, 0m, null, null, null, null, null, ControlItemIds: [reheatId]),
+            })).EnsureSuccessStatusCode();
 
         var order = await CreateOrderAsync(admin, product.Id);
         await admin.PostAsync($"/api/manufacturing-orders/{order.Id}/approve", null);
@@ -135,11 +138,15 @@ private static async Task<ManufacturingOrderResponse> CreateOrderAsync(
             $"/api/manufacturing-orders/{order.Id}/expand", new ExpandRequest(null));
         expanded.EnsureSuccessStatusCode();
         var detail = await expanded.Content.ReadFromJsonAsync<ManufacturingOrderDetailResponse>();
-        var workOrder = detail!.WorkOrders.Single();
-
-        var items = await admin.GetFromJsonAsync<List<WorkOrderControlItemResponse>>(
-            $"/api/work-orders/{workOrder.Id}/control-items");
-        Assert.Equal(["CI-01", "CI-02"], items!.Select(i => i.ItemCode));
+        async Task<List<WorkOrderControlItemResponse>> ItemsOfAsync(ManufacturingOrderDetailResponse d, int sequence) =>
+            (await admin.GetFromJsonAsync<List<WorkOrderControlItemResponse>>(
+                $"/api/work-orders/{d.WorkOrders.Single(w => w.RoutingSequence == sequence).Id}/control-items"))!;
+
+        var items = await ItemsOfAsync(detail!, 1);
+        Assert.Equal(["CI-01", "CI-02"], items.Select(i => i.ItemCode));
+        Assert.Empty(await ItemsOfAsync(detail!, 2));
+        Assert.Equal(["CI-03"], (await ItemsOfAsync(detail!, 3)).Select(i => i.ItemCode));
+        var workOrder = detail!.WorkOrders.Single(w => w.RoutingSequence == 1);
         var temperature = items!.Single(i => i.ItemCode == "CI-02");
         Assert.Equal(180m, temperature.TargetValue);
         Assert.Equal(175m, temperature.LowerLimit);
@@ -147,9 +154,8 @@ private static async Task<ManufacturingOrderResponse> CreateOrderAsync(
         Assert.Equal("℃", temperature.Unit);
 
         // マスタを改訂しても展開済みの指示は変わらない（Spec.md 5.7）
-        var itemId = (await byProcess.Content.ReadFromJsonAsync<ControlItemResponse>())!.Id;
-        (await admin.PutAsJsonAsync($"/api/control-items/{itemId}",
-            new ControlItemRequest("CI-02", "加熱温度", "℃", null, process.Id, 200m, 195m, 205m)))
+        (await admin.PutAsJsonAsync($"/api/control-items/{temperatureId}",
+            new ControlItemRequest("CI-02", "加熱温度", "℃", 200m, 195m, 205m)))
             .EnsureSuccessStatusCode();
         var afterRevision = await admin.GetFromJsonAsync<List<WorkOrderControlItemResponse>>(
             $"/api/work-orders/{workOrder.Id}/control-items");
@@ -163,10 +169,9 @@ private static async Task<ManufacturingOrderResponse> CreateOrderAsync(
         var nextExpanded = await admin.PostAsJsonAsync(
             $"/api/manufacturing-orders/{next.Id}/expand", new ExpandRequest(null));
         var nextDetail = await nextExpanded.Content.ReadFromJsonAsync<ManufacturingOrderDetailResponse>();
-        var nextItems = await admin.GetFromJsonAsync<List<WorkOrderControlItemResponse>>(
-            $"/api/work-orders/{nextDetail!.WorkOrders.Single().Id}/control-items");
-        Assert.Equal(200m, nextItems!.Single(i => i.ItemCode == "CI-02").TargetValue);
-        Assert.Equal(2, nextItems!.Single(i => i.ItemCode == "CI-02").ItemVersion);
+        var nextItems = await ItemsOfAsync(nextDetail!, 1);
+        Assert.Equal(200m, nextItems.Single(i => i.ItemCode == "CI-02").TargetValue);
+        Assert.Equal(2, nextItems.Single(i => i.ItemCode == "CI-02").ItemVersion);
     }
 
     [Fact]