add export customer payment control

[FIX][BE]: fix detail daily checklist empty kandang; add sorting to report biaya operasional

See merge request mbugroup/lti-api!539

.gitlab-ci.yml

@@ -27,10 +27,24 @@ workflow:
 .ecr_login: &ecr_login |
   AWS_CLI_ENV_ARGS=""
   AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_REGION=$AWS_REGION"
-  AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-}"
-  AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-}"
-  if [ -n "${AWS_SESSION_TOKEN:-}" ]; then
-    AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_SESSION_TOKEN=$AWS_SESSION_TOKEN"
+
+  HAS_ACCESS_KEY="false"
+  HAS_SECRET_KEY="false"
+  if [ -n "${AWS_ACCESS_KEY_ID:-}" ]; then
+    HAS_ACCESS_KEY="true"
+  fi
+  if [ -n "${AWS_SECRET_ACCESS_KEY:-}" ]; then
+    HAS_SECRET_KEY="true"
+  fi
+
+  if [ "$HAS_ACCESS_KEY" = "true" ] && [ "$HAS_SECRET_KEY" = "true" ]; then
+    AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID"
+    AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY"
+    if [ -n "${AWS_SESSION_TOKEN:-}" ]; then
+      AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_SESSION_TOKEN=$AWS_SESSION_TOKEN"
+    fi
+  elif [ "$HAS_ACCESS_KEY" = "true" ] || [ "$HAS_SECRET_KEY" = "true" ] || [ -n "${AWS_SESSION_TOKEN:-}" ]; then
+    echo "WARN: Incomplete AWS_* env vars detected; ignoring injected AWS credentials for ECR login."
   fi
 
   PASS="$(docker run --rm $AWS_CLI_ENV_ARGS public.ecr.aws/aws-cli/aws-cli:latest \

cmd/auto-transfer-products-to-farm/main_test.go

@@ -0,0 +1,601 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+	"time"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	transferSvc "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/transfers/services"
+)
+
+// ── Fake executor ─────────────────────────────────────────────────────────────
+
+type fakeSystemTransferExecutor struct {
+	createRequests     []*transferSvc.SystemTransferRequest
+	createResponses    []*entity.StockTransfer
+	createErrors       []error
+	deletedTransferIDs []uint
+	deleteErrors       map[uint]error
+}
+
+func (f *fakeSystemTransferExecutor) CreateSystemTransfer(_ context.Context, req *transferSvc.SystemTransferRequest) (*entity.StockTransfer, error) {
+	f.createRequests = append(f.createRequests, req)
+	idx := len(f.createRequests) - 1
+	if idx < len(f.createErrors) && f.createErrors[idx] != nil {
+		return nil, f.createErrors[idx]
+	}
+	if idx < len(f.createResponses) && f.createResponses[idx] != nil {
+		return f.createResponses[idx], nil
+	}
+	return &entity.StockTransfer{Id: uint64(1000 + idx), MovementNumber: "PND-LTI-DEFAULT"}, nil
+}
+
+func (f *fakeSystemTransferExecutor) DeleteSystemTransfer(_ context.Context, id uint, _ uint) error {
+	f.deletedTransferIDs = append(f.deletedTransferIDs, id)
+	if f.deleteErrors != nil {
+		return f.deleteErrors[id]
+	}
+	return nil
+}
+
+// ── applyFarmWarehouseOverride ────────────────────────────────────────────────
+
+func TestApplyOverrideResolvesMultiFarmLocation(t *testing.T) {
+	farmMap := map[uint]farmWarehouseInfo{
+		10: {
+			LocationID:   10,
+			LocationName: "Cijangkar",
+			AllFarm: []farmWarehouseEntry{
+				{ID: 50, Name: "Farm A"},
+				{ID: 51, Name: "Farm B"},
+			},
+		},
+	}
+
+	if err := applyFarmWarehouseOverride(farmMap, 51); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	info := farmMap[10]
+	if info.ChosenID != 51 {
+		t.Errorf("expected ChosenID=51, got %d", info.ChosenID)
+	}
+	if info.ChosenName != "Farm B" {
+		t.Errorf("expected ChosenName=Farm B, got %s", info.ChosenName)
+	}
+	if len(info.OtherFarm) != 1 || info.OtherFarm[0].ID != 50 {
+		t.Errorf("expected OtherFarm=[Farm A], got %+v", info.OtherFarm)
+	}
+}
+
+func TestApplyOverrideErrorsWhenIDNotInAllFarm(t *testing.T) {
+	farmMap := map[uint]farmWarehouseInfo{
+		10: {
+			LocationID:   10,
+			LocationName: "Cijangkar",
+			AllFarm: []farmWarehouseEntry{
+				{ID: 50, Name: "Farm A"},
+				{ID: 51, Name: "Farm B"},
+			},
+		},
+	}
+
+	err := applyFarmWarehouseOverride(farmMap, 99)
+	if err == nil {
+		t.Fatal("expected error for unknown warehouse id, got nil")
+	}
+	if !strings.Contains(err.Error(), "99") {
+		t.Errorf("error should mention the invalid id, got: %v", err)
+	}
+	if !strings.Contains(err.Error(), "Farm A") || !strings.Contains(err.Error(), "Farm B") {
+		t.Errorf("error should list available warehouses, got: %v", err)
+	}
+}
+
+func TestApplyOverrideIgnoresSingleFarmLocations(t *testing.T) {
+	farmMap := map[uint]farmWarehouseInfo{
+		10: {
+			LocationID:   10,
+			LocationName: "Jamali",
+			AllFarm:      []farmWarehouseEntry{{ID: 50, Name: "Farm A"}},
+			ChosenID:     50,
+			ChosenName:   "Farm A",
+		},
+	}
+
+	// Override ID 50 is present, but there is only 1 farm; the function should
+	// not touch this location (no OtherFarm to populate).
+	if err := applyFarmWarehouseOverride(farmMap, 50); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(farmMap[10].OtherFarm) != 0 {
+		t.Errorf("expected no OtherFarm for single-farm location, got %+v", farmMap[10].OtherFarm)
+	}
+}
+
+func TestApplyOverrideNoopWhenZero(t *testing.T) {
+	farmMap := map[uint]farmWarehouseInfo{
+		10: {
+			LocationID:   10,
+			LocationName: "Cijangkar",
+			AllFarm: []farmWarehouseEntry{
+				{ID: 50, Name: "Farm A"},
+				{ID: 51, Name: "Farm B"},
+			},
+		},
+	}
+	if err := applyFarmWarehouseOverride(farmMap, 0); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if farmMap[10].ChosenID != 0 {
+		t.Errorf("expected ChosenID unchanged (0), got %d", farmMap[10].ChosenID)
+	}
+}
+
+// ── listUnresolvedLocations ───────────────────────────────────────────────────
+
+func TestListUnresolvedLocationsReturnsOnlyAmbiguous(t *testing.T) {
+	farmMap := map[uint]farmWarehouseInfo{
+		1: {LocationID: 1, LocationName: "Jamali", AllFarm: []farmWarehouseEntry{{ID: 50, Name: "Farm A"}}, ChosenID: 50},
+		2: {
+			LocationID:   2,
+			LocationName: "Cijangkar",
+			AllFarm:      []farmWarehouseEntry{{ID: 60, Name: "Farm X"}, {ID: 61, Name: "Farm Y"}},
+			// ChosenID = 0: unresolved
+		},
+		3: {LocationID: 3, LocationName: "Tamansari", AllFarm: nil}, // no farm at all, not an error here
+	}
+
+	msgs := listUnresolvedLocations(farmMap)
+	if len(msgs) != 1 {
+		t.Fatalf("expected 1 unresolved message, got %d: %v", len(msgs), msgs)
+	}
+	if !strings.Contains(msgs[0], "Cijangkar") {
+		t.Errorf("message should name the ambiguous location, got: %s", msgs[0])
+	}
+	if !strings.Contains(msgs[0], "Farm X") || !strings.Contains(msgs[0], "Farm Y") {
+		t.Errorf("message should list available warehouses, got: %s", msgs[0])
+	}
+}
+
+// ── buildTransferPlan — kandang source ───────────────────────────────────────
+
+func TestBuildPlanKandangEligibleGroupedByWarehousePair(t *testing.T) {
+	opts := &commandOptions{RunID: "test-run"}
+	farmMap := map[uint]farmWarehouseInfo{
+		10: {LocationID: 10, LocationName: "Jamali", AllFarm: []farmWarehouseEntry{{ID: 50, Name: "Farm A"}}, ChosenID: 50, ChosenName: "Farm A"},
+	}
+	stocks := []kandangStockRow{
+		{LocationID: 10, LocationName: "Jamali", SourceWarehouseID: 20, SourceWarehouseName: "K1", ProductID: 1, ProductName: "Pakan A", OnHandQty: 100, LeftoverQty: 100, SourceType: sourceTypeKandang},
+		{LocationID: 10, LocationName: "Jamali", SourceWarehouseID: 20, SourceWarehouseName: "K1", ProductID: 2, ProductName: "OVK B", OnHandQty: 50, AllocatedQty: 10, LeftoverQty: 40, SourceType: sourceTypeKandang},
+	}
+
+	reportRows, groups := buildTransferPlan(opts, farmMap, stocks)
+
+	if len(groups) != 1 || len(groups[0].Rows) != 2 {
+		t.Fatalf("expected 1 group with 2 rows, got %d groups", len(groups))
+	}
+	if groups[0].SourceType != sourceTypeKandang {
+		t.Errorf("expected group source type kandang_to_farm, got %s", groups[0].SourceType)
+	}
+	for _, row := range reportRows {
+		if row.Status != "eligible" {
+			t.Errorf("expected eligible, got %s for %s", row.Status, row.ProductName)
+		}
+	}
+	if reportRows[1].Qty != 40 {
+		t.Errorf("expected leftover qty 40 for OVK B, got %.3f", reportRows[1].Qty)
+	}
+}
+
+func TestBuildPlanSkipsMissingFarmWarehouse(t *testing.T) {
+	opts := &commandOptions{RunID: "test-run"}
+	farmMap := map[uint]farmWarehouseInfo{
+		10: {LocationID: 10, LocationName: "Jamali", AllFarm: nil},
+	}
+	stocks := []kandangStockRow{
+		{LocationID: 10, SourceWarehouseID: 20, ProductID: 1, ProductName: "Pakan A", OnHandQty: 100, LeftoverQty: 100, SourceType: sourceTypeKandang},
+	}
+
+	reportRows, groups := buildTransferPlan(opts, farmMap, stocks)
+	if len(groups) != 0 {
+		t.Fatalf("expected no groups, got %d", len(groups))
+	}
+	if reportRows[0].Status != "skipped" || reportRows[0].Reason != "missing_farm_warehouse" {
+		t.Errorf("unexpected: %s / %s", reportRows[0].Status, reportRows[0].Reason)
+	}
+}
+
+func TestBuildPlanErrorForUnresolvedMultiFarmWarehouse(t *testing.T) {
+	opts := &commandOptions{RunID: "test-run"}
+	farmMap := map[uint]farmWarehouseInfo{
+		10: {
+			LocationID:   10,
+			LocationName: "Cijangkar",
+			AllFarm:      []farmWarehouseEntry{{ID: 60, Name: "Farm X"}, {ID: 61, Name: "Farm Y"}},
+			// ChosenID = 0: unresolved
+		},
+	}
+	stocks := []kandangStockRow{
+		{LocationID: 10, LocationName: "Cijangkar", SourceWarehouseID: 21, ProductID: 3, ProductName: "Pakan C", OnHandQty: 200, LeftoverQty: 200, SourceType: sourceTypeKandang},
+	}
+
+	reportRows, groups := buildTransferPlan(opts, farmMap, stocks)
+	if len(groups) != 0 {
+		t.Fatalf("expected no groups, got %d", len(groups))
+	}
+	if reportRows[0].Status != "error" {
+		t.Errorf("expected error status, got %s", reportRows[0].Status)
+	}
+	if !strings.Contains(reportRows[0].Reason, "multiple_farm_warehouses") {
+		t.Errorf("reason should mention multiple_farm_warehouses, got: %s", reportRows[0].Reason)
+	}
+	// The error message must list the available warehouses so the operator knows
+	// which --farm-warehouse-id to use.
+	if !strings.Contains(reportRows[0].Reason, "Farm X") || !strings.Contains(reportRows[0].Reason, "Farm Y") {
+		t.Errorf("reason should list available warehouses, got: %s", reportRows[0].Reason)
+	}
+}
+
+func TestBuildPlanSkipsFullyAllocatedKandangStock(t *testing.T) {
+	opts := &commandOptions{RunID: "test-run"}
+	farmMap := map[uint]farmWarehouseInfo{
+		10: {LocationID: 10, AllFarm: []farmWarehouseEntry{{ID: 50, Name: "Farm A"}}, ChosenID: 50, ChosenName: "Farm A"},
+	}
+	stocks := []kandangStockRow{
+		{LocationID: 10, SourceWarehouseID: 20, ProductID: 1, ProductName: "Pakan A", OnHandQty: 100, AllocatedQty: 100, LeftoverQty: 0, SourceType: sourceTypeKandang},
+		{LocationID: 10, SourceWarehouseID: 20, ProductID: 2, ProductName: "OVK B", OnHandQty: 80, AllocatedQty: 30, LeftoverQty: 50, SourceType: sourceTypeKandang},
+	}
+
+	_, groups := buildTransferPlan(opts, farmMap, stocks)
+	if len(groups) != 1 || len(groups[0].Rows) != 1 {
+		t.Fatalf("expected 1 group with 1 eligible row, got groups=%d", len(groups))
+	}
+	if groups[0].Rows[0].ProductName != "OVK B" {
+		t.Errorf("expected only OVK B to be eligible, got %s", groups[0].Rows[0].ProductName)
+	}
+}
+
+func TestBuildPlanSkipAmbiguousDowngradesErrorToSkipped(t *testing.T) {
+	opts := &commandOptions{RunID: "test-run", SkipAmbiguous: true}
+	farmMap := map[uint]farmWarehouseInfo{
+		10: {
+			LocationID:   10,
+			LocationName: "Cijangkar",
+			AllFarm:      []farmWarehouseEntry{{ID: 60, Name: "Farm X"}, {ID: 61, Name: "Farm Y"}},
+			// ChosenID = 0: unresolved
+		},
+		11: {
+			LocationID:   11,
+			LocationName: "Jamali",
+			AllFarm:      []farmWarehouseEntry{{ID: 50, Name: "Farm A"}},
+			ChosenID:     50,
+			ChosenName:   "Farm A",
+		},
+	}
+	stocks := []kandangStockRow{
+		{LocationID: 10, LocationName: "Cijangkar", SourceWarehouseID: 21, ProductID: 3, ProductName: "Pakan C", OnHandQty: 200, LeftoverQty: 200, SourceType: sourceTypeKandang},
+		{LocationID: 11, LocationName: "Jamali", SourceWarehouseID: 20, ProductID: 1, ProductName: "Pakan A", OnHandQty: 100, LeftoverQty: 100, SourceType: sourceTypeKandang},
+	}
+
+	reportRows, groups := buildTransferPlan(opts, farmMap, stocks)
+
+	// Ambiguous location must be skipped, not error.
+	ambiguous := reportRows[0]
+	if ambiguous.LocationName != "Cijangkar" {
+		t.Fatalf("expected first row to be Cijangkar, got %s", ambiguous.LocationName)
+	}
+	if ambiguous.Status != "skipped" {
+		t.Errorf("expected skipped with --skip-ambiguous, got %s", ambiguous.Status)
+	}
+	if !strings.Contains(ambiguous.Reason, "multiple_farm_warehouses") {
+		t.Errorf("reason should still explain the cause, got: %s", ambiguous.Reason)
+	}
+
+	// Unambiguous location must still be eligible and grouped.
+	if len(groups) != 1 || groups[0].LocationName != "Jamali" {
+		t.Errorf("expected 1 group for Jamali, got %d groups", len(groups))
+	}
+}
+
+// ── applyFlagFilter (unit-level, via buildTransferPlan) ───────────────────────
+
+// applyFlagFilter is a DB-level filter so we test its effect indirectly: the
+// flag filter is applied before rows reach buildTransferPlan, so we simulate
+// by only passing stock rows that the query would have returned.
+// The real guard is that loadKandangLeftoverStocks receives the filtered set.
+// Here we verify that buildTransferPlan itself is agnostic to the filter and
+// simply processes whatever rows it is given.
+func TestBuildPlanOnlyTransfersRowsPassedToIt(t *testing.T) {
+	opts := &commandOptions{RunID: "test-run", FlagFilter: []string{"PAKAN"}}
+	farmMap := map[uint]farmWarehouseInfo{
+		10: {LocationID: 10, AllFarm: []farmWarehouseEntry{{ID: 50, Name: "Farm A"}}, ChosenID: 50, ChosenName: "Farm A"},
+	}
+	// Simulate: only PAKAN products survived the DB filter; OVK was excluded.
+	stocks := []kandangStockRow{
+		{LocationID: 10, SourceWarehouseID: 20, ProductID: 1, ProductName: "Pakan Broiler", OnHandQty: 100, LeftoverQty: 100, SourceType: sourceTypeKandang},
+	}
+
+	_, groups := buildTransferPlan(opts, farmMap, stocks)
+	if len(groups) != 1 || len(groups[0].Rows) != 1 {
+		t.Fatalf("expected 1 group with 1 row, got %d groups", len(groups))
+	}
+	if groups[0].Rows[0].ProductName != "Pakan Broiler" {
+		t.Errorf("unexpected product: %s", groups[0].Rows[0].ProductName)
+	}
+}
+
+// ── buildTransferPlan — farm_consolidation source ────────────────────────────
+
+func TestBuildPlanFarmConsolidationCreatesOwnGroup(t *testing.T) {
+	opts := &commandOptions{RunID: "test-run"}
+	// Location 10 has 2 farm warehouses; Farm B (id=51) was chosen, Farm A
+	// (id=50) is OtherFarm whose stocks need consolidating.
+	farmMap := map[uint]farmWarehouseInfo{
+		10: {
+			LocationID:   10,
+			LocationName: "Cijangkar",
+			AllFarm:      []farmWarehouseEntry{{ID: 50, Name: "Farm A"}, {ID: 51, Name: "Farm B"}},
+			ChosenID:     51,
+			ChosenName:   "Farm B",
+			OtherFarm:    []farmWarehouseEntry{{ID: 50, Name: "Farm A"}},
+		},
+	}
+	// Extra farm stock from Farm A + normal kandang stock.
+	stocks := []kandangStockRow{
+		{LocationID: 10, LocationName: "Cijangkar", SourceWarehouseID: 20, SourceWarehouseName: "Kandang K1", ProductID: 1, ProductName: "Pakan A", OnHandQty: 100, LeftoverQty: 100, SourceType: sourceTypeKandang},
+		{LocationID: 10, LocationName: "Cijangkar", SourceWarehouseID: 50, SourceWarehouseName: "Farm A", ProductID: 2, ProductName: "OVK B", OnHandQty: 60, LeftoverQty: 60, SourceType: sourceTypeFarmConsol},
+	}
+
+	reportRows, groups := buildTransferPlan(opts, farmMap, stocks)
+
+	if len(groups) != 2 {
+		t.Fatalf("expected 2 groups (one per source warehouse), got %d", len(groups))
+	}
+	if len(reportRows) != 2 {
+		t.Fatalf("expected 2 report rows, got %d", len(reportRows))
+	}
+
+	groupsBySource := make(map[uint]*transferGroup, 2)
+	for i := range groups {
+		groupsBySource[groups[i].SourceWarehouseID] = &groups[i]
+	}
+
+	kandangGroup := groupsBySource[20]
+	if kandangGroup == nil {
+		t.Fatal("expected a group with SourceWarehouseID=20")
+	}
+	if kandangGroup.SourceType != sourceTypeKandang {
+		t.Errorf("expected kandang_to_farm group, got %s", kandangGroup.SourceType)
+	}
+	if kandangGroup.FarmWarehouseID != 51 {
+		t.Errorf("expected kandang group to target Farm B (51), got %d", kandangGroup.FarmWarehouseID)
+	}
+
+	consolGroup := groupsBySource[50]
+	if consolGroup == nil {
+		t.Fatal("expected a consolidation group with SourceWarehouseID=50")
+	}
+	if consolGroup.SourceType != sourceTypeFarmConsol {
+		t.Errorf("expected farm_consolidation group, got %s", consolGroup.SourceType)
+	}
+	if consolGroup.FarmWarehouseID != 51 {
+		t.Errorf("expected consolidation group to target Farm B (51), got %d", consolGroup.FarmWarehouseID)
+	}
+}
+
+func TestBuildPlanFarmConsolidationSkipsZeroLeftover(t *testing.T) {
+	opts := &commandOptions{RunID: "test-run"}
+	farmMap := map[uint]farmWarehouseInfo{
+		10: {LocationID: 10, AllFarm: []farmWarehouseEntry{{ID: 50}, {ID: 51}}, ChosenID: 51, ChosenName: "Farm B", OtherFarm: []farmWarehouseEntry{{ID: 50, Name: "Farm A"}}},
+	}
+	stocks := []kandangStockRow{
+		{LocationID: 10, SourceWarehouseID: 50, ProductID: 1, ProductName: "Pakan A", OnHandQty: 100, AllocatedQty: 100, LeftoverQty: 0, SourceType: sourceTypeFarmConsol},
+	}
+
+	reportRows, groups := buildTransferPlan(opts, farmMap, stocks)
+	if len(groups) != 0 {
+		t.Fatalf("expected no groups, got %d", len(groups))
+	}
+	if reportRows[0].Status != "skipped" {
+		t.Errorf("expected skipped, got %s", reportRows[0].Status)
+	}
+}
+
+// ── executeApply ──────────────────────────────────────────────────────────────
+
+func TestExecuteApplyTagsReasonAndNotesWithSourceType(t *testing.T) {
+	date := time.Date(2026, 4, 24, 0, 0, 0, 0, time.UTC)
+	opts := &commandOptions{RunID: "run-apply", TransferDate: date, ActorID: 99}
+
+	groups := []transferGroup{
+		{
+			SourceType:          sourceTypeKandang,
+			LocationName:        "Jamali",
+			SourceWarehouseID:   20,
+			SourceWarehouseName: "K1",
+			FarmWarehouseID:     50,
+			FarmWarehouseName:   "Farm A",
+			Rows:                []*transferReportRow{{ProductID: 1, ProductName: "Pakan A", Qty: 100}},
+		},
+		{
+			SourceType:          sourceTypeFarmConsol,
+			LocationName:        "Cijangkar",
+			SourceWarehouseID:   60,
+			SourceWarehouseName: "Farm X",
+			FarmWarehouseID:     61,
+			FarmWarehouseName:   "Farm Y",
+			Rows:                []*transferReportRow{{ProductID: 2, ProductName: "OVK B", Qty: 40}},
+		},
+	}
+
+	executor := &fakeSystemTransferExecutor{}
+	summary, err := executeApply(context.Background(), executor, opts, groups)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if summary.GroupsApplied != 2 {
+		t.Errorf("expected 2 groups applied, got %d", summary.GroupsApplied)
+	}
+	if len(executor.createRequests) != 2 {
+		t.Fatalf("expected 2 create requests, got %d", len(executor.createRequests))
+	}
+
+	// Both requests must carry the run_id in the reason for rollback to work.
+	for i, req := range executor.createRequests {
+		if !strings.Contains(req.TransferReason, "run_id=run-apply") {
+			t.Errorf("request %d reason missing run_id: %s", i, req.TransferReason)
+		}
+	}
+
+	// Notes for farm_consolidation should be distinct from kandang_to_farm.
+	if !strings.Contains(executor.createRequests[0].StockLogNotes, "kandang to farm") {
+		t.Errorf("kandang group notes should say 'kandang to farm', got: %s", executor.createRequests[0].StockLogNotes)
+	}
+	if !strings.Contains(executor.createRequests[1].StockLogNotes, "consolidation") {
+		t.Errorf("consolidation group notes should say 'consolidation', got: %s", executor.createRequests[1].StockLogNotes)
+	}
+}
+
+func TestExecuteApplyCreatesTransferWithCorrectProductsAndRecordsTransferID(t *testing.T) {
+	date := time.Date(2026, 4, 24, 0, 0, 0, 0, time.UTC)
+	opts := &commandOptions{RunID: "run-1", TransferDate: date, ActorID: 1}
+
+	row1 := &transferReportRow{ProductID: 1, ProductName: "Pakan A", Qty: 100}
+	row2 := &transferReportRow{ProductID: 2, ProductName: "OVK B", Qty: 40}
+	groups := []transferGroup{
+		{
+			SourceType: sourceTypeKandang, SourceWarehouseID: 20, FarmWarehouseID: 50,
+			Rows: []*transferReportRow{row1, row2},
+		},
+	}
+
+	executor := &fakeSystemTransferExecutor{
+		createResponses: []*entity.StockTransfer{{Id: 1001, MovementNumber: "PND-LTI-1001"}},
+	}
+
+	_, err := executeApply(context.Background(), executor, opts, groups)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if row1.Status != "applied" || row2.Status != "applied" {
+		t.Errorf("both rows should be applied: %s, %s", row1.Status, row2.Status)
+	}
+	if row1.TransferID == nil || *row1.TransferID != 1001 {
+		t.Errorf("expected transfer id 1001, got %+v", row1.TransferID)
+	}
+	if row1.MovementNumber == nil || *row1.MovementNumber != "PND-LTI-1001" {
+		t.Errorf("expected movement number PND-LTI-1001, got %+v", row1.MovementNumber)
+	}
+
+	// Verify both products were included in the create request.
+	if len(executor.createRequests[0].Products) != 2 {
+		t.Errorf("expected 2 products in request, got %d", len(executor.createRequests[0].Products))
+	}
+}
+
+// ── executeRollback ───────────────────────────────────────────────────────────
+
+func TestExecuteRollbackDeletesDescendingAndMarksStatuses(t *testing.T) {
+	executor := &fakeSystemTransferExecutor{
+		deleteErrors: map[uint]error{200: errors.New("already consumed")},
+	}
+	rows := []rollbackDetailRow{
+		{TransferID: 100, ProductName: "Pakan A"},
+		{TransferID: 200, ProductName: "OVK B"},
+		{TransferID: 100, ProductName: "Pakan C"},
+	}
+
+	err := executeRollback(context.Background(), executor, rows, 99)
+	if err == nil || !strings.Contains(err.Error(), "already consumed") {
+		t.Fatalf("expected error for transfer 200, got: %v", err)
+	}
+	if executor.deletedTransferIDs[0] != 200 || executor.deletedTransferIDs[1] != 100 {
+		t.Fatalf("expected delete order [200 100], got %v", executor.deletedTransferIDs)
+	}
+	if rows[0].Status != "rolled_back" || rows[2].Status != "rolled_back" {
+		t.Errorf("transfer 100 rows must be rolled_back: %+v", rows)
+	}
+	if rows[1].Status != "failed" {
+		t.Errorf("transfer 200 row must be failed: %+v", rows[1])
+	}
+}
+
+func TestExecuteRollbackRequiresActorID(t *testing.T) {
+	err := executeRollback(context.Background(), &fakeSystemTransferExecutor{}, []rollbackDetailRow{{TransferID: 1}}, 0)
+	if err == nil || !strings.Contains(err.Error(), "actor-id") {
+		t.Fatalf("expected actor-id error, got: %v", err)
+	}
+}
+
+// ── buildTransferReason / buildRunReasonMatcher ───────────────────────────────
+
+func TestBuildTransferReasonMatchesRunReasonMatcher(t *testing.T) {
+	runID := "product-farm-transfer-20260424T120000.000000000Z"
+	date := time.Date(2026, 4, 24, 0, 0, 0, 0, time.UTC)
+	reason := buildTransferReason(runID, "Jamali", "Gudang K1", "Gudang Farm Jamali", date)
+
+	needle := strings.TrimSuffix(buildRunReasonMatcher(runID), "%")
+	if !strings.HasPrefix(reason, needle) {
+		t.Errorf("reason %q does not match matcher prefix %q", reason, needle)
+	}
+}
+
+func TestBuildTransferReasonSanitizesPipes(t *testing.T) {
+	reason := buildTransferReason("run-1", "Lok|asi", "Gudang|K1", "Farm|WH", time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC))
+	parts := strings.Split(reason, "|")
+	// prefix + 5 key=value segments = 6 parts
+	if len(parts) != 6 {
+		t.Errorf("expected 6 pipe-separated segments, got %d: %v", len(parts), parts)
+	}
+}
+
+func TestBuildStockLogNotesContainsSourceTypeHint(t *testing.T) {
+	date := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
+	kandangNote := buildStockLogNotes("r", "Loc", "Src", "Dst", date, sourceTypeKandang)
+	consolNote := buildStockLogNotes("r", "Loc", "Src", "Dst", date, sourceTypeFarmConsol)
+
+	if !strings.Contains(kandangNote, "kandang to farm") {
+		t.Errorf("kandang note should mention 'kandang to farm': %s", kandangNote)
+	}
+	if !strings.Contains(consolNote, "consolidation") {
+		t.Errorf("consolidation note should mention 'consolidation': %s", consolNote)
+	}
+}
+
+// ── summarizeReport ───────────────────────────────────────────────────────────
+
+func TestSummarizeReportCountsAllStatuses(t *testing.T) {
+	rows := []transferReportRow{
+		{Status: "eligible"},
+		{Status: "applied"},
+		{Status: "applied"},
+		{Status: "skipped"},
+		{Status: "error"},
+		{Status: "failed"},
+	}
+	groups := []transferGroup{{}, {}}
+	s := summarizeReport(rows, groups, 1)
+
+	if s.RowsPlanned != 4 { // eligible + 2 applied + 1 failed
+		t.Errorf("expected RowsPlanned=4, got %d", s.RowsPlanned)
+	}
+	if s.RowsApplied != 2 {
+		t.Errorf("expected RowsApplied=2, got %d", s.RowsApplied)
+	}
+	if s.RowsSkipped != 1 {
+		t.Errorf("expected RowsSkipped=1, got %d", s.RowsSkipped)
+	}
+	if s.RowsError != 1 {
+		t.Errorf("expected RowsError=1, got %d", s.RowsError)
+	}
+	if s.RowsFailed != 1 {
+		t.Errorf("expected RowsFailed=1, got %d", s.RowsFailed)
+	}
+	if s.GroupsPlanned != 2 || s.GroupsApplied != 1 {
+		t.Errorf("unexpected group counts: %+v", s)
+	}
+}

cmd/consolidate-duplicate-product-warehouses/main.go

@@ -0,0 +1,436 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"sort"
+	"strings"
+	"text/tabwriter"
+
+	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+	"gitlab.com/mbugroup/lti-api.git/internal/config"
+	"gitlab.com/mbugroup/lti-api.git/internal/database"
+	"gorm.io/gorm"
+)
+
+const (
+	outputTable = "table"
+	outputJSON  = "json"
+)
+
+type options struct {
+	Apply     bool
+	Output    string
+	DBSSLMode string
+	AreaName  string
+}
+
+type duplicateGroup struct {
+	WarehouseID            uint  `json:"warehouse_id"`
+	WarehouseName          string `json:"warehouse_name"`
+	ProductID              uint   `json:"product_id"`
+	ProductName            string `json:"product_name"`
+	AreaName               string `json:"area_name"`
+	LocationName           string `json:"location_name"`
+	ProjectFlockKandangID  *uint  `json:"project_flock_kandang_id,omitempty"`
+
+	SurvivorID       uint    `json:"survivor_id"`
+	SurvivorQty      float64 `json:"survivor_qty"`
+	AbsorbedCount    int     `json:"absorbed_count"`
+	TotalMergedQty   float64 `json:"total_merged_qty"`
+	AbsorbedIDs      string  `json:"absorbed_ids"`
+}
+
+type consolidateSummary struct {
+	TotalDuplicateGroups      int              `json:"total_duplicate_groups"`
+	TotalProductWarehouses    int64            `json:"total_product_warehouses"`
+	UpdatedReferences         map[string]int64 `json:"updated_references,omitempty"`
+	DeletedProductWarehouses  int64            `json:"deleted_product_warehouses,omitempty"`
+	OverallStatus             string           `json:"overall_status"`
+}
+
+func main() {
+	opts, err := parseFlags()
+	if err != nil {
+		log.Fatalf("invalid flags: %v", err)
+	}
+
+	if opts.DBSSLMode != "" {
+		config.DBSSLMode = opts.DBSSLMode
+	}
+
+	ctx := context.Background()
+	db := database.Connect(config.DBHost, config.DBName)
+
+	// Find duplicate groups
+	groups, err := findDuplicateProductWarehouses(ctx, db, opts)
+	if err != nil {
+		log.Fatalf("failed to find duplicates: %v", err)
+	}
+
+	if len(groups) == 0 {
+		fmt.Println("No duplicate product_warehouses found")
+		return
+	}
+
+	summary := summarizeGroups(groups)
+	if !opts.Apply {
+		renderConsolidation(opts.Output, groups, summary)
+		return
+	}
+
+	applied, err := applyConsolidation(ctx, db, groups)
+	if err != nil {
+		log.Fatalf("apply failed: %v", err)
+	}
+	renderConsolidation(opts.Output, groups, applied)
+}
+
+func parseFlags() (*options, error) {
+	var opts options
+	flag.BoolVar(&opts.Apply, "apply", false, "Apply consolidation (omit for dry-run)")
+	flag.StringVar(&opts.Output, "output", outputTable, "Output format: table or json")
+	flag.StringVar(&opts.DBSSLMode, "db-sslmode", "", "Database sslmode override")
+	flag.StringVar(&opts.AreaName, "area-name", "", "Optional area filter")
+	flag.Parse()
+
+	opts.Output = strings.ToLower(strings.TrimSpace(opts.Output))
+	opts.AreaName = strings.TrimSpace(opts.AreaName)
+	opts.DBSSLMode = strings.TrimSpace(opts.DBSSLMode)
+
+	if opts.Output == "" {
+		opts.Output = outputTable
+	}
+	if opts.Output != outputTable && opts.Output != outputJSON {
+		return nil, fmt.Errorf("unsupported --output=%s", opts.Output)
+	}
+
+	return &opts, nil
+}
+
+func findDuplicateProductWarehouses(ctx context.Context, db *gorm.DB, opts *options) ([]duplicateGroup, error) {
+	filters := ""
+	args := []any{}
+	if opts.AreaName != "" {
+		filters = "WHERE a.name = ?"
+		args = append(args, opts.AreaName)
+	}
+
+	query := fmt.Sprintf(`
+WITH duplicates AS (
+	SELECT
+		pw.warehouse_id,
+		w.name AS warehouse_name,
+		pw.product_id,
+		p.name AS product_name,
+		COALESCE(a.name, 'N/A') AS area_name,
+		COALESCE(l.name, 'N/A') AS location_name,
+		pw.project_flock_kandang_id,
+		pw.id,
+		pw.qty,
+		MIN(pw.id) OVER (PARTITION BY pw.warehouse_id, pw.product_id) AS survivor_id,
+		COUNT(*) OVER (PARTITION BY pw.warehouse_id, pw.product_id) AS duplicate_count,
+		SUM(pw.qty) OVER (PARTITION BY pw.warehouse_id, pw.product_id) AS total_qty
+	FROM product_warehouses pw
+	JOIN warehouses w ON w.id = pw.warehouse_id
+	JOIN products p ON p.id = pw.product_id
+	LEFT JOIN locations l ON l.id = w.location_id
+	LEFT JOIN areas a ON a.id = l.area_id
+	%s
+)
+SELECT
+	warehouse_id,
+	warehouse_name,
+	product_id,
+	product_name,
+	area_name,
+	location_name,
+	(SELECT project_flock_kandang_id FROM duplicates d2 WHERE d2.id = survivor_id LIMIT 1) AS project_flock_kandang_id,
+	survivor_id,
+	(SELECT qty FROM duplicates d2 WHERE d2.id = survivor_id LIMIT 1) AS survivor_qty,
+	duplicate_count - 1 AS absorbed_count,
+	total_qty AS total_merged_qty,
+	STRING_AGG(id::text, ', ' ORDER BY id::text) FILTER (WHERE id <> survivor_id) AS absorbed_ids
+FROM duplicates
+WHERE duplicate_count > 1
+GROUP BY warehouse_id, warehouse_name, product_id, product_name, area_name, location_name, survivor_id, total_qty, duplicate_count
+ORDER BY area_name, location_name, warehouse_name, product_name
+`, filters)
+
+	rows := make([]duplicateGroup, 0)
+	if err := db.WithContext(ctx).Raw(query, args...).Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+
+	return rows, nil
+}
+
+func applyConsolidation(ctx context.Context, db *gorm.DB, groups []duplicateGroup) (consolidateSummary, error) {
+	summary := consolidateSummary{
+		TotalDuplicateGroups: len(groups),
+		UpdatedReferences:    make(map[string]int64),
+		OverallStatus:        "PASS",
+	}
+
+	fifoSvc := commonSvc.NewFifoStockV2Service(db, nil)
+
+	err := db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		for _, group := range groups {
+			absorbedIDs := []uint{}
+			if group.AbsorbedIDs != "" {
+				parts := strings.Split(group.AbsorbedIDs, ", ")
+				for _, p := range parts {
+					var id uint
+					fmt.Sscanf(p, "%d", &id)
+					absorbedIDs = append(absorbedIDs, id)
+				}
+			}
+
+			if len(absorbedIDs) == 0 {
+				continue
+			}
+
+			// Update all references to point to survivor
+			refTables := []struct {
+				table  string
+				column string
+			}{
+				{"stock_allocations", "product_warehouse_id"},
+				{"stock_logs", "product_warehouse_id"},
+				{"purchase_items", "product_warehouse_id"},
+				{"recording_stocks", "product_warehouse_id"},
+				{"recording_eggs", "product_warehouse_id"},
+				{"recording_depletions", "product_warehouse_id"},
+				{"recording_depletions", "source_product_warehouse_id"},
+				{"marketing_delivery_products", "product_warehouse_id"},
+				{"marketing_products", "product_warehouse_id"},
+				{"stock_transfer_details", "source_product_warehouse_id"},
+				{"stock_transfer_details", "dest_product_warehouse_id"},
+				{"adjustment_stocks", "product_warehouse_id"},
+				{"laying_transfer_sources", "product_warehouse_id"},
+				{"laying_transfer_targets", "product_warehouse_id"},
+				{"laying_transfers", "source_product_warehouse_id"},
+				{"project_chickin_details", "product_warehouse_id"},
+				{"project_chickins", "product_warehouse_id"},
+				{"project_flock_populations", "product_warehouse_id"},
+				{"fifo_stock_v2_operation_log", "product_warehouse_id"},
+				{"fifo_stock_v2_reflow_checkpoints", "product_warehouse_id"},
+				{"fifo_stock_v2_shadow_allocations", "product_warehouse_id"},
+			}
+
+			for _, ref := range refTables {
+				res := tx.WithContext(ctx).
+					Table(ref.table).
+					Where(fmt.Sprintf("%s IN ?", ref.column), absorbedIDs).
+					Update(ref.column, group.SurvivorID)
+				if res.Error != nil {
+					return fmt.Errorf("update %s.%s: %w", ref.table, ref.column, res.Error)
+				}
+				if res.RowsAffected > 0 {
+					summary.UpdatedReferences[ref.table+"."+ref.column] += res.RowsAffected
+				}
+			}
+
+			// Update survivor qty to merged total
+			res := tx.WithContext(ctx).
+				Table("product_warehouses").
+				Where("id = ?", group.SurvivorID).
+				Update("qty", group.TotalMergedQty)
+			if res.Error != nil {
+				return fmt.Errorf("update survivor qty: %w", res.Error)
+			}
+
+			// Clear project_flock_kandang_id for LOKASI warehouse survivors
+			if err := tx.WithContext(ctx).Exec(`
+				UPDATE product_warehouses pw
+				SET project_flock_kandang_id = NULL
+				FROM warehouses w
+				WHERE pw.warehouse_id = w.id
+				  AND pw.id = ?
+				  AND UPPER(w.type) = 'LOKASI'
+				  AND pw.project_flock_kandang_id IS NOT NULL
+			`, group.SurvivorID).Error; err != nil {
+				return fmt.Errorf("clear project_flock_kandang_id survivor %d: %w", group.SurvivorID, err)
+			}
+
+			// Delete absorbed product_warehouses
+			res = tx.WithContext(ctx).
+				Table("product_warehouses").
+				Where("id IN ?", absorbedIDs).
+				Delete(nil)
+			if res.Error != nil {
+				return fmt.Errorf("delete absorbed: %w", res.Error)
+			}
+			summary.DeletedProductWarehouses += res.RowsAffected
+
+			// Recalculate stock_logs for survivor
+			if err := recalculateStockLogs(ctx, tx, []uint{group.SurvivorID}); err != nil {
+				return fmt.Errorf("recalculate stock_logs: %w", err)
+			}
+
+			// Reflow and recalculate FIFO
+			if err := reflowProductWarehouse(ctx, fifoSvc, tx, group.SurvivorID); err != nil {
+				return fmt.Errorf("reflow product_warehouse %d: %w", group.SurvivorID, err)
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		summary.OverallStatus = "FAIL"
+		return summary, err
+	}
+
+	return summary, nil
+}
+
+func recalculateStockLogs(ctx context.Context, tx *gorm.DB, productWarehouseIDs []uint) error {
+	if len(productWarehouseIDs) == 0 {
+		return nil
+	}
+
+	query := `
+WITH recalculated AS (
+	SELECT
+		id,
+		SUM(COALESCE(increase, 0) - COALESCE(decrease, 0))
+			OVER (PARTITION BY product_warehouse_id ORDER BY created_at ASC, id ASC) AS running_stock
+	FROM stock_logs
+	WHERE product_warehouse_id IN ?
+)
+UPDATE stock_logs sl
+SET stock = recalculated.running_stock
+FROM recalculated
+WHERE sl.id = recalculated.id
+`
+	return tx.WithContext(ctx).Exec(query, productWarehouseIDs).Error
+}
+
+func reflowProductWarehouse(ctx context.Context, fifoSvc commonSvc.FifoStockV2Service, tx *gorm.DB, productWarehouseID uint) error {
+	type row struct {
+		FlagGroupCode string `gorm:"column:flag_group_code"`
+	}
+
+	var selected row
+	err := tx.WithContext(ctx).
+		Table("fifo_stock_v2_route_rules rr").
+		Select("rr.flag_group_code").
+		Joins("JOIN fifo_stock_v2_flag_groups fg ON fg.code = rr.flag_group_code AND fg.is_active = TRUE").
+		Where("rr.is_active = TRUE").
+		Where("rr.lane = ?", "STOCKABLE").
+		Where("rr.function_code = ?", "PURCHASE_IN").
+		Where("rr.source_table = ?", "purchase_items").
+		Where(`EXISTS (
+			SELECT 1
+			FROM product_warehouses pw
+			JOIN flags f ON f.flagable_id = pw.product_id
+			JOIN fifo_stock_v2_flag_members fm ON fm.flag_name = f.name AND fm.is_active = TRUE
+			WHERE pw.id = ?
+			  AND f.flagable_type = 'products'
+			  AND fm.flag_group_code = rr.flag_group_code
+		)`, productWarehouseID).
+		Order("rr.id ASC").
+		Limit(1).
+		Take(&selected).Error
+
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return err
+	}
+
+	if err == gorm.ErrRecordNotFound {
+		return nil
+	}
+
+	flagGroupCode := strings.TrimSpace(selected.FlagGroupCode)
+
+	if _, err := fifoSvc.Reflow(ctx, commonSvc.FifoStockV2ReflowRequest{
+		FlagGroupCode:      flagGroupCode,
+		ProductWarehouseID: productWarehouseID,
+		Tx:                 tx,
+	}); err != nil {
+		return err
+	}
+
+	if _, err := fifoSvc.Recalculate(ctx, commonSvc.FifoStockV2RecalculateRequest{
+		ProductWarehouseIDs: []uint{productWarehouseID},
+		FlagGroupCodes:      []string{flagGroupCode},
+		FixDrift:            true,
+		Tx:                  tx,
+	}); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func summarizeGroups(groups []duplicateGroup) consolidateSummary {
+	var totalQty int64
+	for _, g := range groups {
+		totalQty += int64(g.AbsorbedCount)
+	}
+
+	return consolidateSummary{
+		TotalDuplicateGroups: len(groups),
+		TotalProductWarehouses: totalQty,
+		OverallStatus: "PASS",
+	}
+}
+
+func renderConsolidation(mode string, groups []duplicateGroup, summary consolidateSummary) {
+	if mode == outputJSON {
+		payload := map[string]any{
+			"groups":  groups,
+			"summary": summary,
+		}
+		enc := json.NewEncoder(os.Stdout)
+		enc.SetIndent("", "  ")
+		_ = enc.Encode(payload)
+		return
+	}
+
+	w := tabwriter.NewWriter(os.Stdout, 2, 8, 2, ' ', 0)
+	fmt.Fprintln(w, "AREA\tLOCATION\tWAREHOUSE\tPRODUCT\tPFK_ID\tSURVIVOR_ID\tSURVIVOR_QTY\tABSORBED_COUNT\tTOTAL_MERGED_QTY\tABSORBED_IDS")
+	for _, g := range groups {
+		pfkID := "-"
+		if g.ProjectFlockKandangID != nil {
+			pfkID = fmt.Sprintf("%d", *g.ProjectFlockKandangID)
+		}
+		fmt.Fprintf(
+			w,
+			"%s\t%s\t%s\t%s\t%s\t%d\t%.3f\t%d\t%.3f\t%s\n",
+			g.AreaName,
+			g.LocationName,
+			g.WarehouseName,
+			g.ProductName,
+			pfkID,
+			g.SurvivorID,
+			g.SurvivorQty,
+			g.AbsorbedCount,
+			g.TotalMergedQty,
+			g.AbsorbedIDs,
+		)
+	}
+	_ = w.Flush()
+
+	fmt.Printf("\n=== SUMMARY ===\n")
+	fmt.Printf("Duplicate groups found: %d\n", summary.TotalDuplicateGroups)
+	fmt.Printf("Product warehouses to delete: %d\n", summary.TotalProductWarehouses)
+	fmt.Printf("Overall status: %s\n", summary.OverallStatus)
+
+	if len(summary.UpdatedReferences) > 0 {
+		fmt.Println("\nUpdated references:")
+		keys := make([]string, 0, len(summary.UpdatedReferences))
+		for k := range summary.UpdatedReferences {
+			keys = append(keys, k)
+		}
+		sort.Strings(keys)
+		for _, k := range keys {
+			fmt.Printf("  %s=%d\n", k, summary.UpdatedReferences[k])
+		}
+	}
+}

cmd/consolidate-kandang-to-farm-stocks/main.go

@@ -26,12 +26,14 @@ const (
 )
 
 type options struct {
-	Apply                 bool
-	Output                string
-	AreaName              string
-	KandangLocationName   string
-	DBSSLMode             string
-	DeleteKandangWarehouses bool
+	Apply                        bool
+	Output                       string
+	AreaName                     string
+	KandangLocationName          string
+	DBSSLMode                    string
+	DeleteKandangWarehouses      bool
+	SkipBlockedRefsCheck         bool
+	SkipIncompleteLocations      bool
 }
 
 type consolidateRow struct {
@@ -132,7 +134,7 @@ func main() {
 		log.Fatalf("failed to inspect warehouse references: %v", err)
 	}
 
-	if err := runPrechecks(ctx, db, rows, refs); err != nil {
+	if err := runPrechecks(ctx, db, rows, refs, opts); err != nil {
 		log.Fatalf("precheck failed: %v", err)
 	}
 
@@ -157,6 +159,8 @@ func parseFlags() (*options, error) {
 	flag.StringVar(&opts.KandangLocationName, "kandang-location-name", "", "Optional exact canonical kandang location filter")
 	flag.StringVar(&opts.DBSSLMode, "db-sslmode", "", "Optional database sslmode override, for example: require")
 	flag.BoolVar(&opts.DeleteKandangWarehouses, "delete-kandang-warehouses", true, "Soft delete kandang warehouse rows after all stocks have been moved")
+	flag.BoolVar(&opts.SkipBlockedRefsCheck, "skip-blocked-refs-check", false, "Skip blocked references check (use with caution - only if you understand the stock_transfers references)")
+	flag.BoolVar(&opts.SkipIncompleteLocations, "skip-incomplete-locations", false, "Skip locations that don't have farm-level warehouses and process the rest")
 	flag.Parse()
 
 	opts.Output = strings.ToLower(strings.TrimSpace(opts.Output))
@@ -186,6 +190,12 @@ func loadConsolidateRows(ctx context.Context, db *gorm.DB, opts *options) ([]con
 		args = append(args, opts.KandangLocationName)
 	}
 
+	// If skipping incomplete locations, filter out NULL farm warehouses
+	whereClause := ""
+	if opts.SkipIncompleteLocations {
+		whereClause = "AND fw.id IS NOT NULL"
+	}
+
 	query := fmt.Sprintf(`
 SELECT
 	a.name AS area_name,
@@ -224,7 +234,10 @@ JOIN product_warehouses wp
 	ON wp.warehouse_id = w.id
 JOIN products p
 	ON p.id = wp.product_id
-   AND UPPER(COALESCE(p.type, '')) IN ('PAKAN', 'OVK')
+JOIN flags f
+	ON f.flagable_id = p.id
+   AND f.flagable_type = 'products'
+   AND UPPER(f.name) IN ('PAKAN', 'OVK')
 LEFT JOIN product_warehouses fpw
 	ON fpw.product_id = wp.product_id
    AND fpw.warehouse_id = fw.id
@@ -246,8 +259,11 @@ WHERE w.deleted_at IS NULL
 	  AND sa.deleted_at IS NULL
   )
   %s
+  %s
 ORDER BY a.name ASC, kl.name ASC, k.name ASC, wp.id ASC
-`, andClause(filters))
+`,
+		andClause(filters),
+		whereClause)
 
 	rows := make([]consolidateRow, 0)
 	if err := db.WithContext(ctx).Raw(query, args...).Scan(&rows).Error; err != nil {
@@ -297,9 +313,12 @@ func buildReferencePlan(ctx context.Context, db *gorm.DB) (*referencePlan, error
 	}, nil
 }
 
-func runPrechecks(ctx context.Context, db *gorm.DB, rows []consolidateRow, refs *referencePlan) error {
-	if err := ensureNoBlockedWarehouseRefsConsolidate(ctx, db, rows, refs.BlockedWarehouseRefs); err != nil {
-		return err
+func runPrechecks(ctx context.Context, db *gorm.DB, rows []consolidateRow, refs *referencePlan, opts *options) error {
+	// Only check blocked references if we're actually deleting the warehouses
+	if opts.DeleteKandangWarehouses && !opts.SkipBlockedRefsCheck {
+		if err := ensureNoBlockedWarehouseRefsConsolidate(ctx, db, rows, refs.BlockedWarehouseRefs); err != nil {
+			return err
+		}
 	}
 	if err := ensureNoPurchaseItemWarehouseConflictsConsolidate(ctx, db, rows); err != nil {
 		return err
@@ -710,6 +729,9 @@ func reflowAndRecalculateProductWarehouse(
 	if err != nil {
 		return fmt.Errorf("resolve flag group for product_warehouse %d: %w", productWarehouseID, err)
 	}
+	if flagGroupCode == "" {
+		return nil
+	}
 
 	if _, err := fifoSvc.Reflow(ctx, commonSvc.FifoStockV2ReflowRequest{
 		FlagGroupCode:      flagGroupCode,
@@ -759,6 +781,9 @@ func resolveFlagGroupByProductWarehouse(ctx context.Context, tx *gorm.DB, produc
 		Order("rr.id ASC").
 		Limit(1).
 		Take(&selected).Error
+	if err == gorm.ErrRecordNotFound {
+		return "", nil
+	}
 	if err != nil {
 		return "", err
 	}

cmd/fix-stock-log-drift/main.go

@@ -0,0 +1,387 @@
+// Command: fix-stock-log-drift
+//
+// Tujuan:
+//   Sinkronkan `stock_logs.stock` (running ledger) dengan `product_warehouses.qty`
+//   (FIFO truth) ketika keduanya drift.
+//
+// Drift biasanya terjadi karena bug di Recording-Edit (sebelum fix) yang
+// hanya menulis -decrease tanpa +increase saat in-place update. Akibatnya
+// running ledger di stock_logs tertinggal dari qty riil di product_warehouses.
+//
+// Cara kerja:
+//   1. Ambil product_warehouses.qty (sebagai truth)
+//   2. Ambil last_stock_log.stock
+//   3. Cari recording yang berkontribusi pada drift (untuk notes)
+//   4. Hitung drift = qty - last_stock_log.stock
+//   5. Jika drift != 0, insert 1 stock_log corrective:
+//        - drift > 0 → increase = drift
+//        - drift < 0 → decrease = |drift|
+//      stock akhir akan sama dengan qty (truth).
+//   Notes otomatis berisi daftar recording IDs yang berkontribusi pada drift.
+//
+// Mode:
+//   --apply=false  (default) → dry-run, hanya tampilkan rencana
+//   --apply=true            → eksekusi insert
+//
+// Contoh:
+//   go run cmd/fix-stock-log-drift/main.go --product-warehouse-id=1261
+//   go run cmd/fix-stock-log-drift/main.go --product-warehouse-id=1261 --apply
+//   go run cmd/fix-stock-log-drift/main.go --product-warehouse-id=1261 --apply \
+//       --actor-id=1 --notes="Koreksi manual drift"
+
+package main
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"log"
+	"math"
+	"os"
+	"strings"
+	"time"
+
+	"gitlab.com/mbugroup/lti-api.git/internal/config"
+	"gitlab.com/mbugroup/lti-api.git/internal/database"
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gorm.io/gorm"
+)
+
+const (
+	qtyEpsilon          = 1e-6
+	defaultActorID uint = 1
+	maxSuspectInNotes   = 30
+)
+
+type driftRow struct {
+	ProductWarehouseID uint    `gorm:"column:product_warehouse_id"`
+	ProductID          uint    `gorm:"column:product_id"`
+	ProductName        string  `gorm:"column:product_name"`
+	WarehouseName      string  `gorm:"column:warehouse_name"`
+	CurrentQty         float64 `gorm:"column:current_qty"`
+	LastLogStock       float64 `gorm:"column:last_log_stock"`
+	LastLogID          uint    `gorm:"column:last_log_id"`
+	FifoExpected       float64 `gorm:"column:fifo_expected"`
+}
+
+type suspectRecording struct {
+	RecordingID    uint    `gorm:"column:recording_id"`
+	FifoUsage      float64 `gorm:"column:fifo_usage"`
+	NetLogConsumed float64 `gorm:"column:net_log_consumed"`
+	Phantom        float64 `gorm:"column:phantom"`
+}
+
+func main() {
+	var (
+		productWarehouseID uint
+		apply              bool
+		actorID            uint
+		notes              string
+	)
+
+	flag.UintVar(&productWarehouseID, "product-warehouse-id", 0, "Target product_warehouse_id (required)")
+	flag.BoolVar(&apply, "apply", false, "Apply changes. If false, run as dry-run")
+	flag.UintVar(&actorID, "actor-id", defaultActorID, "User id yang akan dicatat sebagai created_by stock_log corrective")
+	flag.StringVar(&notes, "notes", "", "Custom notes untuk stock_log corrective (opsional, default=auto-generate dari data recording)")
+	flag.Parse()
+
+	notes = strings.TrimSpace(notes)
+	if err := validateFlags(productWarehouseID, actorID); err != nil {
+		log.Fatalf("invalid flags: %v", err)
+	}
+
+	ctx := context.Background()
+	db := database.Connect(config.DBHost, config.DBName)
+
+	row, err := loadDriftRow(ctx, db, productWarehouseID)
+	if err != nil {
+		log.Fatalf("failed to load product warehouse: %v", err)
+	}
+
+	suspects, err := loadSuspectRecordings(ctx, db, productWarehouseID)
+	if err != nil {
+		log.Fatalf("failed to load suspect recordings: %v", err)
+	}
+
+	drift := row.CurrentQty - row.LastLogStock
+
+	// Print info header
+	fmt.Printf("Mode: %s\n", modeLabel(apply))
+	fmt.Printf("Target product_warehouse_id: %d\n", productWarehouseID)
+	fmt.Printf("Product: %q\n", row.ProductName)
+	fmt.Printf("Warehouse: %q\n", row.WarehouseName)
+	fmt.Printf("Current qty (product_warehouses): %.3f\n", row.CurrentQty)
+	fmt.Printf("FIFO expected (sum total_qty - total_used): %.3f\n", row.FifoExpected)
+	fmt.Printf("Last stock_log: id=%d stock=%.3f\n", row.LastLogID, row.LastLogStock)
+	fmt.Printf("Drift (qty - last_log_stock): %+.3f\n", drift)
+
+	if !nearlyEqual(row.CurrentQty, row.FifoExpected) {
+		fmt.Println()
+		fmt.Println("⚠️  WARNING: product_warehouses.qty TIDAK match dengan FIFO expected.")
+		fmt.Println("   Disarankan jalankan dulu cmd/reflow-quantity-product-warehouse-from-stock-allocation")
+		fmt.Println("   sebelum fix stock_log drift, agar truth source-nya sudah benar.")
+	}
+
+	// Print suspect recordings
+	fmt.Println()
+	if len(suspects) > 0 {
+		totalPhantom := 0.0
+		for _, s := range suspects {
+			totalPhantom += s.Phantom
+		}
+		fmt.Printf("Suspect recordings (drift contributors): %d\n", len(suspects))
+		for _, s := range suspects {
+			fmt.Printf(
+				"  #%-6d  fifo=%-10.3f  net_log=%-10.3f  phantom=%+.3f\n",
+				s.RecordingID, s.FifoUsage, s.NetLogConsumed, s.Phantom,
+			)
+		}
+		fmt.Printf("Total suspect phantom: %+.3f\n", totalPhantom)
+	} else {
+		fmt.Println("Suspect recordings: none found (drift origin unknown)")
+	}
+	fmt.Println()
+
+	if nearlyEqual(drift, 0) {
+		fmt.Println("✓ Tidak ada drift. Stock_log sudah sinkron dengan product_warehouses.qty.")
+		fmt.Println("Summary: planned=0 inserted=0 skipped=1 failed=0")
+		return
+	}
+
+	// Build notes if not provided
+	if notes == "" {
+		notes = buildDefaultNotes(row, drift, suspects)
+	}
+
+	plan := buildCorrectiveLog(row, drift, actorID, notes)
+
+	fmt.Printf(
+		"PLAN insert stock_log:\n  pw=%d  increase=%.3f  decrease=%.3f  stock=%.3f\n  notes=%q\n",
+		plan.ProductWarehouseId,
+		plan.Increase,
+		plan.Decrease,
+		plan.Stock,
+		plan.Notes,
+	)
+
+	if !apply {
+		fmt.Println()
+		fmt.Println("Summary: planned=1 inserted=0 skipped=0 failed=0 (dry-run)")
+		return
+	}
+
+	if err := db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		// Re-check di dalam transaction agar aman dari race condition
+		current, err := loadDriftRow(ctx, tx, productWarehouseID)
+		if err != nil {
+			return fmt.Errorf("re-read product_warehouse_id=%d: %w", productWarehouseID, err)
+		}
+		currentDrift := current.CurrentQty - current.LastLogStock
+		if nearlyEqual(currentDrift, 0) {
+			fmt.Println("Drift hilang sebelum insert (kemungkinan ada operasi paralel). Skip.")
+			return nil
+		}
+		fresh := buildCorrectiveLog(current, currentDrift, actorID, notes)
+		if err := tx.Create(&fresh).Error; err != nil {
+			return fmt.Errorf("insert corrective stock_log for pw=%d: %w", productWarehouseID, err)
+		}
+		fmt.Printf(
+			"DONE inserted stock_log id=%d pw=%d increase=%.3f decrease=%.3f stock=%.3f\n",
+			fresh.Id,
+			fresh.ProductWarehouseId,
+			fresh.Increase,
+			fresh.Decrease,
+			fresh.Stock,
+		)
+		return nil
+	}); err != nil {
+		fmt.Println()
+		fmt.Println("Summary: planned=1 inserted=0 skipped=0 failed=1")
+		log.Printf("error: %v", err)
+		os.Exit(1)
+	}
+
+	fmt.Println()
+	fmt.Println("Summary: planned=1 inserted=1 skipped=0 failed=0")
+}
+
+func validateFlags(productWarehouseID uint, actorID uint) error {
+	if productWarehouseID == 0 {
+		return errors.New("--product-warehouse-id is required (must be > 0)")
+	}
+	if actorID == 0 {
+		return errors.New("--actor-id must be > 0")
+	}
+	return nil
+}
+
+func loadDriftRow(ctx context.Context, db *gorm.DB, productWarehouseID uint) (driftRow, error) {
+	row := driftRow{}
+
+	lastLogSub := db.WithContext(ctx).
+		Table("stock_logs").
+		Select("id, product_warehouse_id, stock").
+		Where("product_warehouse_id = ?", productWarehouseID).
+		Order("id DESC").
+		Limit(1)
+
+	fifoSub := db.WithContext(ctx).
+		Table("purchase_items").
+		Select(`
+			product_warehouse_id,
+			COALESCE(SUM(COALESCE(total_qty, 0) - COALESCE(total_used, 0)), 0) AS fifo_expected
+		`).
+		Where("product_warehouse_id = ?", productWarehouseID).
+		Group("product_warehouse_id")
+
+	if err := db.WithContext(ctx).
+		Table("product_warehouses pw").
+		Select(`
+			pw.id AS product_warehouse_id,
+			pw.product_id AS product_id,
+			COALESCE(p.name, '') AS product_name,
+			COALESCE(w.name, '') AS warehouse_name,
+			COALESCE(pw.qty, 0) AS current_qty,
+			COALESCE(last_log.stock, 0) AS last_log_stock,
+			COALESCE(last_log.id, 0) AS last_log_id,
+			COALESCE(fifo.fifo_expected, 0) AS fifo_expected
+		`).
+		Joins("LEFT JOIN products p ON p.id = pw.product_id").
+		Joins("LEFT JOIN warehouses w ON w.id = pw.warehouse_id").
+		Joins("LEFT JOIN (?) last_log ON last_log.product_warehouse_id = pw.id", lastLogSub).
+		Joins("LEFT JOIN (?) fifo ON fifo.product_warehouse_id = pw.id", fifoSub).
+		Where("pw.id = ?", productWarehouseID).
+		Scan(&row).Error; err != nil {
+		return row, err
+	}
+
+	if row.ProductWarehouseID == 0 {
+		return row, fmt.Errorf("product_warehouse_id=%d not found", productWarehouseID)
+	}
+
+	return row, nil
+}
+
+// loadSuspectRecordings mencari recording yang net stock_log consumed-nya
+// melebihi FIFO usage_qty — ini adalah recording yang berkontribusi pada drift
+// akibat bug Recording-Edit yang hanya menulis -decrease tanpa +increase.
+func loadSuspectRecordings(ctx context.Context, db *gorm.DB, productWarehouseID uint) ([]suspectRecording, error) {
+	rows := make([]suspectRecording, 0)
+	if err := db.WithContext(ctx).
+		Table("recording_stocks rs").
+		Select(`
+			rs.recording_id,
+			COALESCE(rs.usage_qty, 0) AS fifo_usage,
+			(
+				COALESCE(SUM(CASE WHEN sl.decrease > 0 THEN sl.decrease ELSE 0 END), 0) -
+				COALESCE(SUM(CASE WHEN sl.increase > 0 THEN sl.increase ELSE 0 END), 0)
+			) AS net_log_consumed,
+			(
+				COALESCE(SUM(CASE WHEN sl.decrease > 0 THEN sl.decrease ELSE 0 END), 0) -
+				COALESCE(SUM(CASE WHEN sl.increase > 0 THEN sl.increase ELSE 0 END), 0) -
+				COALESCE(rs.usage_qty, 0)
+			) AS phantom
+		`).
+		Joins(`
+			JOIN stock_logs sl ON sl.loggable_type = ?
+				AND sl.loggable_id = rs.recording_id
+				AND sl.product_warehouse_id = rs.product_warehouse_id
+		`, string(utils.StockLogTypeRecording)).
+		Where("rs.product_warehouse_id = ?", productWarehouseID).
+		Group("rs.recording_id, rs.usage_qty").
+		Having(`
+			ABS(
+				COALESCE(SUM(CASE WHEN sl.decrease > 0 THEN sl.decrease ELSE 0 END), 0) -
+				COALESCE(SUM(CASE WHEN sl.increase > 0 THEN sl.increase ELSE 0 END), 0) -
+				COALESCE(rs.usage_qty, 0)
+			) > ?
+		`, qtyEpsilon).
+		Order("rs.recording_id ASC").
+		Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
+// buildDefaultNotes membuat notes otomatis yang berisi penjelasan drift
+// beserta daftar recording_id yang berkontribusi + phantom amount masing-masing.
+func buildDefaultNotes(row driftRow, drift float64, suspects []suspectRecording) string {
+	sign := "+"
+	if drift < 0 {
+		sign = ""
+	}
+
+	var sb strings.Builder
+	sb.WriteString(fmt.Sprintf(
+		"Koreksi drift stock_log akibat bug Recording-Edit (in-place update menulis -decrease tanpa +increase). PW=%d (%s) drift=%s%.3f.",
+		row.ProductWarehouseID,
+		row.WarehouseName,
+		sign,
+		drift,
+	))
+
+	if len(suspects) == 0 {
+		return sb.String()
+	}
+
+	sb.WriteString(" Recordings affected:")
+
+	limit := len(suspects)
+	truncated := 0
+	if limit > maxSuspectInNotes {
+		truncated = limit - maxSuspectInNotes
+		limit = maxSuspectInNotes
+	}
+
+	for i := 0; i < limit; i++ {
+		s := suspects[i]
+		phantomSign := "+"
+		if s.Phantom < 0 {
+			phantomSign = ""
+		}
+		sb.WriteString(fmt.Sprintf(" #%d(%s%.0f)", s.RecordingID, phantomSign, s.Phantom))
+		if i < limit-1 || truncated > 0 {
+			sb.WriteString(",")
+		}
+	}
+
+	if truncated > 0 {
+		sb.WriteString(fmt.Sprintf(" ... (+%d more)", truncated))
+	}
+
+	sb.WriteString(".")
+	return sb.String()
+}
+
+func buildCorrectiveLog(row driftRow, drift float64, actorID uint, notes string) entity.StockLog {
+	corrective := entity.StockLog{
+		ProductWarehouseId: row.ProductWarehouseID,
+		CreatedBy:          actorID,
+		LoggableType:       string(utils.StockLogTypeAdjustment),
+		LoggableId:         0,
+		Stock:              row.CurrentQty,
+		Notes:              notes,
+		CreatedAt:          time.Now(),
+	}
+	if drift > 0 {
+		corrective.Increase = drift
+		corrective.Decrease = 0
+	} else {
+		corrective.Increase = 0
+		corrective.Decrease = -drift
+	}
+	return corrective
+}
+
+func modeLabel(apply bool) string {
+	if apply {
+		return "APPLY"
+	}
+	return "DRY-RUN"
+}
+
+func nearlyEqual(a, b float64) bool {
+	return math.Abs(a-b) <= qtyEpsilon
+}

cmd/repoint-wrong-warehouse-relations/main.go

@@ -26,12 +26,13 @@ const (
 )
 
 type options struct {
-	Apply                 bool
-	Output                string
-	AreaName              string
-	KandangLocationName   string
-	DBSSLMode             string
-	DeleteWrongWarehouses bool
+	Apply                        bool
+	Output                       string
+	AreaName                     string
+	KandangLocationName          string
+	DBSSLMode                    string
+	DeleteWrongWarehouses        bool
+	AllowMovingAllocatedStocks   bool
 }
 
 type planRow struct {
@@ -123,6 +124,16 @@ func main() {
 		log.Fatalf("failed to load plan rows: %v", err)
 	}
 
+	if opts.AllowMovingAllocatedStocks {
+		allocatedRows, err := loadPlanRowsWithAllocations(ctx, db, opts)
+		if err != nil {
+			log.Fatalf("failed to load allocated plan rows: %v", err)
+		}
+		rows = append(rows, allocatedRows...)
+		// Remove duplicates
+		rows = deduplicatePlanRows(rows)
+	}
+
 	if len(rows) == 0 {
 		fmt.Println("No misplaced PAKAN/OVK stocks found in wrong-location warehouses")
 		return
@@ -158,6 +169,7 @@ func parseFlags() (*options, error) {
 	flag.StringVar(&opts.KandangLocationName, "kandang-location-name", "", "Optional exact canonical kandang location filter")
 	flag.StringVar(&opts.DBSSLMode, "db-sslmode", "", "Optional database sslmode override, for example: require")
 	flag.BoolVar(&opts.DeleteWrongWarehouses, "delete-wrong-warehouses", true, "Soft delete wrong warehouse rows after all references have been moved")
+	flag.BoolVar(&opts.AllowMovingAllocatedStocks, "allow-moving-allocated-stocks", false, "Allow moving stocks that have active allocations (use with caution - for old recordings with completed allocations)")
 	flag.Parse()
 
 	opts.Output = strings.ToLower(strings.TrimSpace(opts.Output))
@@ -175,6 +187,90 @@ func parseFlags() (*options, error) {
 	return &opts, nil
 }
 
+func deduplicatePlanRows(rows []planRow) []planRow {
+	seen := make(map[uint]struct{})
+	result := make([]planRow, 0, len(rows))
+	for _, row := range rows {
+		if _, ok := seen[row.SurvivorPWID]; !ok {
+			seen[row.SurvivorPWID] = struct{}{}
+			result = append(result, row)
+		}
+	}
+	return result
+}
+
+func loadPlanRowsWithAllocations(ctx context.Context, db *gorm.DB, opts *options) ([]planRow, error) {
+	filters := make([]string, 0, 2)
+	args := make([]any, 0, 2)
+	if opts.AreaName != "" {
+		filters = append(filters, "a.name = ?")
+		args = append(args, opts.AreaName)
+	}
+	if opts.KandangLocationName != "" {
+		filters = append(filters, "kl.name = ?")
+		args = append(args, opts.KandangLocationName)
+	}
+
+	query := fmt.Sprintf(`
+SELECT
+	a.name AS area_name,
+	kl.name AS kandang_location_name,
+	k.id AS kandang_id,
+	k.name AS kandang_name,
+	w.id AS wrong_warehouse_id,
+	w.name AS wrong_warehouse_name,
+	correct_w.id AS correct_warehouse_id,
+	correct_w.name AS correct_warehouse_name,
+	p.id AS product_id,
+	p.name AS product_name,
+	wp.project_flock_kandang_id,
+	wp.id AS survivor_pw_id,
+	COALESCE(wp.qty, 0) AS survivor_current_qty,
+	cpw.id AS absorbed_pw_id,
+	cpw.qty AS absorbed_current_qty
+FROM warehouses w
+JOIN kandangs k
+	ON k.id = w.kandang_id
+   AND k.deleted_at IS NULL
+JOIN locations kl
+	ON kl.id = k.location_id
+JOIN areas a
+	ON a.id = kl.area_id
+JOIN LATERAL (
+	SELECT w2.id, w2.name
+	FROM warehouses w2
+	WHERE w2.location_id = k.location_id
+	  AND UPPER(COALESCE(w2.type, '')) = 'LOKASI'
+	  AND w2.deleted_at IS NULL
+	ORDER BY w2.id ASC
+	LIMIT 1
+) AS correct_w ON TRUE
+JOIN product_warehouses wp
+	ON wp.warehouse_id = w.id
+JOIN products p
+	ON p.id = wp.product_id
+JOIN flags f
+	ON f.flagable_id = p.id
+   AND f.flagable_type = 'products'
+   AND UPPER(f.name) IN ('PAKAN', 'OVK')
+LEFT JOIN product_warehouses cpw
+	ON cpw.product_id = wp.product_id
+   AND cpw.warehouse_id = correct_w.id
+   AND cpw.project_flock_kandang_id IS NOT DISTINCT FROM wp.project_flock_kandang_id
+WHERE w.deleted_at IS NULL
+  AND w.kandang_id IS NOT NULL
+  AND w.location_id IS DISTINCT FROM k.location_id
+  %s
+ORDER BY a.name ASC, kl.name ASC, k.name ASC, wp.id ASC
+`, andClause(filters))
+
+	rows := make([]planRow, 0)
+	if err := db.WithContext(ctx).Raw(query, args...).Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
 func loadPlanRows(ctx context.Context, db *gorm.DB, opts *options) ([]planRow, error) {
 	filters := make([]string, 0, 2)
 	args := make([]any, 0, 2)
@@ -225,7 +321,10 @@ JOIN product_warehouses wp
 	ON wp.warehouse_id = w.id
 JOIN products p
 	ON p.id = wp.product_id
-   AND UPPER(COALESCE(p.type, '')) IN ('PAKAN', 'OVK')
+JOIN flags f
+	ON f.flagable_id = p.id
+   AND f.flagable_type = 'products'
+   AND UPPER(f.name) IN ('PAKAN', 'OVK')
 LEFT JOIN product_warehouses cpw
 	ON cpw.product_id = wp.product_id
    AND cpw.warehouse_id = correct_w.id
@@ -301,8 +400,10 @@ func buildReferencePlan(ctx context.Context, db *gorm.DB) (*referencePlan, error
 }
 
 func runPrechecks(ctx context.Context, db *gorm.DB, rows []planRow, refs *referencePlan, opts *options) error {
-	if err := ensureNoBlockedWarehouseRefs(ctx, db, rows, refs.BlockedWarehouseRefs); err != nil {
-		return err
+	if opts.DeleteWrongWarehouses {
+		if err := ensureNoBlockedWarehouseRefs(ctx, db, rows, refs.BlockedWarehouseRefs); err != nil {
+			return err
+		}
 	}
 	if err := ensureNoPurchaseItemWarehouseConflicts(ctx, db, rows); err != nil {
 		return err
@@ -714,6 +815,9 @@ func reflowAndRecalculateProductWarehouse(
 	if err != nil {
 		return fmt.Errorf("resolve flag group for product_warehouse %d: %w", productWarehouseID, err)
 	}
+	if flagGroupCode == "" {
+		return nil
+	}
 
 	if _, err := fifoSvc.Reflow(ctx, commonSvc.FifoStockV2ReflowRequest{
 		FlagGroupCode:      flagGroupCode,
@@ -763,6 +867,9 @@ func resolveFlagGroupByProductWarehouse(ctx context.Context, tx *gorm.DB, produc
 		Order("rr.id ASC").
 		Limit(1).
 		Take(&selected).Error
+	if err == gorm.ErrRecordNotFound {
+		return "", nil
+	}
 	if err != nil {
 		return "", err
 	}

cmd/verify-stock-consolidation/main.go

@@ -19,9 +19,9 @@ const (
 	outputTable = "table"
 	outputJSON  = "json"
 
-	caseA = "A"
-	caseB = "B"
-	caseAll = "all"
+	caseA   = "A"
+	caseB   = "B"
+	caseAll = "ALL"
 )
 
 type options struct {
@@ -39,7 +39,7 @@ type sourceWarehouseCheck struct {
 	KandangName           string  `json:"kandang_name"`
 	SourceWarehouseID     uint    `json:"source_warehouse_id"`
 	SourceWarehouseName   string  `json:"source_warehouse_name"`
-	Case                  string  `json:"case"`
+	Case                  string  `json:"case" gorm:"column:case_type"`
 	DeletedAt             *string `json:"deleted_at"`
 	StockInProductWH      float64 `json:"stock_in_product_wh"`
 	ActivePurchaseItems   int64   `json:"active_purchase_items"`
@@ -145,7 +145,7 @@ func parseFlags() (*options, error) {
 }
 
 func verifySourceWarehouses(ctx context.Context, db *gorm.DB, opts *options) ([]sourceWarehouseCheck, error) {
-	filters := buildFilters(opts)
+	filters, args := buildFilters(opts)
 	query := fmt.Sprintf(`
 WITH case_a_warehouses AS (
 	-- Case A: Kandang-level warehouses (type != 'LOKASI' or NULL)
@@ -182,9 +182,27 @@ case_b_warehouses AS (
 	  AND w.location_id IS DISTINCT FROM k.location_id
 ),
 all_source_warehouses AS (
-	SELECT id, area_name, kandang_location_name, id AS kandang_id, name, case_type FROM case_a_warehouses
+	SELECT w_id, area_name, kandang_location_name, k_id AS kandang_id, name, case_type FROM (
+		SELECT w.id as w_id, a.name AS area_name, kl.name AS kandang_location_name, k.id as k_id, k.name, 'A'::text AS case_type
+		FROM warehouses w
+		JOIN kandangs k ON k.id = w.kandang_id AND k.deleted_at IS NULL
+		JOIN locations kl ON kl.id = k.location_id
+		JOIN areas a ON a.id = kl.area_id
+		WHERE w.deleted_at IS NOT NULL
+		  AND w.kandang_id IS NOT NULL
+		  AND UPPER(COALESCE(w.type, '')) <> 'LOKASI'
+	) case_a_warehouses
 	UNION ALL
-	SELECT id, area_name, kandang_location_name, id AS kandang_id, name, case_type FROM case_b_warehouses
+	SELECT w_id, area_name, kandang_location_name, k_id AS kandang_id, name, case_type FROM (
+		SELECT w.id as w_id, a.name AS area_name, kl.name AS kandang_location_name, k.id as k_id, k.name, 'B'::text AS case_type
+		FROM warehouses w
+		JOIN kandangs k ON k.id = w.kandang_id AND k.deleted_at IS NULL
+		JOIN locations kl ON kl.id = k.location_id
+		JOIN areas a ON a.id = kl.area_id
+		WHERE w.deleted_at IS NOT NULL
+		  AND w.kandang_id IS NOT NULL
+		  AND w.location_id IS DISTINCT FROM k.location_id
+	) case_b_warehouses
 )
 SELECT
 	asw.area_name,
@@ -198,7 +216,7 @@ SELECT
 	COALESCE(SUM(pw.qty), 0) AS stock_in_product_wh,
 	COUNT(DISTINCT pi.id) AS active_purchase_items
 FROM all_source_warehouses asw
-JOIN warehouses w ON w.id = asw.id
+JOIN warehouses w ON w.id = asw.w_id
 LEFT JOIN product_warehouses pw ON pw.warehouse_id = w.id
 LEFT JOIN purchase_items pi ON pi.warehouse_id = w.id
 WHERE true
@@ -216,7 +234,7 @@ ORDER BY asw.area_name ASC, asw.kandang_location_name ASC, w.name ASC
 `, andClause(filters))
 
 	rows := make([]sourceWarehouseCheck, 0)
-	if err := db.WithContext(ctx).Raw(query).Scan(&rows).Error; err != nil {
+	if err := db.WithContext(ctx).Raw(query, args...).Scan(&rows).Error; err != nil {
 		return nil, err
 	}
 
@@ -239,7 +257,7 @@ ORDER BY asw.area_name ASC, asw.kandang_location_name ASC, w.name ASC
 }
 
 func verifyDestinationWarehouses(ctx context.Context, db *gorm.DB, opts *options, sourceChecks []sourceWarehouseCheck) ([]destinationWarehouseCheck, error) {
-	filters := buildFilters(opts)
+	filters, args := buildFilters(opts)
 	query := fmt.Sprintf(`
 SELECT
 	a.name AS area_name,
@@ -252,12 +270,11 @@ SELECT
 	COALESCE(SUM(sl.stock), 0) AS stock_logs_total,
 	COUNT(DISTINCT sl.id) AS stock_logs_count
 FROM warehouses fw
-JOIN locations loc ON loc.id = fw.location_id
-JOIN areas a ON a.id = loc.area_id
-JOIN kandangs k ON k.location_id = fw.location_id AND k.deleted_at IS NULL
-JOIN locations kl ON kl.id = k.location_id
-JOIN products p ON UPPER(COALESCE(p.type, '')) IN ('PAKAN', 'OVK')
-LEFT JOIN product_warehouses pw ON pw.warehouse_id = fw.id AND pw.product_id = p.id
+JOIN locations kl ON kl.id = fw.location_id
+JOIN areas a ON a.id = kl.area_id
+JOIN product_warehouses pw ON pw.warehouse_id = fw.id
+JOIN products p ON p.id = pw.product_id
+JOIN flags f ON f.flagable_id = p.id AND f.flagable_type = 'products' AND UPPER(f.name) IN ('PAKAN', 'OVK')
 LEFT JOIN stock_logs sl ON sl.product_warehouse_id = pw.id
 WHERE fw.deleted_at IS NULL
   AND UPPER(COALESCE(fw.type, '')) = 'LOKASI'
@@ -274,7 +291,7 @@ ORDER BY a.name ASC, kl.name ASC, fw.name ASC, p.name ASC
 `, andClause(filters))
 
 	rows := make([]destinationWarehouseCheck, 0)
-	if err := db.WithContext(ctx).Raw(query).Scan(&rows).Error; err != nil {
+	if err := db.WithContext(ctx).Raw(query, args...).Scan(&rows).Error; err != nil {
 		return nil, err
 	}
 
@@ -316,7 +333,6 @@ func verifyOrphanedReferences(ctx context.Context, db *gorm.DB, sourceChecks []s
 		{"purchase_items", "warehouse_id"},
 		{"stock_transfers", "from_warehouse_id"},
 		{"stock_transfers", "to_warehouse_id"},
-		{"fifo_stock_v2_operation_log", "warehouse_id"},
 	}
 
 	for _, ref := range refChecks {
@@ -328,17 +344,17 @@ func verifyOrphanedReferences(ctx context.Context, db *gorm.DB, sourceChecks []s
 		}
 
 		if count > 0 {
-			// Get the specific warehouse IDs
+			// Get the specific warehouse IDs using raw SQL
 			var ids []uint
-			if err := db.Table(ref.table).
-				Where(fmt.Sprintf("%s IN ?", ref.column), warehouseIDs).
-				Pluck(ref.column, &ids).Error; err != nil {
+			query := fmt.Sprintf("SELECT DISTINCT %s FROM %s WHERE %s IN ?",
+				ref.column, ref.table, ref.column)
+			if err := db.Raw(query, warehouseIDs).Scan(&ids).Error; err != nil {
 				return nil, err
 			}
 
-			idStrs := make([]string, len(ids))
-			for i, id := range ids {
-				idStrs[i] = fmt.Sprintf("%d", id)
+			idStrs := make([]string, 0, len(ids))
+			for _, id := range ids {
+				idStrs = append(idStrs, fmt.Sprintf("%d", id))
 			}
 
 			results = append(results, orphanedReferenceCheck{
@@ -353,15 +369,18 @@ func verifyOrphanedReferences(ctx context.Context, db *gorm.DB, sourceChecks []s
 	return results, nil
 }
 
-func buildFilters(opts *options) []string {
+func buildFilters(opts *options) ([]string, []any) {
 	filters := make([]string, 0, 2)
+	args := make([]any, 0, 2)
 	if opts.AreaName != "" {
-		filters = append(filters, fmt.Sprintf("a.name = '%s'", opts.AreaName))
+		filters = append(filters, "a.name = ?")
+		args = append(args, opts.AreaName)
 	}
 	if opts.KandangLocationName != "" {
-		filters = append(filters, fmt.Sprintf("kl.name = '%s'", opts.KandangLocationName))
+		filters = append(filters, "kl.name = ?")
+		args = append(args, opts.KandangLocationName)
 	}
-	return filters
+	return filters, args
 }
 
 func andClause(filters []string) string {

docs/openapi/read-api.json

@@ -3215,6 +3215,55 @@
         ]
       }
     },
+    "/api/inventory/stock-logs/": {
+      "get": {
+        "description": "Read access to `/api/inventory/stock-logs`.",
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PaginatedEnvelope"
+                }
+              }
+            },
+            "description": "Successful response"
+          },
+          "401": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Unauthorized"
+          },
+          "403": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Forbidden"
+          }
+        },
+        "security": [
+          {
+            "ApiKeyAuth": []
+          },
+          {
+            "BearerAuth": []
+          }
+        ],
+        "summary": "GET api / inventory / stock logs",
+        "tags": [
+          "Inventory"
+        ]
+      }
+    },
     "/api/inventory/transfers/": {
       "get": {
         "description": "Read access to `/api/inventory/transfers`.",
@@ -4318,6 +4367,29 @@
           "200": {
             "content": {
               "application/json": {
+                "example": {
+                  "code": 200,
+                  "data": [
+                    {
+                      "created_at": "2026-01-01T00:00:00Z",
+                      "created_user": {
+                        "id": 1,
+                        "name": "Admin"
+                      },
+                      "id": 1,
+                      "name": "FCR Broiler Standard",
+                      "updated_at": "2026-01-01T00:00:00Z"
+                    }
+                  ],
+                  "message": "Get all fcrs successfully",
+                  "meta": {
+                    "limit": 10,
+                    "page": 1,
+                    "total_pages": 1,
+                    "total_results": 1
+                  },
+                  "status": "success"
+                },
                 "schema": {
                   "$ref": "#/components/schemas/PaginatedEnvelope"
                 }
@@ -4379,6 +4451,41 @@
           "200": {
             "content": {
               "application/json": {
+                "example": {
+                  "code": 200,
+                  "data": {
+                    "created_at": "2026-01-01T00:00:00Z",
+                    "created_user": {
+                      "id": 1,
+                      "name": "Admin"
+                    },
+                    "fcr_standards": [
+                      {
+                        "fcr_number": 1.2,
+                        "id": 1,
+                        "mortality": 0.5,
+                        "weight": 0.5
+                      },
+                      {
+                        "fcr_number": 1.35,
+                        "id": 2,
+                        "mortality": 0.3,
+                        "weight": 1
+                      },
+                      {
+                        "fcr_number": 1.5,
+                        "id": 3,
+                        "mortality": 0.25,
+                        "weight": 1.5
+                      }
+                    ],
+                    "id": 1,
+                    "name": "FCR Broiler Standard",
+                    "updated_at": "2026-01-01T00:00:00Z"
+                  },
+                  "message": "Get fcr successfully",
+                  "status": "success"
+                },
                 "schema": {
                   "$ref": "#/components/schemas/SuccessEnvelope"
                 }
@@ -6457,6 +6564,126 @@
         ]
       }
     },
+    "/api/production/chickins/": {
+      "get": {
+        "description": "Read access to `/api/production/chickins`.",
+        "parameters": [
+          {
+            "description": "Page number.",
+            "example": 1,
+            "in": "query",
+            "name": "page",
+            "required": false,
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Page size.",
+            "example": 10,
+            "in": "query",
+            "name": "limit",
+            "required": false,
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Project flock kandang id filter.",
+            "example": 1,
+            "in": "query",
+            "name": "project_flock_kandang_id",
+            "required": false,
+            "schema": {
+              "type": "integer"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "example": {
+                  "code": 200,
+                  "data": [
+                    {
+                      "chick_in_date": "2026-01-01T00:00:00Z",
+                      "created_at": "2026-01-01T00:00:00Z",
+                      "created_user": {
+                        "id": 1,
+                        "name": "Admin"
+                      },
+                      "id": 1,
+                      "notes": "",
+                      "pending_usage_qty": 0,
+                      "product_warehouse": {
+                        "id": 1,
+                        "product": {
+                          "id": 1,
+                          "name": "DOC Broiler"
+                        },
+                        "warehouse": {
+                          "id": 1,
+                          "name": "Gudang DOC"
+                        }
+                      },
+                      "product_warehouse_id": 1,
+                      "project_flock_kandang_id": 1,
+                      "updated_at": "2026-01-01T00:00:00Z",
+                      "usage_qty": 10000
+                    }
+                  ],
+                  "message": "Get all chickins successfully",
+                  "meta": {
+                    "limit": 10,
+                    "page": 1,
+                    "total_pages": 1,
+                    "total_results": 1
+                  },
+                  "status": "success"
+                },
+                "schema": {
+                  "$ref": "#/components/schemas/PaginatedEnvelope"
+                }
+              }
+            },
+            "description": "Successful response"
+          },
+          "401": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Unauthorized"
+          },
+          "403": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Forbidden"
+          }
+        },
+        "security": [
+          {
+            "ApiKeyAuth": []
+          },
+          {
+            "BearerAuth": []
+          }
+        ],
+        "summary": "GET api / production / chickins",
+        "tags": [
+          "Production"
+        ]
+      }
+    },
     "/api/production/chickins/{id}": {
       "get": {
         "description": "Read access to `/api/production/chickins/:id`.",
@@ -7517,6 +7744,47 @@
           "200": {
             "content": {
               "application/json": {
+                "example": {
+                  "code": 200,
+                  "data": [
+                    {
+                      "approval": {
+                        "action": null,
+                        "step_name": "Pengajuan",
+                        "step_number": 1
+                      },
+                      "created_at": "2026-01-15T00:00:00Z",
+                      "created_by": 1,
+                      "created_user": {
+                        "id": 1,
+                        "name": "Admin"
+                      },
+                      "economic_cutoff_date": "2026-01-20T00:00:00Z",
+                      "effective_move_date": "2026-01-18T00:00:00Z",
+                      "executed_at": null,
+                      "from_project_flock": {
+                        "flock_name": "Flock A Period 1",
+                        "id": 1
+                      },
+                      "id": 1,
+                      "notes": "",
+                      "to_project_flock": {
+                        "flock_name": "Flock B Period 1",
+                        "id": 2
+                      },
+                      "transfer_date": "2026-01-15T00:00:00Z",
+                      "transfer_number": "TL-00001"
+                    }
+                  ],
+                  "message": "Get all transferLayings successfully",
+                  "meta": {
+                    "limit": 10,
+                    "page": 1,
+                    "total_pages": 1,
+                    "total_results": 1
+                  },
+                  "status": "success"
+                },
                 "schema": {
                   "$ref": "#/components/schemas/PaginatedEnvelope"
                 }
@@ -7700,6 +7968,69 @@
           "200": {
             "content": {
               "application/json": {
+                "example": {
+                  "code": 200,
+                  "data": {
+                    "approval": {
+                      "action": null,
+                      "step_name": "Pengajuan",
+                      "step_number": 1
+                    },
+                    "created_at": "2026-01-15T00:00:00Z",
+                    "created_by": 1,
+                    "created_user": {
+                      "id": 1,
+                      "name": "Admin"
+                    },
+                    "economic_cutoff_date": "2026-01-20T00:00:00Z",
+                    "effective_move_date": "2026-01-18T00:00:00Z",
+                    "executed_at": null,
+                    "from_project_flock": {
+                      "flock_name": "Flock A Period 1",
+                      "id": 1
+                    },
+                    "id": 1,
+                    "notes": "",
+                    "sources": [
+                      {
+                        "note": "",
+                        "qty": 5000,
+                        "source_project_flock_kandang": {
+                          "id": 1,
+                          "kandang": {
+                            "id": 1,
+                            "name": "Kandang A"
+                          },
+                          "kandang_id": 1,
+                          "project_flock_id": 1
+                        }
+                      }
+                    ],
+                    "targets": [
+                      {
+                        "note": "",
+                        "qty": 5000,
+                        "target_project_flock_kandang": {
+                          "id": 2,
+                          "kandang": {
+                            "id": 2,
+                            "name": "Kandang B"
+                          },
+                          "kandang_id": 2,
+                          "project_flock_id": 2
+                        }
+                      }
+                    ],
+                    "to_project_flock": {
+                      "flock_name": "Flock B Period 1",
+                      "id": 2
+                    },
+                    "transfer_date": "2026-01-15T00:00:00Z",
+                    "transfer_number": "TL-00001"
+                  },
+                  "message": "Get transferLaying successfully",
+                  "status": "success"
+                },
                 "schema": {
                   "$ref": "#/components/schemas/SuccessEnvelope"
                 }
@@ -8912,6 +9243,55 @@
         ]
       }
     },
+    "/api/reports/hpp-v2-breakdown": {
+      "get": {
+        "description": "Read access to `/api/reports/hpp-v2-breakdown`.",
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PaginatedEnvelope"
+                }
+              }
+            },
+            "description": "Successful response"
+          },
+          "401": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Unauthorized"
+          },
+          "403": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Forbidden"
+          }
+        },
+        "security": [
+          {
+            "ApiKeyAuth": []
+          },
+          {
+            "BearerAuth": []
+          }
+        ],
+        "summary": "GET api / reports / hpp v2 breakdown",
+        "tags": [
+          "Reports"
+        ]
+      }
+    },
     "/api/reports/marketing": {
       "get": {
         "description": "Read access to `/api/reports/marketing`.",
@@ -9555,6 +9935,55 @@
         ]
       }
     },
+    "/api/system-settings/": {
+      "get": {
+        "description": "Read access to `/api/system-settings`.",
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PaginatedEnvelope"
+                }
+              }
+            },
+            "description": "Successful response"
+          },
+          "401": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Unauthorized"
+          },
+          "403": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorEnvelope"
+                }
+              }
+            },
+            "description": "Forbidden"
+          }
+        },
+        "security": [
+          {
+            "ApiKeyAuth": []
+          },
+          {
+            "BearerAuth": []
+          }
+        ],
+        "summary": "GET api / system settings",
+        "tags": [
+          "API"
+        ]
+      }
+    },
     "/api/users/": {
       "get": {
         "description": "Read access to `/api/users`.",

docs/openapi/read-api.yaml

@@ -2006,6 +2006,34 @@ paths:
             summary: GET api / inventory / product warehouses / :id
             tags:
                 - Inventory
+    /api/inventory/stock-logs/:
+        get:
+            description: Read access to `/api/inventory/stock-logs`.
+            responses:
+                "200":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/PaginatedEnvelope'
+                    description: Successful response
+                "401":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Unauthorized
+                "403":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Forbidden
+            security:
+                - ApiKeyAuth: []
+                - BearerAuth: []
+            summary: GET api / inventory / stock logs
+            tags:
+                - Inventory
     /api/inventory/transfers/:
         get:
             description: Read access to `/api/inventory/transfers`.
@@ -2686,6 +2714,23 @@ paths:
                 "200":
                     content:
                         application/json:
+                            example:
+                                code: 200
+                                data:
+                                    - created_at: "2026-01-01T00:00:00Z"
+                                      created_user:
+                                        id: 1
+                                        name: Admin
+                                      id: 1
+                                      name: FCR Broiler Standard
+                                      updated_at: "2026-01-01T00:00:00Z"
+                                message: Get all fcrs successfully
+                                meta:
+                                    limit: 10
+                                    page: 1
+                                    total_pages: 1
+                                    total_results: 1
+                                status: success
                             schema:
                                 $ref: '#/components/schemas/PaginatedEnvelope'
                     description: Successful response
@@ -2722,6 +2767,31 @@ paths:
                 "200":
                     content:
                         application/json:
+                            example:
+                                code: 200
+                                data:
+                                    created_at: "2026-01-01T00:00:00Z"
+                                    created_user:
+                                        id: 1
+                                        name: Admin
+                                    fcr_standards:
+                                        - fcr_number: 1.2
+                                          id: 1
+                                          mortality: 0.5
+                                          weight: 0.5
+                                        - fcr_number: 1.35
+                                          id: 2
+                                          mortality: 0.3
+                                          weight: 1
+                                        - fcr_number: 1.5
+                                          id: 3
+                                          mortality: 0.25
+                                          weight: 1.5
+                                    id: 1
+                                    name: FCR Broiler Standard
+                                    updated_at: "2026-01-01T00:00:00Z"
+                                message: Get fcr successfully
+                                status: success
                             schema:
                                 $ref: '#/components/schemas/SuccessEnvelope'
                     description: Successful response
@@ -3994,6 +4064,86 @@ paths:
             summary: GET api / master data / warehouses / :id
             tags:
                 - Master Data
+    /api/production/chickins/:
+        get:
+            description: Read access to `/api/production/chickins`.
+            parameters:
+                - description: Page number.
+                  example: 1
+                  in: query
+                  name: page
+                  required: false
+                  schema:
+                    type: integer
+                - description: Page size.
+                  example: 10
+                  in: query
+                  name: limit
+                  required: false
+                  schema:
+                    type: integer
+                - description: Project flock kandang id filter.
+                  example: 1
+                  in: query
+                  name: project_flock_kandang_id
+                  required: false
+                  schema:
+                    type: integer
+            responses:
+                "200":
+                    content:
+                        application/json:
+                            example:
+                                code: 200
+                                data:
+                                    - chick_in_date: "2026-01-01T00:00:00Z"
+                                      created_at: "2026-01-01T00:00:00Z"
+                                      created_user:
+                                        id: 1
+                                        name: Admin
+                                      id: 1
+                                      notes: ""
+                                      pending_usage_qty: 0
+                                      product_warehouse:
+                                        id: 1
+                                        product:
+                                            id: 1
+                                            name: DOC Broiler
+                                        warehouse:
+                                            id: 1
+                                            name: Gudang DOC
+                                      product_warehouse_id: 1
+                                      project_flock_kandang_id: 1
+                                      updated_at: "2026-01-01T00:00:00Z"
+                                      usage_qty: 10000
+                                message: Get all chickins successfully
+                                meta:
+                                    limit: 10
+                                    page: 1
+                                    total_pages: 1
+                                    total_results: 1
+                                status: success
+                            schema:
+                                $ref: '#/components/schemas/PaginatedEnvelope'
+                    description: Successful response
+                "401":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Unauthorized
+                "403":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Forbidden
+            security:
+                - ApiKeyAuth: []
+                - BearerAuth: []
+            summary: GET api / production / chickins
+            tags:
+                - Production
     /api/production/chickins/{id}:
         get:
             description: Read access to `/api/production/chickins/:id`.
@@ -4664,6 +4814,38 @@ paths:
                 "200":
                     content:
                         application/json:
+                            example:
+                                code: 200
+                                data:
+                                    - approval:
+                                        action: null
+                                        step_name: Pengajuan
+                                        step_number: 1
+                                      created_at: "2026-01-15T00:00:00Z"
+                                      created_by: 1
+                                      created_user:
+                                        id: 1
+                                        name: Admin
+                                      economic_cutoff_date: "2026-01-20T00:00:00Z"
+                                      effective_move_date: "2026-01-18T00:00:00Z"
+                                      executed_at: null
+                                      from_project_flock:
+                                        flock_name: Flock A Period 1
+                                        id: 1
+                                      id: 1
+                                      notes: ""
+                                      to_project_flock:
+                                        flock_name: Flock B Period 1
+                                        id: 2
+                                      transfer_date: "2026-01-15T00:00:00Z"
+                                      transfer_number: TL-00001
+                                message: Get all transferLayings successfully
+                                meta:
+                                    limit: 10
+                                    page: 1
+                                    total_pages: 1
+                                    total_results: 1
+                                status: success
                             schema:
                                 $ref: '#/components/schemas/PaginatedEnvelope'
                     description: Successful response
@@ -4700,6 +4882,53 @@ paths:
                 "200":
                     content:
                         application/json:
+                            example:
+                                code: 200
+                                data:
+                                    approval:
+                                        action: null
+                                        step_name: Pengajuan
+                                        step_number: 1
+                                    created_at: "2026-01-15T00:00:00Z"
+                                    created_by: 1
+                                    created_user:
+                                        id: 1
+                                        name: Admin
+                                    economic_cutoff_date: "2026-01-20T00:00:00Z"
+                                    effective_move_date: "2026-01-18T00:00:00Z"
+                                    executed_at: null
+                                    from_project_flock:
+                                        flock_name: Flock A Period 1
+                                        id: 1
+                                    id: 1
+                                    notes: ""
+                                    sources:
+                                        - note: ""
+                                          qty: 5000
+                                          source_project_flock_kandang:
+                                            id: 1
+                                            kandang:
+                                                id: 1
+                                                name: Kandang A
+                                            kandang_id: 1
+                                            project_flock_id: 1
+                                    targets:
+                                        - note: ""
+                                          qty: 5000
+                                          target_project_flock_kandang:
+                                            id: 2
+                                            kandang:
+                                                id: 2
+                                                name: Kandang B
+                                            kandang_id: 2
+                                            project_flock_id: 2
+                                    to_project_flock:
+                                        flock_name: Flock B Period 1
+                                        id: 2
+                                    transfer_date: "2026-01-15T00:00:00Z"
+                                    transfer_number: TL-00001
+                                message: Get transferLaying successfully
+                                status: success
                             schema:
                                 $ref: '#/components/schemas/SuccessEnvelope'
                     description: Successful response
@@ -5545,6 +5774,34 @@ paths:
             summary: GET api / reports / hpp per kandang
             tags:
                 - Reports
+    /api/reports/hpp-v2-breakdown:
+        get:
+            description: Read access to `/api/reports/hpp-v2-breakdown`.
+            responses:
+                "200":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/PaginatedEnvelope'
+                    description: Successful response
+                "401":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Unauthorized
+                "403":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Forbidden
+            security:
+                - ApiKeyAuth: []
+                - BearerAuth: []
+            summary: GET api / reports / hpp v2 breakdown
+            tags:
+                - Reports
     /api/reports/marketing:
         get:
             description: Read access to `/api/reports/marketing`.
@@ -5955,6 +6212,34 @@ paths:
             summary: GET api / sso / userinfo
             tags:
                 - SSO
+    /api/system-settings/:
+        get:
+            description: Read access to `/api/system-settings`.
+            responses:
+                "200":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/PaginatedEnvelope'
+                    description: Successful response
+                "401":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Unauthorized
+                "403":
+                    content:
+                        application/json:
+                            schema:
+                                $ref: '#/components/schemas/ErrorEnvelope'
+                    description: Forbidden
+            security:
+                - ApiKeyAuth: []
+                - BearerAuth: []
+            summary: GET api / system settings
+            tags:
+                - API
     /api/users/:
         get:
             description: Read access to `/api/users`.

docs/postman/read-api.collection.json

@@ -109,6 +109,19 @@
                 "method": "GET",
                 "url": "{{base_url}}/api/closings/?page=1\u0026limit=10\u0026search=kandang\u0026project_status=1\u0026location_id={{location_id}}"
               }
+            },
+            {
+              "name": "GET api / system settings",
+              "request": {
+                "header": [
+                  {
+                    "key": "Accept",
+                    "value": "application/json"
+                  }
+                ],
+                "method": "GET",
+                "url": "{{base_url}}/api/system-settings/"
+              }
             }
           ],
           "name": "API"
@@ -582,6 +595,19 @@
                 "url": "{{base_url}}/api/inventory/product-warehouses/{{id}}"
               }
             },
+            {
+              "name": "GET api / inventory / stock logs",
+              "request": {
+                "header": [
+                  {
+                    "key": "Accept",
+                    "value": "application/json"
+                  }
+                ],
+                "method": "GET",
+                "url": "{{base_url}}/api/inventory/stock-logs/"
+              }
+            },
             {
               "name": "GET api / inventory / transfers",
               "request": {
@@ -1143,6 +1169,19 @@
         },
         {
           "item": [
+            {
+              "name": "GET api / production / chickins",
+              "request": {
+                "header": [
+                  {
+                    "key": "Accept",
+                    "value": "application/json"
+                  }
+                ],
+                "method": "GET",
+                "url": "{{base_url}}/api/production/chickins/?page=1\u0026limit=10\u0026project_flock_kandang_id={{project_flock_kandang_id}}"
+              }
+            },
             {
               "name": "GET api / production / chickins / :id",
               "request": {
@@ -1478,6 +1517,19 @@
                 "url": "{{base_url}}/api/reports/hpp-per-kandang?page=1\u0026limit=10\u0026period=2026-01-01\u0026show_unrecorded=false\u0026area_id=1,2\u0026location_id=1,2\u0026kandang_id=1,2\u0026weight_min=1.2\u0026weight_max=1.8"
               }
             },
+            {
+              "name": "GET api / reports / hpp v2 breakdown",
+              "request": {
+                "header": [
+                  {
+                    "key": "Accept",
+                    "value": "application/json"
+                  }
+                ],
+                "method": "GET",
+                "url": "{{base_url}}/api/reports/hpp-v2-breakdown"
+              }
+            },
             {
               "name": "GET api / reports / marketing",
               "request": {

go.mod

@@ -52,6 +52,7 @@ require (
 	github.com/fsnotify/fsnotify v1.7.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.8 // indirect
 	github.com/glebarez/go-sqlite v1.21.2 // indirect
+	github.com/go-pdf/fpdf v0.9.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
 	github.com/google/go-cmp v0.6.0 // indirect

go.sum

@@ -77,6 +77,8 @@ github.com/glebarez/go-sqlite v1.21.2 h1:3a6LFC4sKahUunAmynQKLZceZCOzUthkRkEAl9g
 github.com/glebarez/go-sqlite v1.21.2/go.mod h1:sfxdZyhQjTM2Wry3gVYWaW072Ri1WMdWJi0k6+3382k=
 github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMw=
 github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ=
+github.com/go-pdf/fpdf v0.9.0 h1:PPvSaUuo1iMi9KkaAn90NuKi+P4gwMedWPHhj8YlJQw=
+github.com/go-pdf/fpdf v0.9.0/go.mod h1:oO8N111TkmKb9D7VvWGLvLJlaZUQVPM+6V42pp3iV4Y=
 github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
 github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=

internal/apikeys/defaults.go

@@ -89,5 +89,6 @@ func DefaultDashboardPermissions() []string {
 		"lti.users.detail",
 		"lti.users.list",
 		"lti.daily_checklist.master_data.kandang",
+		"lti.production.chickins.list",
 	}
 }

internal/common/repository/common.hppv2.repository.go

@@ -115,6 +115,7 @@ type HppV2CostRepository interface {
 	GetFeedUsageCost(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time) (float64, error)
 	GetTotalPopulation(ctx context.Context, projectFlockKandangIDs []uint) (float64, error)
 	GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time) (float64, float64, error)
+	GetEggProduksiBreakdownByProjectFlockKandangIds(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time) (recordingQty, recordingWeight, adjustmentQty, adjustmentWeight float64, err error)
 	GetEggTerjualPiecesAndWeightKgByProjectFlockKandangIds(ctx context.Context, projectFlockKandangIDs []uint, startDate *time.Time, endDate *time.Time) (float64, float64, error)
 	GetTransferSourceSummary(ctx context.Context, projectFlockKandangId uint) (uint, float64, error)
 }
@@ -858,58 +859,50 @@ func (r *HppV2RepositoryImpl) GetTotalPopulation(ctx context.Context, projectFlo
 }
 
 func (r *HppV2RepositoryImpl) GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time) (float64, float64, error) {
+	rQty, rWeight, aQty, aWeight, err := r.GetEggProduksiBreakdownByProjectFlockKandangIds(ctx, projectFlockKandangIDs, date)
+	if err != nil {
+		return 0, 0, err
+	}
+	return rQty + aQty, rWeight + aWeight, nil
+}
+
+func (r *HppV2RepositoryImpl) GetEggProduksiBreakdownByProjectFlockKandangIds(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time) (recordingQty, recordingWeight, adjustmentQty, adjustmentWeight float64, err error) {
 	if date == nil {
 		now := time.Now()
 		date = &now
 	}
 
-	var totals struct {
+	var recordingTotals struct {
 		TotalPieces   float64
 		TotalWeightKg float64
 	}
-	err := r.db.WithContext(ctx).
+	err = r.db.WithContext(ctx).
 		Table("recordings AS r").
-		Select("COALESCE(SUM(re.qty), 0) AS total_pieces, COALESCE(SUM(re.weight), 0)AS total_weight_kg").
+		Select("COALESCE(SUM(re.qty), 0) AS total_pieces, COALESCE(SUM(re.weight), 0) AS total_weight_kg").
 		Joins("JOIN recording_eggs AS re ON re.recording_id = r.id").
 		Where("r.project_flock_kandangs_id IN (?)", projectFlockKandangIDs).
 		Where("r.record_datetime <= ?", *date).
-		Scan(&totals).Error
+		Scan(&recordingTotals).Error
 	if err != nil {
-		return 0, 0, err
+		return 0, 0, 0, 0, err
 	}
 
 	var adjustmentTotals struct {
 		TotalQty    float64
 		TotalWeight float64
 	}
-	adjustmentSubQuery := r.db.WithContext(ctx).
-		Table("recordings AS r").
-		Select("DISTINCT ast.id AS adjustment_id, ast.total_qty AS total_qty, ast.price AS price").
-		Joins("JOIN recording_eggs AS re ON re.recording_id = r.id").
-		Joins("JOIN stock_transfer_details AS std ON std.dest_product_warehouse_id = re.product_warehouse_id").
-		Joins(
-			"JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = std.id AND sa.stockable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?",
-			fifo.UsableKeyStockTransferOut.String(),
-			fifo.StockableKeyAdjustmentIn.String(),
-			entity.StockAllocationStatusActive,
-			entity.StockAllocationPurposeConsume,
-		).
-		Joins("JOIN adjustment_stocks AS ast ON ast.id = sa.stockable_id AND ast.product_warehouse_id = std.source_product_warehouse_id").
-		Where("r.project_flock_kandangs_id IN (?)", projectFlockKandangIDs).
-		Where("r.record_datetime <= ?", *date)
-
 	err = r.db.WithContext(ctx).
-		Table("(?) AS adjustment_sources", adjustmentSubQuery).
-		Select("COALESCE(SUM(adjustment_sources.total_qty), 0) AS total_qty, COALESCE(SUM(adjustment_sources.price), 0) AS total_weight").
+		Table("adjustment_stocks AS ast").
+		Select("COALESCE(SUM(ast.total_qty), 0) AS total_qty, COALESCE(SUM(ast.price), 0) AS total_weight").
+		Joins("JOIN product_warehouses AS pw ON pw.id = ast.product_warehouse_id").
+		Where("pw.project_flock_kandang_id IN (?)", projectFlockKandangIDs).
+		Where("ast.function_code = ?", string(utils.AdjustmentTransactionSubtypeRecordingEggIn)).
 		Scan(&adjustmentTotals).Error
 	if err != nil {
-		return 0, 0, err
+		return 0, 0, 0, 0, err
 	}
 
-	totals.TotalPieces += adjustmentTotals.TotalQty
-	totals.TotalWeightKg += adjustmentTotals.TotalWeight
-
-	return totals.TotalPieces, totals.TotalWeightKg, nil
+	return recordingTotals.TotalPieces, recordingTotals.TotalWeightKg, adjustmentTotals.TotalQty, adjustmentTotals.TotalWeight, nil
 }
 
 func (r *HppV2RepositoryImpl) GetEggTerjualPiecesAndWeightKgByProjectFlockKandangIds(
@@ -1160,7 +1153,6 @@ CROSS JOIN lokasi_rec_totals lrt
 			string(utils.AdjustmentTransactionTypeRecording),
 		).
 		Scan(&totals).Error
-
 	if err != nil {
 		return 0, 0, err
 	}

internal/common/service/common.depreciation.service.go

@@ -31,7 +31,7 @@ func FlockAgeDay(originDate time.Time, periodDate time.Time) int {
 	if period.Before(origin) {
 		return 0
 	}
-	return int(period.Sub(origin).Hours()/24) + 1
+	return int(period.Sub(origin).Hours() / 24)
 }
 
 func DepreciationScheduleDay(originDate time.Time, periodDate time.Time, houseType string) int {

internal/common/service/common.hpp.service.go

@@ -18,8 +18,9 @@ type HppService interface {
 }
 
 type HppCostResponse struct {
-	Estimation HppCostDetail `json:"estimation"`
-	Real       HppCostDetail `json:"real"`
+	Estimation  HppCostDetail       `json:"estimation"`
+	Real        HppCostDetail       `json:"real"`
+	DebugValues *HppCostDebugValues `json:"debug_values,omitempty"`
 }
 
 type HppCostDetail struct {

internal/common/service/common.hppv2.model.go

@@ -44,6 +44,15 @@ type HppV2Component struct {
 	Parts  []HppV2ComponentPart `json:"parts"`
 }
 
+type HppCostDebugValues struct {
+	RecordingEggQty     float64 `json:"recording_egg_qty"`
+	RecordingEggWeight  float64 `json:"recording_egg_weight"`
+	AdjustmentEggQty    float64 `json:"adjustment_egg_qty"`
+	AdjustmentEggWeight float64 `json:"adjustment_egg_weight"`
+	SoldEggQty          float64 `json:"sold_egg_qty"`
+	SoldEggWeight       float64 `json:"sold_egg_weight"`
+}
+
 type HppV2Breakdown struct {
 	ProjectFlockKandangID uint             `json:"project_flock_kandang_id"`
 	ProjectFlockID        uint             `json:"project_flock_id"`

internal/common/service/common.hppv2.service.go

@@ -36,7 +36,7 @@ const (
 	hppV2ProrationEggPiece             = "laying_egg_piece_share"
 	hppV2ScopePulletCost               = "pullet_cost"
 	hppV2ScopeProductionCost           = "production_cost"
-	hppV2CutoverFlagPakan              = "PAKAN-CUTOVER"
+	hppV2CutoverFlagPakan              = string(utils.FlagPakan)
 	hppV2CutoverFlagOvk                = "OVK"
 )
 
@@ -1489,7 +1489,7 @@ func (s *hppV2Service) GetHppEstimationDanRealisasi(totalProductionCost float64,
 		return &HppCostResponse{}, nil
 	}
 
-	estimPieces, estimWeightKg, err := s.hppRepo.GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(context.Background(), []uint{projectFlockKandangId}, endDate)
+	recordingQty, recordingWeight, adjustmentQty, adjustmentWeight, err := s.hppRepo.GetEggProduksiBreakdownByProjectFlockKandangIds(context.Background(), []uint{projectFlockKandangId}, endDate)
 	if err != nil {
 		utils.Log.WithError(err).Errorf(
 			"GetHppEstimationDanRealisasi failed to get estimation egg production: project_flock_kandang_id=%d end_date=%s",
@@ -1498,6 +1498,8 @@ func (s *hppV2Service) GetHppEstimationDanRealisasi(totalProductionCost float64,
 		)
 		return nil, err
 	}
+	estimPieces := recordingQty + adjustmentQty
+	estimWeightKg := recordingWeight + adjustmentWeight
 
 	realPieces, realWeightKg, err := s.hppRepo.GetEggTerjualPiecesAndWeightKgByProjectFlockKandangIds(context.Background(), []uint{projectFlockKandangId}, startDate, endDate)
 	if err != nil {
@@ -1551,6 +1553,14 @@ func (s *hppV2Service) GetHppEstimationDanRealisasi(totalProductionCost float64,
 	return &HppCostResponse{
 		Estimation: estimation,
 		Real:       real,
+		DebugValues: &HppCostDebugValues{
+			RecordingEggQty:     recordingQty,
+			RecordingEggWeight:  recordingWeight,
+			AdjustmentEggQty:    adjustmentQty,
+			AdjustmentEggWeight: adjustmentWeight,
+			SoldEggQty:          realPieces,
+			SoldEggWeight:       realWeightKg,
+		},
 	}, nil
 }
 

internal/common/service/common.hppv2.service_test.go

@@ -132,6 +132,17 @@ func (s *hppV2RepoStub) GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(
 	return totalPieces, totalKg, nil
 }
 
+func (s *hppV2RepoStub) GetEggProduksiBreakdownByProjectFlockKandangIds(_ context.Context, projectFlockKandangIDs []uint, _ *time.Time) (float64, float64, float64, float64, error) {
+	totalPieces := 0.0
+	totalKg := 0.0
+	for _, projectFlockKandangID := range projectFlockKandangIDs {
+		row := s.eggProductionByPFK[projectFlockKandangID]
+		totalPieces += row.pieces
+		totalKg += row.kg
+	}
+	return totalPieces, totalKg, 0, 0, nil
+}
+
 func (s *hppV2RepoStub) GetEggTerjualPiecesAndWeightKgByProjectFlockKandangIds(_ context.Context, projectFlockKandangIDs []uint, _ *time.Time, _ *time.Time) (float64, float64, error) {
 	if len(projectFlockKandangIDs) != 1 {
 		return 0, 0, nil

internal/database/migrations/20260402034456_adjust_daily_checklist_unique_for_rejected.down.sql

@@ -0,0 +1,9 @@
+BEGIN;
+
+DROP INDEX IF EXISTS idx_daily_checklists_unique_non_rejected;
+
+ALTER TABLE daily_checklists
+    ADD CONSTRAINT daily_checklists_date_kandang_category_key
+    UNIQUE (date, kandang_id, category);
+
+COMMIT;

internal/database/migrations/20260402034456_adjust_daily_checklist_unique_for_rejected.up.sql

@@ -0,0 +1,10 @@
+BEGIN;
+
+ALTER TABLE daily_checklists
+    DROP CONSTRAINT IF EXISTS daily_checklists_date_kandang_category_key;
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_daily_checklists_unique_non_rejected
+    ON daily_checklists (date, kandang_id, category)
+    WHERE (status IS NULL OR status <> 'REJECTED');
+
+COMMIT;

internal/database/migrations/20260425145831_fix_recording_numeric_precision.down.sql

@@ -0,0 +1,11 @@
+BEGIN;
+
+-- Revert fcr_value and cum_depletion_rate back to NUMERIC(7,3).
+-- WARNING: any value with an integer part > 9999 (e.g. high-FCR early-laying recordings)
+-- will fail the cast and must be cleared first, or this rollback will error.
+
+ALTER TABLE recordings
+    ALTER COLUMN fcr_value          TYPE NUMERIC(7,3) USING fcr_value::NUMERIC(7,3),
+    ALTER COLUMN cum_depletion_rate TYPE NUMERIC(7,3) USING cum_depletion_rate::NUMERIC(7,3);
+
+COMMIT;

internal/database/migrations/20260425145831_fix_recording_numeric_precision.up.sql

@@ -0,0 +1,13 @@
+BEGIN;
+
+-- fcr_value and cum_depletion_rate were created as NUMERIC(7,3) (max integer part: 9999).
+-- Early-laying flocks produce very few eggs relative to total feed consumed, so
+-- FCR = usageInGrams / totalEggWeightGrams can legitimately exceed 9999 (e.g. ~31 740).
+-- Widening to NUMERIC(15,3) keeps the same 3-decimal-place scale and is
+-- fully backward-compatible: no existing value will be truncated or altered.
+
+ALTER TABLE recordings
+    ALTER COLUMN fcr_value          TYPE NUMERIC(15,3) USING fcr_value::NUMERIC(15,3),
+    ALTER COLUMN cum_depletion_rate TYPE NUMERIC(15,3) USING cum_depletion_rate::NUMERIC(15,3);
+
+COMMIT;

internal/database/migrations/20260428000001_create_system_settings.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS system_settings;

internal/database/migrations/20260428000001_create_system_settings.up.sql

@@ -0,0 +1,11 @@
+CREATE TABLE system_settings (
+    key         VARCHAR(100) PRIMARY KEY,
+    value       TEXT NOT NULL DEFAULT '',
+    description TEXT,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+INSERT INTO system_settings (key, value, description) VALUES
+  ('allow_negative_pakan_ovk', 'false',
+   'Izinkan pencatatan penggunaan PAKAN & OVK negatif (mode migrasi): membuka semua produk PAKAN & OVK meskipun belum ada pembelian di sistem');

internal/database/migrations/20260504035824_adjust_recording_day_zero_indexed.down.sql

@@ -0,0 +1,21 @@
+UPDATE recordings r
+SET day = (
+    SELECT (r.record_datetime::date - MIN(pc.chick_in_date)::date)::int + 1
+    FROM project_chickins pc
+    WHERE pc.project_flock_kandang_id = r.project_flock_kandangs_id
+      AND pc.deleted_at IS NULL
+)
+WHERE r.deleted_at IS NULL
+  AND (
+      SELECT MIN(pc.chick_in_date)
+      FROM project_chickins pc
+      WHERE pc.project_flock_kandang_id = r.project_flock_kandangs_id
+        AND pc.deleted_at IS NULL
+  ) IS NOT NULL;
+
+ALTER TABLE recordings
+DROP CONSTRAINT IF EXISTS chk_recordings_day;
+
+ALTER TABLE recordings
+ADD CONSTRAINT chk_recordings_day
+CHECK (day IS NULL OR day >= 1);

internal/database/migrations/20260504035824_adjust_recording_day_zero_indexed.up.sql

@@ -0,0 +1,21 @@
+ALTER TABLE recordings
+DROP CONSTRAINT IF EXISTS chk_recordings_day;
+
+ALTER TABLE recordings
+ADD CONSTRAINT chk_recordings_day
+CHECK (day IS NULL OR day >= 0);
+
+UPDATE recordings r
+SET day = (
+    SELECT (r.record_datetime::date - MIN(pc.chick_in_date)::date)::int
+    FROM project_chickins pc
+    WHERE pc.project_flock_kandang_id = r.project_flock_kandangs_id
+      AND pc.deleted_at IS NULL
+)
+WHERE r.deleted_at IS NULL
+  AND (
+      SELECT MIN(pc.chick_in_date)
+      FROM project_chickins pc
+      WHERE pc.project_flock_kandang_id = r.project_flock_kandangs_id
+        AND pc.deleted_at IS NULL
+  ) IS NOT NULL;

internal/database/migrations/20260505083754_update_pullet_cikaum_chick_in_date.down.sql

@@ -0,0 +1,13 @@
+-- Revert chick_in_date Pullet Cikaum 1 (project_flock_kandang_id = 70) -> 23 Maret 2026
+UPDATE public.project_chickins
+SET chick_in_date = DATE '2026-03-23',
+    updated_at    = NOW()
+WHERE project_flock_kandang_id = 70
+  AND deleted_at IS NULL;
+
+-- Revert chick_in_date Pullet Cikaum 2 (project_flock_kandang_id = 71) -> 15 Desember 2025
+UPDATE public.project_chickins
+SET chick_in_date = DATE '2025-12-15',
+    updated_at    = NOW()
+WHERE project_flock_kandang_id = 71
+  AND deleted_at IS NULL;

internal/database/migrations/20260505083754_update_pullet_cikaum_chick_in_date.up.sql

@@ -0,0 +1,13 @@
+-- Update chick_in_date Pullet Cikaum 1 (project_flock_kandang_id = 70) -> 24 Maret 2026
+UPDATE public.project_chickins
+SET chick_in_date = DATE '2026-03-24',
+    updated_at    = NOW()
+WHERE project_flock_kandang_id = 70
+  AND deleted_at IS NULL;
+
+-- Update chick_in_date Pullet Cikaum 2 (project_flock_kandang_id = 71) -> 6 April 2026
+UPDATE public.project_chickins
+SET chick_in_date = DATE '2026-04-06',
+    updated_at    = NOW()
+WHERE project_flock_kandang_id = 71
+  AND deleted_at IS NULL;

internal/database/migrations/20260507101151_normalize_recording_day_pullet_cikaum.down.sql

@@ -0,0 +1,21 @@
+-- Revert: hitung ulang recording.day menggunakan chick_in_date sebelum perubahan
+-- PFK 70: old chick_in_date = 2026-03-23
+-- PFK 71: old chick_in_date = 2025-12-15
+-- Kembalikan constraint chk_recordings_day ke >= 1
+
+UPDATE recordings r
+SET day = GREATEST(1, (r.record_datetime::date -
+    CASE r.project_flock_kandangs_id
+        WHEN 70 THEN DATE '2026-03-23'
+        WHEN 71 THEN DATE '2025-12-15'
+    END)::int + 1),
+    updated_at = NOW()
+WHERE r.project_flock_kandangs_id IN (70, 71)
+  AND r.deleted_at IS NULL;
+
+ALTER TABLE recordings
+DROP CONSTRAINT IF EXISTS chk_recordings_day;
+
+ALTER TABLE recordings
+ADD CONSTRAINT chk_recordings_day
+CHECK (day IS NULL OR day >= 1);

internal/database/migrations/20260507101151_normalize_recording_day_pullet_cikaum.up.sql

@@ -0,0 +1,23 @@
+-- Normalize recording.day untuk Pullet Cikaum 1 & 2
+-- Setelah migrasi 20260505083754_update_pullet_cikaum_chick_in_date mengubah chick_in_date:
+--   PFK 70: 2026-03-23 → 2026-03-24 (shift +1 hari)
+--   PFK 71: 2025-12-15 → 2026-04-06 (shift +112 hari)
+-- Recording.day perlu dihitung ulang: day = record_datetime::date - chick_in_date::date
+-- Edge case: PFK 70 punya 1 recording (2026-03-23) sebelum chick_in_date baru → di-clamp ke 0
+-- Note: constraint chk_recordings_day diubah ke >= 0 karena zero-indexed day
+
+ALTER TABLE recordings
+DROP CONSTRAINT IF EXISTS chk_recordings_day;
+
+ALTER TABLE recordings
+ADD CONSTRAINT chk_recordings_day
+CHECK (day IS NULL OR day >= 0);
+
+UPDATE recordings r
+SET day = GREATEST(0, (r.record_datetime::date - pc.chick_in_date::date)::int),
+    updated_at = NOW()
+FROM project_chickins pc
+WHERE pc.project_flock_kandang_id = r.project_flock_kandangs_id
+  AND pc.deleted_at IS NULL
+  AND r.deleted_at IS NULL
+  AND r.project_flock_kandangs_id IN (70, 71);

internal/database/migrations/20260508091531_fix_adjustment_stock_531_price.down.sql

@@ -0,0 +1,5 @@
+-- Rollback price adjustment_stock id=531
+UPDATE adjustment_stocks
+SET price = 9535,
+    grand_total = ROUND(9000 * 9535, 3)
+WHERE id = 531 AND adj_number = 'ADJ-00506';

internal/database/migrations/20260508091531_fix_adjustment_stock_531_price.up.sql

@@ -0,0 +1,7 @@
+-- Fix price adjustment_stock id=531 (ADJ-00506)
+-- Old: price=9535, grand_total=85,815,000
+-- New: price=12635, grand_total=113,715,000
+UPDATE adjustment_stocks
+SET price = 12635,
+    grand_total = ROUND(9000 * 12635, 3)
+WHERE id = 531 AND adj_number = 'ADJ-00506';

internal/database/migrations/20260511070035_add_is_paid_to_expenses.down.sql

@@ -0,0 +1 @@
+ALTER TABLE expenses DROP COLUMN is_paid;

internal/database/migrations/20260511070035_add_is_paid_to_expenses.up.sql

@@ -0,0 +1 @@
+ALTER TABLE expenses ADD COLUMN is_paid BOOLEAN NOT NULL DEFAULT FALSE;

internal/database/migrations/20260517112459_create_daily_checklist_empty_kandangs.down.sql

@@ -0,0 +1,5 @@
+BEGIN;
+
+DROP TABLE IF EXISTS daily_checklist_empty_kandangs;
+
+COMMIT;

internal/database/migrations/20260517112459_create_daily_checklist_empty_kandangs.up.sql

@@ -0,0 +1,60 @@
+BEGIN;
+
+CREATE TABLE daily_checklist_empty_kandangs (
+  id                  bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  daily_checklist_id  bigint NOT NULL,
+  kandang_id          bigint NOT NULL,
+  start_date          date NOT NULL,
+  end_date            date NOT NULL,
+  created_by          bigint,
+  deleted_by          bigint,
+  created_at          timestamptz NOT NULL DEFAULT now(),
+  updated_at          timestamptz NOT NULL DEFAULT now(),
+  deleted_at          timestamptz,
+
+  CONSTRAINT fk_dcek_daily_checklist
+    FOREIGN KEY (daily_checklist_id) REFERENCES daily_checklists(id) ON DELETE CASCADE,
+  CONSTRAINT fk_dcek_kandang
+    FOREIGN KEY (kandang_id) REFERENCES kandangs(id) ON DELETE CASCADE,
+  CONSTRAINT fk_dcek_created_by
+    FOREIGN KEY (created_by) REFERENCES users(id) ON DELETE SET NULL,
+  CONSTRAINT fk_dcek_deleted_by
+    FOREIGN KEY (deleted_by) REFERENCES users(id) ON DELETE SET NULL,
+  CONSTRAINT ck_dcek_range CHECK (end_date >= start_date)
+);
+
+CREATE INDEX idx_dcek_kandang_range
+  ON daily_checklist_empty_kandangs (kandang_id, start_date, end_date)
+  WHERE deleted_at IS NULL;
+
+CREATE UNIQUE INDEX idx_dcek_daily_checklist_unique
+  ON daily_checklist_empty_kandangs (daily_checklist_id)
+  WHERE deleted_at IS NULL;
+
+INSERT INTO daily_checklist_empty_kandangs (
+  daily_checklist_id, kandang_id, start_date, end_date, created_by, created_at, updated_at
+)
+SELECT
+  dc.id,
+  dc.kandang_id,
+  dc.date AS start_date,
+  COALESCE(
+    (SELECT (next_dc.date - INTERVAL '1 day')::date
+     FROM daily_checklists next_dc
+     WHERE next_dc.kandang_id = dc.kandang_id
+       AND next_dc.date > dc.date
+       AND next_dc.category <> 'empty_kandang'
+       AND (next_dc.status IS NULL OR next_dc.status <> 'REJECTED')
+       AND next_dc.deleted_at IS NULL
+     ORDER BY next_dc.date ASC
+     LIMIT 1),
+    dc.date
+  ) AS end_date,
+  dc.created_by,
+  dc.created_at,
+  dc.updated_at
+FROM daily_checklists dc
+WHERE dc.category = 'empty_kandang'
+  AND dc.deleted_at IS NULL;
+
+COMMIT;

internal/database/migrations/20260517132922_add_bank_name_to_customers_suppliers.down.sql

@@ -0,0 +1,2 @@
+ALTER TABLE customers DROP COLUMN bank_name;
+ALTER TABLE suppliers DROP COLUMN bank_name;

internal/database/migrations/20260517132922_add_bank_name_to_customers_suppliers.up.sql

@@ -0,0 +1,2 @@
+ALTER TABLE customers ADD COLUMN bank_name VARCHAR(100) NOT NULL DEFAULT '';
+ALTER TABLE suppliers ADD COLUMN bank_name VARCHAR(100);

internal/entities/customer.go

@@ -15,6 +15,7 @@ type Customer struct {
 	Phone         string         `gorm:"not null;size:20"`
 	Email         string         `gorm:"type:varchar(50);not null"`
 	AccountNumber string         `gorm:"not null;size:50"`
+	BankName      string         `gorm:"not null;size:100;default:''"`
 	Balance       float64        `gorm:"default:0"`
 	CreatedBy     uint           `gorm:"not null"`
 	CreatedAt     time.Time      `gorm:"autoCreateTime"`

internal/entities/daily-checklist-empty-kandang.go

@@ -0,0 +1,27 @@
+package entities
+
+import (
+	"time"
+
+	"gorm.io/gorm"
+)
+
+type DailyChecklistEmptyKandang struct {
+	Id               uint      `gorm:"primaryKey"`
+	DailyChecklistId uint      `gorm:"not null"`
+	KandangId        uint      `gorm:"not null"`
+	StartDate        time.Time `gorm:"type:date;not null"`
+	EndDate          time.Time `gorm:"type:date;not null"`
+	CreatedBy        *uint
+	DeletedBy        *uint
+	CreatedAt        time.Time      `gorm:"autoCreateTime"`
+	UpdatedAt        time.Time      `gorm:"autoUpdateTime"`
+	DeletedAt        gorm.DeletedAt `gorm:"index" json:"-"`
+
+	DailyChecklist *DailyChecklist `gorm:"foreignKey:DailyChecklistId;references:Id"`
+	Kandang        *KandangGroup   `gorm:"foreignKey:KandangId;references:Id"`
+}
+
+func (DailyChecklistEmptyKandang) TableName() string {
+	return "daily_checklist_empty_kandangs"
+}

internal/entities/daily-checklist.go

@@ -23,11 +23,12 @@ type DailyChecklist struct {
 	UpdatedAt    time.Time      `gorm:"autoUpdateTime"`
 	DeletedAt    gorm.DeletedAt `gorm:"index" json:"-"`
 
-	Kandang   KandangGroup         `gorm:"foreignKey:KandangId;references:Id"`
-	Checklist *Checklist           `gorm:"foreignKey:ChecklistId;references:Id"`
-	Creator   *User                `gorm:"foreignKey:CreatedBy;references:Id"`
-	Deleter   *User                `gorm:"foreignKey:DeletedBy;references:Id"`
-	Tasks     []DailyChecklistTask `gorm:"foreignKey:DailyChecklistId;references:Id"`
+	Kandang      KandangGroup                `gorm:"foreignKey:KandangId;references:Id"`
+	Checklist    *Checklist                  `gorm:"foreignKey:ChecklistId;references:Id"`
+	Creator      *User                       `gorm:"foreignKey:CreatedBy;references:Id"`
+	Deleter      *User                       `gorm:"foreignKey:DeletedBy;references:Id"`
+	Tasks        []DailyChecklistTask        `gorm:"foreignKey:DailyChecklistId;references:Id"`
+	EmptyKandang *DailyChecklistEmptyKandang `gorm:"foreignKey:DailyChecklistId;references:Id"`
 }
 
 type DailyChecklistPhase struct {

internal/entities/expense.go

@@ -17,6 +17,7 @@ type Expense struct {
 	RealizationDate         time.Time      `gorm:"type:date;column:realization_date"`
 	TransactionDate         time.Time      `gorm:"type:date;not null"`
 	Notes                   string         `gorm:"type:text;column:notes"`
+	IsPaid                  bool           `gorm:"column:is_paid;not null;default:false"`
 	CreatedBy               uint64         `gorm:""`
 	CreatedAt               time.Time      `gorm:"autoCreateTime"`
 	UpdatedAt               time.Time      `gorm:"autoUpdateTime"`

internal/entities/recording.go

@@ -43,6 +43,7 @@ type Recording struct {
 	StandardEggMass      *float64 `gorm:"-"`
 	StandardEggWeight    *float64 `gorm:"-"`
 	StandardFcr          *float64 `gorm:"-"`
+	StandardWeek         *int     `gorm:"-"`
 	PopulationCanChange  *bool    `gorm:"-"`
 	TransferExecuted     *bool    `gorm:"-"`
 	IsTransition         *bool    `gorm:"-"`

internal/entities/supplier.go

@@ -19,6 +19,7 @@ type Supplier struct {
 	Address       string         `gorm:"not null"`
 	Npwp          *string        `gorm:"size:50"`
 	AccountNumber *string        `gorm:"size:50"`
+	BankName      *string        `gorm:"size:100"`
 	Balance       float64        `gorm:"type:numeric(15,3);default:0"`
 	DueDate       int            `gorm:"not null"`
 	CreatedBy     uint           `gorm:"not null"`

internal/entities/system_setting.go

@@ -0,0 +1,17 @@
+package entities
+
+import "time"
+
+const SystemSettingKeyAllowNegativePakanOVK = "allow_negative_pakan_ovk"
+
+type SystemSetting struct {
+	Key         string    `gorm:"column:key;primaryKey" json:"key"`
+	Value       string    `gorm:"column:value;not null;default:''" json:"value"`
+	Description string    `gorm:"column:description" json:"description"`
+	CreatedAt   time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+	UpdatedAt   time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+}
+
+func (SystemSetting) TableName() string {
+	return "system_settings"
+}

internal/entities/warehouse.go

@@ -9,7 +9,7 @@ import (
 type Warehouse struct {
 	Id         uint   `gorm:"primaryKey"`
 	Name       string `gorm:"type:varchar(50);not null"`
-	Type       string `gorm:"not null"`
+	Type       string `gorm:"column:type;not null"`
 	AreaId     uint   `gorm:"not null"`
 	LocationId *uint
 	KandangId  *uint

internal/middleware/permissions.go

@@ -4,6 +4,10 @@ const (
 	P_DashboardGetAll = "lti.dashboard.list"
 )
 
+const (
+	P_SystemSettingUpdate = "lti.system_settings.update"
+)
+
 // project-flock
 const (
 	P_ProjectFlockKandangsClosing      = "lti.production.project_flock_kandangs.closing"
@@ -62,6 +66,7 @@ const (
 	P_ProductStockGetOne      = "lti.inventory.product_stock.detail"
 	P_ProductWarehousekGetAll = "lti.inventory.product_warehouses.list"
 	P_ProductWarehouseGetOne  = "lti.inventory.product_warehouses.detail"
+	P_StockLogGetAll          = "lti.inventory.stock_log.list"
 )
 const (
 	P_ClosingGetAll = "lti.closing.list"
@@ -203,6 +208,7 @@ const (
 	P_Finances_Transaction_DeleteOne = "lti.finance.transactions.delete"
 )
 const (
+	P_ChickinsGetAll    = "lti.production.chickins.list"
 	P_ChickinsCreateOne = "lti.production.chickins.create"
 	P_ChickinsGetOne    = "lti.production.chickins.detail"
 	P_ChickinsApproval  = "lti.production.chickins.approve"

internal/modules/closings/validations/closing.validation.go

@@ -10,7 +10,7 @@ type Update struct {
 
 type Query struct {
 	Page          int    `query:"page" validate:"omitempty,number,min=1,gt=0"`
-	Limit         int    `query:"limit" validate:"omitempty,number,min=1,max=100,gt=0"`
+	Limit         int    `query:"limit" validate:"omitempty,number,min=1,gt=0"`
 	Search        string `query:"search" validate:"omitempty,max=50"`
 	ProjectStatus *int   `query:"project_status" validate:"omitempty,oneof=1 2"`
 	LocationID    *uint  `query:"location_id" validate:"omitempty,gt=0"`
@@ -24,7 +24,7 @@ const (
 type ClosingSapronakQuery struct {
 	Type      string `query:"type" validate:"required,oneof=incoming outgoing"`
 	Page      int    `query:"page" validate:"omitempty,number,min=1,gt=0"`
-	Limit     int    `query:"limit" validate:"omitempty,number,min=1,max=100,gt=0"`
+	Limit     int    `query:"limit" validate:"omitempty,number,min=1,gt=0"`
 	KandangID *uint  `query:"kandang_id" validate:"omitempty,gt=0"`
 	Search    string `query:"search" validate:"omitempty,max=100"`
 }

internal/modules/daily-checklists/controllers/daily-checklist.controller.go

@@ -238,17 +238,17 @@ func (u *DailyChecklistController) GetReport(c *fiber.Ctx) error {
 	}
 
 	result, totalResults, err := u.DailyChecklistService.GetReport(c, query)
-	withoutActivities := func(src map[string]int) map[string]int {
-		if src == nil {
-			return map[string]int{}
-		}
-		return src
-	}
-
 	if err != nil {
 		return err
 	}
 
+	withoutActivities := func(src map[string]any) map[string]any {
+		if src == nil {
+			return map[string]any{}
+		}
+		return src
+	}
+
 	responseData := make([]dto.DailyChecklistReportDTO, len(result))
 	for i, item := range result {
 		responseData[i] = dto.DailyChecklistReportDTO{
@@ -412,6 +412,33 @@ func (u *DailyChecklistController) UpdateOne(c *fiber.Ctx) error {
 		})
 }
 
+func (u *DailyChecklistController) UpdateByPut(c *fiber.Ctx) error {
+	req := new(validation.Create)
+	param := c.Params("idDailyChecklist")
+
+	id, err := strconv.Atoi(param)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid Id")
+	}
+
+	if err := c.BodyParser(req); err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid request body")
+	}
+
+	result, err := u.DailyChecklistService.UpdateByPut(c, req, uint(id))
+	if err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).
+		JSON(response.Success{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Update dailyChecklist successfully",
+			Data:    dto.ToDailyChecklistListDTO(*result),
+		})
+}
+
 func validateDailyChecklistDocumentSizes(files []*multipart.FileHeader) error {
 	const maxDailyChecklistDocumentBytes = 5 * 1024 * 1024 // 5MB
 	for _, file := range files {

internal/modules/daily-checklists/dto/daily-checklist.dto.go

@@ -42,6 +42,13 @@ type DailyChecklistDetailDTO struct {
 	TotalActivity     int                                `json:"total_activity"`
 	Progress          float64                            `json:"progress"`
 	DocumentURLs      []DailyChecklistDocumentDTO        `json:"document_urls"`
+	EmptyKandang      *DailyChecklistEmptyKandangDTO     `json:"empty_kandang,omitempty"`
+}
+
+type DailyChecklistEmptyKandangDTO struct {
+	Id        uint      `json:"id"`
+	StartDate time.Time `json:"start_date"`
+	EndDate   time.Time `json:"end_date"`
 }
 
 type DailyChecklistDocumentDTO struct {
@@ -72,13 +79,14 @@ type DailyChecklistPerformanceOverviewDTO struct {
 	ActivityLeft  int                           `json:"activity_left"`
 }
 
+
 type DailyChecklistReportDTO struct {
 	Area            DailyChecklistReportEntityDTO  `json:"area"`
 	Farm            DailyChecklistReportEntityDTO  `json:"farm"`
 	Kandang         DailyChecklistReportEntityDTO  `json:"kandang"`
 	ABK             DailyChecklistReportEntityDTO  `json:"abk"`
 	Phase           string                         `json:"phase"`
-	DailyActivities map[string]int                 `json:"daily_activities"`
+	DailyActivities map[string]any                 `json:"daily_activities"`
 	Summary         DailyChecklistReportSummaryDTO `json:"summary"`
 }
 
@@ -179,6 +187,17 @@ func ToDailyChecklistListDTO(e entity.DailyChecklist) DailyChecklistListDTO {
 	}
 }
 
+func ToDailyChecklistEmptyKandangDTO(e *entity.DailyChecklistEmptyKandang) *DailyChecklistEmptyKandangDTO {
+	if e == nil || e.Id == 0 {
+		return nil
+	}
+	return &DailyChecklistEmptyKandangDTO{
+		Id:        e.Id,
+		StartDate: e.StartDate,
+		EndDate:   e.EndDate,
+	}
+}
+
 func ToDailyChecklistDetailDTO(checklist entity.DailyChecklist, phases []entity.DailyChecklistPhase, tasks []entity.DailyChecklistActivityTask, assignedEmployees []entity.Employee, totalActivities int, progress float64, documentURLs []DailyChecklistDocumentDTO) DailyChecklistDetailDTO {
 	phaseDTOs := make([]DailyChecklistPhaseDTO, 0, len(phases))
 	for _, phase := range phases {
@@ -240,5 +259,6 @@ func ToDailyChecklistDetailDTO(checklist entity.DailyChecklist, phases []entity.
 		TotalActivity:         totalActivities,
 		Progress:              progress,
 		DocumentURLs:          documentURLs,
+		EmptyKandang:          ToDailyChecklistEmptyKandangDTO(checklist.EmptyKandang),
 	}
 }

internal/modules/daily-checklists/module.go

@@ -22,6 +22,7 @@ type DailyChecklistModule struct{}
 
 func (DailyChecklistModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
 	dailyChecklistRepo := rDailyChecklist.NewDailyChecklistRepository(db)
+	emptyKandangRepo := rDailyChecklist.NewDailyChecklistEmptyKandangRepository(db)
 	phasesRepo := rPhases.NewPhasesRepository(db)
 	userRepo := rUser.NewUserRepository(db)
 	documentRepo := commonRepo.NewDocumentRepository(db)
@@ -30,7 +31,7 @@ func (DailyChecklistModule) RegisterRoutes(router fiber.Router, db *gorm.DB, val
 		panic(fmt.Sprintf("failed to create document service: %v", err))
 	}
 
-	dailyChecklistService := sDailyChecklist.NewDailyChecklistService(dailyChecklistRepo, phasesRepo, validate, documentSvc)
+	dailyChecklistService := sDailyChecklist.NewDailyChecklistService(dailyChecklistRepo, emptyKandangRepo, phasesRepo, validate, documentSvc)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	DailyChecklistRoutes(router, userService, dailyChecklistService)

internal/modules/daily-checklists/repositories/daily-checklist-empty-kandang.repository.go

@@ -0,0 +1,98 @@
+package repository
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	"gorm.io/gorm"
+)
+
+type DailyChecklistEmptyKandangRepository interface {
+	repository.BaseRepository[entity.DailyChecklistEmptyKandang]
+	FindByDailyChecklistID(ctx context.Context, dailyChecklistID uint) (*entity.DailyChecklistEmptyKandang, error)
+	FindOverlapping(ctx context.Context, kandangID uint, startDate, endDate time.Time, excludeDailyChecklistID uint) (*entity.DailyChecklistEmptyKandang, error)
+	FindActiveCoveringDate(ctx context.Context, kandangID uint, date time.Time) (*entity.DailyChecklistEmptyKandang, error)
+	FindOverlappingInRange(ctx context.Context, kandangIDs []uint, rangeStart, rangeEnd time.Time) ([]entity.DailyChecklistEmptyKandang, error)
+	SoftDeleteByDailyChecklistID(ctx context.Context, dailyChecklistID uint, actorID *uint) error
+}
+
+type DailyChecklistEmptyKandangRepositoryImpl struct {
+	*repository.BaseRepositoryImpl[entity.DailyChecklistEmptyKandang]
+}
+
+func NewDailyChecklistEmptyKandangRepository(db *gorm.DB) DailyChecklistEmptyKandangRepository {
+	return &DailyChecklistEmptyKandangRepositoryImpl{
+		BaseRepositoryImpl: repository.NewBaseRepository[entity.DailyChecklistEmptyKandang](db),
+	}
+}
+
+func (r *DailyChecklistEmptyKandangRepositoryImpl) FindByDailyChecklistID(ctx context.Context, dailyChecklistID uint) (*entity.DailyChecklistEmptyKandang, error) {
+	var rec entity.DailyChecklistEmptyKandang
+	if err := r.DB().WithContext(ctx).
+		Where("daily_checklist_id = ?", dailyChecklistID).
+		First(&rec).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &rec, nil
+}
+
+func (r *DailyChecklistEmptyKandangRepositoryImpl) FindOverlapping(ctx context.Context, kandangID uint, startDate, endDate time.Time, excludeDailyChecklistID uint) (*entity.DailyChecklistEmptyKandang, error) {
+	var rec entity.DailyChecklistEmptyKandang
+	query := r.DB().WithContext(ctx).
+		Where("kandang_id = ? AND start_date <= ? AND end_date >= ?", kandangID, endDate, startDate)
+	if excludeDailyChecklistID > 0 {
+		query = query.Where("daily_checklist_id <> ?", excludeDailyChecklistID)
+	}
+	if err := query.First(&rec).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &rec, nil
+}
+
+func (r *DailyChecklistEmptyKandangRepositoryImpl) FindActiveCoveringDate(ctx context.Context, kandangID uint, date time.Time) (*entity.DailyChecklistEmptyKandang, error) {
+	var rec entity.DailyChecklistEmptyKandang
+	if err := r.DB().WithContext(ctx).
+		Where("kandang_id = ? AND start_date <= ? AND end_date >= ?", kandangID, date, date).
+		First(&rec).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return &rec, nil
+}
+
+func (r *DailyChecklistEmptyKandangRepositoryImpl) FindOverlappingInRange(ctx context.Context, kandangIDs []uint, rangeStart, rangeEnd time.Time) ([]entity.DailyChecklistEmptyKandang, error) {
+	if len(kandangIDs) == 0 {
+		return []entity.DailyChecklistEmptyKandang{}, nil
+	}
+	var recs []entity.DailyChecklistEmptyKandang
+	if err := r.DB().WithContext(ctx).
+		Where("kandang_id IN ? AND start_date <= ? AND end_date >= ?", kandangIDs, rangeEnd, rangeStart).
+		Find(&recs).Error; err != nil {
+		return nil, err
+	}
+	return recs, nil
+}
+
+func (r *DailyChecklistEmptyKandangRepositoryImpl) SoftDeleteByDailyChecklistID(ctx context.Context, dailyChecklistID uint, actorID *uint) error {
+	updates := map[string]any{
+		"deleted_at": time.Now(),
+	}
+	if actorID != nil {
+		updates["deleted_by"] = *actorID
+	}
+	return r.DB().WithContext(ctx).
+		Model(&entity.DailyChecklistEmptyKandang{}).
+		Where("daily_checklist_id = ? AND deleted_at IS NULL", dailyChecklistID).
+		Updates(updates).Error
+}

internal/modules/daily-checklists/route.go

@@ -59,6 +59,7 @@ func DailyChecklistRoutes(v1 fiber.Router, u user.UserService, s dailyChecklist.
 	route.Post("/assignment", m.RequirePermissions(m.P_DailyChecklistCreateOne), ctrl.UpdateAssignment)
 
 	route.Patch("/bulk-update", m.RequirePermissions(m.P_DailyChecklistCreateOne), ctrl.BulkUpdate)
+	route.Put("/:idDailyChecklist", m.RequirePermissions(m.P_DailyChecklistCreateOne), ctrl.UpdateByPut)
 	route.Patch("/:idDailyChecklist", m.RequirePermissions(m.P_DailyChecklistCreateOne), ctrl.UpdateOne)
 	route.Delete("/:idDailyChecklist", m.RequirePermissions(m.P_DailyChecklistCreateOne), ctrl.DeleteOne)
 }

internal/modules/daily-checklists/services/daily-checklist.service.go

@@ -29,6 +29,7 @@ type DailyChecklistService interface {
 	GetOne(ctx *fiber.Ctx, id uint) (*entity.DailyChecklist, error)
 	CreateOne(ctx *fiber.Ctx, req *validation.Create) (*entity.DailyChecklist, error)
 	UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.DailyChecklist, error)
+	UpdateByPut(ctx *fiber.Ctx, req *validation.Create, id uint) (*entity.DailyChecklist, error)
 	BulkUpdate(ctx *fiber.Ctx, req *validation.BulkStatusUpdate) ([]entity.DailyChecklist, error)
 	DeleteOne(ctx *fiber.Ctx, id uint) error
 	AssignPhases(ctx *fiber.Ctx, id uint, req *validation.AssignPhases) error
@@ -43,11 +44,12 @@ type DailyChecklistService interface {
 }
 
 type dailyChecklistService struct {
-	Log         *logrus.Logger
-	Validate    *validator.Validate
-	Repository  repository.DailyChecklistRepository
-	PhaseRepo   phaseRepo.PhasesRepository
-	DocumentSvc commonSvc.DocumentService
+	Log              *logrus.Logger
+	Validate         *validator.Validate
+	Repository       repository.DailyChecklistRepository
+	EmptyKandangRepo repository.DailyChecklistEmptyKandangRepository
+	PhaseRepo        phaseRepo.PhasesRepository
+	DocumentSvc      commonSvc.DocumentService
 }
 
 type DailyChecklistDocument struct {
@@ -104,7 +106,7 @@ type DailyChecklistReportItem struct {
 	EmployeeID      uint
 	EmployeeName    string
 	PhaseName       string
-	DailyActivities map[string]int
+	DailyActivities map[string]any
 	Summary         DailyChecklistReportSummary
 }
 
@@ -123,26 +125,30 @@ type DailyChecklistReportCategory struct {
 }
 
 const (
-	dailyChecklistDateLayout           = "2006-01-02"
-	dailyChecklistCategoryEmptyKandang = "empty_kandang"
-	dailyChecklistStatusRejected       = "REJECTED"
-	dailyChecklistStatusDraft          = "DRAFT"
-	dailyChecklistErrEmptyKandangExist = "DailyChecklist cannot be created because empty_kandang already exists for at least one date in range"
-	dailyChecklistErrDateOverlapExist  = "DailyChecklist cannot be created because at least one date in range already has a checklist"
+	dailyChecklistDateLayout                      = "2006-01-02"
+	dailyChecklistCategoryEmptyKandang            = "empty_kandang"
+	dailyChecklistStatusRejected                  = "REJECTED"
+	dailyChecklistStatusDraft                     = "DRAFT"
+	dailyChecklistErrDateOverlapExist             = "DailyChecklist cannot be created because at least one date in range already has a checklist"
+	dailyChecklistErrDeletedNonEmptyKandangExists = "DailyChecklist cannot be created as empty_kandang because a deleted non-empty_kandang checklist exists for this date"
+	dailyChecklistErrEmptyKandangRangeOverlap     = "Empty kandang range overlaps with an existing empty kandang period for this kandang"
+	dailyChecklistErrDateInsideEmptyKandang       = "Tanggal berada dalam periode kandang kosong untuk kandang ini"
+	dailyChecklistErrEmptyKandangEndDateInvalid   = "empty_kandang_end_date harus >= date"
 )
 
-func NewDailyChecklistService(repo repository.DailyChecklistRepository, phaseRepo phaseRepo.PhasesRepository, validate *validator.Validate, documentSvc commonSvc.DocumentService) DailyChecklistService {
+func NewDailyChecklistService(repo repository.DailyChecklistRepository, emptyKandangRepo repository.DailyChecklistEmptyKandangRepository, phaseRepo phaseRepo.PhasesRepository, validate *validator.Validate, documentSvc commonSvc.DocumentService) DailyChecklistService {
 	return &dailyChecklistService{
-		Log:         utils.Log,
-		Validate:    validate,
-		Repository:  repo,
-		PhaseRepo:   phaseRepo,
-		DocumentSvc: documentSvc,
+		Log:              utils.Log,
+		Validate:         validate,
+		Repository:       repo,
+		EmptyKandangRepo: emptyKandangRepo,
+		PhaseRepo:        phaseRepo,
+		DocumentSvc:      documentSvc,
 	}
 }
 
 func (s dailyChecklistService) withRelations(db *gorm.DB) *gorm.DB {
-	return db.Preload("Kandang")
+	return db.Preload("Kandang").Preload("EmptyKandang")
 }
 
 func (s dailyChecklistService) ensureChecklistAccess(c *fiber.Ctx, checklistID uint) error {
@@ -276,7 +282,11 @@ func (s dailyChecklistService) GetAll(c *fiber.Ctx, params *validation.Query) ([
 		normalizedSearch := re.ReplaceAllString(params.Search, "")
 		if normalizedSearch != "" {
 			like := "%" + normalizedSearch + "%"
-			db = db.Where("(regexp_replace(k.name, '[^a-zA-Z0-9]', '', 'g') ILIKE ? OR regexp_replace(dc.category::text, '[^a-zA-Z0-9]', '', 'g') ILIKE ?)", like, like)
+			db = db.Where(`(
+					regexp_replace(k.name, '[^a-zA-Z0-9]', '', 'g') ILIKE ? OR
+					regexp_replace(dc.category::text, '[^a-zA-Z0-9]', '', 'g') ILIKE ? OR
+					(dc.category = 'empty_kandang' AND regexp_replace('Kandang Kosong', '[^a-zA-Z0-9]', '', 'g') ILIKE ?)
+				)`, like, like, like)
 		}
 	}
 
@@ -519,24 +529,28 @@ func (s *dailyChecklistService) CreateOne(c *fiber.Ctx, req *validation.Create)
 
 	status := req.Status
 	category := req.Category
-	endDate := date
 
 	if req.EmptyKandang {
-		if strings.TrimSpace(req.EmptyKandangEndDate) == "" {
-			return nil, fiber.NewError(fiber.StatusBadRequest, "empty_kandang_end_date is required when empty_kandang is true")
-		}
-
-		endDate, err = time.Parse(dailyChecklistDateLayout, strings.TrimSpace(req.EmptyKandangEndDate))
-		if err != nil {
-			return nil, fiber.NewError(fiber.StatusBadRequest, "invalid empty_kandang_end_date format, use YYYY-MM-DD")
-		}
-		if endDate.Before(date) {
-			return nil, fiber.NewError(fiber.StatusBadRequest, "empty_kandang_end_date must be greater than or equal to date")
-		}
-
 		category = dailyChecklistCategoryEmptyKandang
 	}
 
+	var emptyEndDate time.Time
+	if category == dailyChecklistCategoryEmptyKandang {
+		trimmedEnd := strings.TrimSpace(req.EmptyKandangEndDate)
+		if trimmedEnd == "" {
+			emptyEndDate = date
+		} else {
+			parsedEnd, parseErr := time.Parse(dailyChecklistDateLayout, trimmedEnd)
+			if parseErr != nil {
+				return nil, fiber.NewError(fiber.StatusBadRequest, "invalid empty_kandang_end_date format, use YYYY-MM-DD")
+			}
+			if parsedEnd.Before(date) {
+				return nil, fiber.NewError(fiber.StatusBadRequest, dailyChecklistErrEmptyKandangEndDateInvalid)
+			}
+			emptyEndDate = parsedEnd
+		}
+	}
+
 	targetID := uint(0)
 
 	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
@@ -544,18 +558,40 @@ func (s *dailyChecklistService) CreateOne(c *fiber.Ctx, req *validation.Create)
 			return err
 		}
 
-		if req.EmptyKandang {
-			if err := s.validateNoChecklistOverlapForEmptyKandang(tx, req.KandangId, date, endDate); err != nil {
+		if category == dailyChecklistCategoryEmptyKandang {
+			if err := s.validateNoNormalChecklistInRange(tx, req.KandangId, date, emptyEndDate, 0); err != nil {
+				return err
+			}
+			if err := s.validateNoEmptyKandangRangeOverlap(tx, req.KandangId, date, emptyEndDate, 0); err != nil {
+				return err
+			}
+			if err := s.validateNoExistingEmptyKandangInRange(tx, req.KandangId, date, emptyEndDate, 0); err != nil {
+				return err
+			}
+			if err := s.validateNoDeletedNonEmptyKandangForDate(tx, req.KandangId, date); err != nil {
+				return err
+			}
+		} else {
+			if err := s.validateDateNotInEmptyKandangRange(tx, req.KandangId, date, 0); err != nil {
+				return err
+			}
+			if err := s.validateDateNotInExistingEmptyKandangChecklist(tx, req.KandangId, date, 0); err != nil {
 				return err
 			}
-			return s.createBulkDailyChecklists(tx, req.KandangId, date, endDate, category, status, &targetID)
 		}
 
-		if err := s.validateNoEmptyKandangConflict(tx, req.KandangId, date, endDate); err != nil {
+		if err := s.createOrReuseSingleDailyChecklist(tx, req.KandangId, date, category, status, &targetID); err != nil {
 			return err
 		}
 
-		return s.createOrReuseSingleDailyChecklist(tx, req.KandangId, date, category, status, &targetID)
+		if category == dailyChecklistCategoryEmptyKandang {
+			actorID, _ := m.ActorIDFromContext(c)
+			if err := s.upsertEmptyKandangRange(tx, targetID, req.KandangId, date, emptyEndDate, actorID); err != nil {
+				return err
+			}
+		}
+
+		return nil
 	})
 	if err != nil {
 		s.Log.Errorf("Failed to create/upsert dailyChecklist: %+v", err)
@@ -585,31 +621,131 @@ func (s *dailyChecklistService) lockKandangForChecklistCreation(tx *gorm.DB, kan
 	return nil
 }
 
-func (s *dailyChecklistService) validateNoChecklistOverlapForEmptyKandang(tx *gorm.DB, kandangID uint, startDate, endDate time.Time) error {
+func (s *dailyChecklistService) validateNoNormalChecklistInRange(tx *gorm.DB, kandangID uint, startDate, endDate time.Time, excludeDCID uint) error {
+	q := tx.Model(&entity.DailyChecklist{}).
+		Where("kandang_id = ? AND date BETWEEN ? AND ? AND category <> ? AND deleted_at IS NULL",
+			kandangID, startDate, endDate, dailyChecklistCategoryEmptyKandang)
+	if excludeDCID > 0 {
+		q = q.Where("id <> ?", excludeDCID)
+	}
 	var conflictCount int64
-	if err := tx.Model(&entity.DailyChecklist{}).
-		Where("kandang_id = ? AND date BETWEEN ? AND ? AND deleted_at IS NULL", kandangID, startDate, endDate).
-		Count(&conflictCount).Error; err != nil {
+	if err := q.Count(&conflictCount).Error; err != nil {
 		return err
 	}
-
 	if conflictCount > 0 {
 		return fiber.NewError(fiber.StatusConflict, dailyChecklistErrDateOverlapExist)
 	}
-
 	return nil
 }
 
-func (s *dailyChecklistService) validateNoEmptyKandangConflict(tx *gorm.DB, kandangID uint, startDate, endDate time.Time) error {
+func (s *dailyChecklistService) validateNoEmptyKandangRangeOverlap(tx *gorm.DB, kandangID uint, startDate, endDate time.Time, excludeDCID uint) error {
+	q := tx.Model(&entity.DailyChecklistEmptyKandang{}).
+		Where("kandang_id = ? AND start_date <= ? AND end_date >= ?", kandangID, endDate, startDate)
+	if excludeDCID > 0 {
+		q = q.Where("daily_checklist_id <> ?", excludeDCID)
+	}
+	var overlapCount int64
+	if err := q.Count(&overlapCount).Error; err != nil {
+		return err
+	}
+	if overlapCount > 0 {
+		return fiber.NewError(fiber.StatusConflict, dailyChecklistErrEmptyKandangRangeOverlap)
+	}
+	return nil
+}
+
+func (s *dailyChecklistService) validateDateNotInEmptyKandangRange(tx *gorm.DB, kandangID uint, date time.Time, excludeDCID uint) error {
+	q := tx.Model(&entity.DailyChecklistEmptyKandang{}).
+		Where("kandang_id = ? AND start_date <= ? AND end_date >= ?", kandangID, date, date)
+	if excludeDCID > 0 {
+		q = q.Where("daily_checklist_id <> ?", excludeDCID)
+	}
+	var rec entity.DailyChecklistEmptyKandang
+	if err := q.First(&rec).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil
+		}
+		return err
+	}
+	return fiber.NewError(fiber.StatusConflict, dailyChecklistErrDateInsideEmptyKandang)
+}
+
+func (s *dailyChecklistService) validateNoExistingEmptyKandangInRange(tx *gorm.DB, kandangID uint, startDate, endDate time.Time, excludeDCID uint) error {
+	q := tx.Model(&entity.DailyChecklist{}).
+		Where("kandang_id = ? AND date BETWEEN ? AND ? AND category = ? AND deleted_at IS NULL",
+			kandangID, startDate, endDate, dailyChecklistCategoryEmptyKandang)
+	if excludeDCID > 0 {
+		q = q.Where("id <> ?", excludeDCID)
+	}
+	var conflictCount int64
+	if err := q.Count(&conflictCount).Error; err != nil {
+		return err
+	}
+	if conflictCount > 0 {
+		return fiber.NewError(fiber.StatusConflict, dailyChecklistErrEmptyKandangRangeOverlap)
+	}
+	return nil
+}
+
+func (s *dailyChecklistService) validateDateNotInExistingEmptyKandangChecklist(tx *gorm.DB, kandangID uint, date time.Time, excludeDCID uint) error {
+	q := tx.Model(&entity.DailyChecklist{}).
+		Where("kandang_id = ? AND date = ? AND category = ? AND deleted_at IS NULL",
+			kandangID, date, dailyChecklistCategoryEmptyKandang)
+	if excludeDCID > 0 {
+		q = q.Where("id <> ?", excludeDCID)
+	}
+	var conflictCount int64
+	if err := q.Count(&conflictCount).Error; err != nil {
+		return err
+	}
+	if conflictCount > 0 {
+		return fiber.NewError(fiber.StatusConflict, dailyChecklistErrDateInsideEmptyKandang)
+	}
+	return nil
+}
+
+func (s *dailyChecklistService) upsertEmptyKandangRange(tx *gorm.DB, dailyChecklistID, kandangID uint, startDate, endDate time.Time, actorID uint) error {
+	var existing entity.DailyChecklistEmptyKandang
+	err := tx.Where("daily_checklist_id = ?", dailyChecklistID).First(&existing).Error
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return err
+	}
+
+	if err == nil {
+		return tx.Model(&entity.DailyChecklistEmptyKandang{}).
+			Where("id = ?", existing.Id).
+			Updates(map[string]any{
+				"kandang_id": kandangID,
+				"start_date": startDate,
+				"end_date":   endDate,
+				"updated_at": time.Now(),
+			}).Error
+	}
+
+	record := &entity.DailyChecklistEmptyKandang{
+		DailyChecklistId: dailyChecklistID,
+		KandangId:        kandangID,
+		StartDate:        startDate,
+		EndDate:          endDate,
+	}
+	if actorID > 0 {
+		actor := actorID
+		record.CreatedBy = &actor
+	}
+	return tx.Create(record).Error
+}
+
+func (s *dailyChecklistService) validateNoDeletedNonEmptyKandangForDate(tx *gorm.DB, kandangID uint, date time.Time) error {
 	var conflictCount int64
 	if err := tx.Model(&entity.DailyChecklist{}).
-		Where("kandang_id = ? AND date BETWEEN ? AND ? AND category = ? AND deleted_at IS NULL", kandangID, startDate, endDate, dailyChecklistCategoryEmptyKandang).
+		Unscoped().
+		Where("kandang_id = ? AND date = ? AND deleted_at IS NULL AND category != ?", kandangID, date, dailyChecklistCategoryEmptyKandang).
 		Count(&conflictCount).Error; err != nil {
 		return err
 	}
 
 	if conflictCount > 0 {
-		return fiber.NewError(fiber.StatusConflict, dailyChecklistErrEmptyKandangExist)
+		return fiber.NewError(fiber.StatusBadRequest, dailyChecklistErrDeletedNonEmptyKandangExists)
 	}
 
 	return nil
@@ -856,6 +992,157 @@ func (s dailyChecklistService) BulkUpdate(c *fiber.Ctx, req *validation.BulkStat
 	return updated, nil
 }
 
+func (s *dailyChecklistService) UpdateByPut(c *fiber.Ctx, req *validation.Create, id uint) (*entity.DailyChecklist, error) {
+	if err := s.Validate.Struct(req); err != nil {
+		return nil, err
+	}
+
+	if err := s.ensureChecklistAccess(c, id); err != nil {
+		return nil, err
+	}
+
+	date, err := time.Parse(dailyChecklistDateLayout, strings.TrimSpace(req.Date))
+	if err != nil {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "invalid date format, use YYYY-MM-DD")
+	}
+
+	category := req.Category
+	if req.EmptyKandang {
+		category = dailyChecklistCategoryEmptyKandang
+	}
+
+	status := req.Status
+
+	var emptyEndDate time.Time
+	if category == dailyChecklistCategoryEmptyKandang {
+		trimmedEnd := strings.TrimSpace(req.EmptyKandangEndDate)
+		if trimmedEnd == "" {
+			emptyEndDate = date
+		} else {
+			parsedEnd, parseErr := time.Parse(dailyChecklistDateLayout, trimmedEnd)
+			if parseErr != nil {
+				return nil, fiber.NewError(fiber.StatusBadRequest, "invalid empty_kandang_end_date format, use YYYY-MM-DD")
+			}
+			if parsedEnd.Before(date) {
+				return nil, fiber.NewError(fiber.StatusBadRequest, dailyChecklistErrEmptyKandangEndDateInvalid)
+			}
+			emptyEndDate = parsedEnd
+		}
+	}
+
+	var wasBranchC bool // non-empty_kandang → empty_kandang transition
+	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
+		if err := s.lockKandangForChecklistCreation(tx, req.KandangId); err != nil {
+			return err
+		}
+
+		var existing entity.DailyChecklist
+		if err := tx.Where("id = ? AND deleted_at IS NULL", id).First(&existing).Error; err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return fiber.NewError(fiber.StatusNotFound, "DailyChecklist not found")
+			}
+			return err
+		}
+
+		existingIsEmpty := existing.Category == dailyChecklistCategoryEmptyKandang
+		newIsEmpty := category == dailyChecklistCategoryEmptyKandang
+
+		if newIsEmpty {
+			if err := s.validateNoNormalChecklistInRange(tx, req.KandangId, date, emptyEndDate, id); err != nil {
+				return err
+			}
+			if err := s.validateNoEmptyKandangRangeOverlap(tx, req.KandangId, date, emptyEndDate, id); err != nil {
+				return err
+			}
+		} else {
+			if err := s.validateDateNotInEmptyKandangRange(tx, req.KandangId, date, id); err != nil {
+				return err
+			}
+		}
+
+		var conflictCount int64
+		if err := tx.Model(&entity.DailyChecklist{}).
+			Where("id <> ? AND date = ? AND kandang_id = ? AND category = ? AND deleted_at IS NULL",
+				id, date, req.KandangId, category).
+			Count(&conflictCount).Error; err != nil {
+			return err
+		}
+		if conflictCount > 0 {
+			return fiber.NewError(fiber.StatusConflict, "DailyChecklist already exists with same date, kandang, and category")
+		}
+
+		result := tx.Model(&entity.DailyChecklist{}).Where("id = ?", id).Updates(map[string]any{
+			"date":       date,
+			"kandang_id": req.KandangId,
+			"category":   category,
+			"status":     status,
+		})
+		if result.Error != nil {
+			return result.Error
+		}
+		if result.RowsAffected == 0 {
+			return gorm.ErrRecordNotFound
+		}
+
+		actorID, _ := m.ActorIDFromContext(c)
+		if newIsEmpty {
+			if err := s.upsertEmptyKandangRange(tx, id, req.KandangId, date, emptyEndDate, actorID); err != nil {
+				return err
+			}
+			// Branch C: non-empty → empty_kandang, hard-delete task/progress data
+			if !existingIsEmpty {
+				wasBranchC = true
+				if err := tx.Exec(`
+					DELETE FROM daily_checklist_activity_task_assignments
+					WHERE task_id IN (
+						SELECT id FROM daily_checklist_activity_tasks WHERE checklist_id = ?
+					)`, id).Error; err != nil {
+					return err
+				}
+				if err := tx.Where("checklist_id = ?", id).Delete(&entity.DailyChecklistActivityTask{}).Error; err != nil {
+					return err
+				}
+				if err := tx.Where("daily_checklist_id = ?", id).Delete(&entity.DailyChecklistTask{}).Error; err != nil {
+					return err
+				}
+			}
+		} else if existingIsEmpty {
+			updates := map[string]any{
+				"deleted_at": time.Now(),
+			}
+			if actorID > 0 {
+				updates["deleted_by"] = actorID
+			}
+			if err := tx.Model(&entity.DailyChecklistEmptyKandang{}).
+				Where("daily_checklist_id = ? AND deleted_at IS NULL", id).
+				Updates(updates).Error; err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Branch C: delete DC documents outside transaction (storage is external)
+	if wasBranchC && s.DocumentSvc != nil {
+		docs, docErr := s.DocumentSvc.ListByTarget(c.Context(), string(utils.DocumentTypeDailyChecklist), uint64(id))
+		if docErr == nil && len(docs) > 0 {
+			docIDs := make([]uint, 0, len(docs))
+			for _, doc := range docs {
+				docIDs = append(docIDs, doc.Id)
+			}
+			if delErr := s.DocumentSvc.DeleteDocuments(c.Context(), docIDs, true); delErr != nil {
+				s.Log.Errorf("Failed to delete documents for DC %d during empty_kandang conversion: %+v", id, delErr)
+			}
+		}
+	}
+
+	return s.GetOne(c, id)
+}
+
 func (s dailyChecklistService) DeleteOne(c *fiber.Ctx, id uint) error {
 	if err := s.ensureChecklistAccess(c, id); err != nil {
 		return err
@@ -887,6 +1174,15 @@ func (s dailyChecklistService) DeleteOne(c *fiber.Ctx, id uint) error {
 			return gorm.ErrRecordNotFound
 		}
 
+		if err := tx.Model(&entity.DailyChecklistEmptyKandang{}).
+			Where("daily_checklist_id = ? AND deleted_at IS NULL", id).
+			Updates(map[string]any{
+				"deleted_at": time.Now(),
+				"deleted_by": actorID,
+			}).Error; err != nil {
+			return err
+		}
+
 		return nil
 	}); err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
@@ -1449,11 +1745,12 @@ func (s dailyChecklistService) GetReport(c *fiber.Ctx, params *validation.Report
 			Group("a.id, a.name, loc.id, loc.name, k.id, k.name, e.id, e.name, p.id, p.name")
 	}
 
-	var total int64
+	// --- Count approved rows ---
+	var approvedTotal int64
 	groupedForCount := buildGroupedQuery()
 	if err := s.Repository.DB().WithContext(c.Context()).
 		Table("(?) AS grouped", groupedForCount).
-		Count(&total).Error; err != nil {
+		Count(&approvedTotal).Error; err != nil {
 		s.Log.Errorf("Failed to count report data: %+v", err)
 		return nil, 0, err
 	}
@@ -1473,19 +1770,197 @@ func (s dailyChecklistService) GetReport(c *fiber.Ctx, params *validation.Report
 		TotalAssignments     int64
 	}
 
-	rows := make([]reportRow, 0)
-	if err := buildGroupedQuery().
-		Order("a.name, loc.name, k.name, e.name").
-		Offset(offset).
-		Limit(params.Limit).
-		Scan(&rows).Error; err != nil {
-		s.Log.Errorf("Failed to fetch report data: %+v", err)
+	type fallbackRowType struct {
+		AreaID       uint
+		AreaName     string
+		LocationID   uint
+		LocationName string
+		KandangID    uint
+		KandangName  string
+		EmployeeID   uint
+		EmployeeName string
+	}
+
+	// buildFallbackQ returns employees in kandangs that have NO approved checklist data
+	// for the filtered period. Applies the same scope/area/location/kandang/employee filters.
+	buildFallbackQ := func() *gorm.DB {
+		approvedKandangSubQ := buildBase().Select("DISTINCT dc.kandang_id")
+		q := s.Repository.DB().WithContext(c.Context()).
+			Table("employee_kandangs ek").
+			Joins("JOIN employees e ON e.id = ek.employee_id AND e.deleted_at IS NULL").
+			Joins("JOIN kandang_groups k ON k.id = ek.kandang_id AND k.deleted_at IS NULL").
+			Joins("JOIN locations loc ON loc.id = k.location_id AND loc.deleted_at IS NULL").
+			Joins("JOIN areas a ON a.id = loc.area_id AND a.deleted_at IS NULL").
+			Where("ek.kandang_id NOT IN (?)", approvedKandangSubQ).
+			Select("e.id AS employee_id, e.name AS employee_name, k.id AS kandang_id, k.name AS kandang_name, loc.id AS location_id, loc.name AS location_name, a.id AS area_id, a.name AS area_name")
+		q = m.ApplyScopeFilter(q, locationScope, "loc.id")
+		q = m.ApplyScopeFilter(q, areaScope, "a.id")
+		if params.AreaID != nil {
+			q = q.Where("a.id = ?", *params.AreaID)
+		}
+		if params.LocationID != nil {
+			q = q.Where("loc.id = ?", *params.LocationID)
+		}
+		if params.KandangID != nil {
+			q = q.Where("ek.kandang_id = ?", *params.KandangID)
+		}
+		if params.EmployeeID != nil {
+			q = q.Where("ek.employee_id = ?", *params.EmployeeID)
+		}
+		// PhaseID not applied: fallback rows have no phase data
+		return q
+	}
+
+	// --- Count fallback rows ---
+	var fallbackTotal int64
+	if err := s.Repository.DB().WithContext(c.Context()).
+		Table("(?) AS fb", buildFallbackQ()).
+		Count(&fallbackTotal).Error; err != nil {
+		s.Log.Errorf("Failed to count fallback report data: %+v", err)
 		return nil, 0, err
 	}
 
-	if len(rows) == 0 {
+	total := approvedTotal + fallbackTotal
+
+	// --- Fetch ALL approved rows (pagination done in Go after merging with fallback) ---
+	allApprovedRows := make([]reportRow, 0)
+	if approvedTotal > 0 {
+		if err := buildGroupedQuery().
+			Order("a.name, loc.name, k.name, e.name").
+			Scan(&allApprovedRows).Error; err != nil {
+			s.Log.Errorf("Failed to fetch report data: %+v", err)
+			return nil, 0, err
+		}
+	}
+
+	// --- Fetch ALL fallback rows ---
+	allFallbackRows := make([]fallbackRowType, 0)
+	if fallbackTotal > 0 {
+		if err := buildFallbackQ().
+			Order("a.name, loc.name, k.name, e.name").
+			Scan(&allFallbackRows).Error; err != nil {
+			s.Log.Errorf("Failed to fetch fallback report data: %+v", err)
+			return nil, 0, err
+		}
+	}
+
+	// --- Merge approved + fallback and sort consistently ---
+	type mergedEntry struct {
+		AreaName     string
+		LocationName string
+		KandangName  string
+		EmployeeName string
+		IsApproved   bool
+		Idx          int
+	}
+
+	merged := make([]mergedEntry, 0, len(allApprovedRows)+len(allFallbackRows))
+	for i, r := range allApprovedRows {
+		merged = append(merged, mergedEntry{
+			AreaName: r.AreaName, LocationName: r.LocationName,
+			KandangName: r.KandangName, EmployeeName: r.EmployeeName,
+			IsApproved: true, Idx: i,
+		})
+	}
+	for i, r := range allFallbackRows {
+		merged = append(merged, mergedEntry{
+			AreaName: r.AreaName, LocationName: r.LocationName,
+			KandangName: r.KandangName, EmployeeName: r.EmployeeName,
+			IsApproved: false, Idx: i,
+		})
+	}
+	sort.Slice(merged, func(i, j int) bool {
+		a, b := merged[i], merged[j]
+		if a.AreaName != b.AreaName {
+			return a.AreaName < b.AreaName
+		}
+		if a.LocationName != b.LocationName {
+			return a.LocationName < b.LocationName
+		}
+		if a.KandangName != b.KandangName {
+			return a.KandangName < b.KandangName
+		}
+		return a.EmployeeName < b.EmployeeName
+	})
+
+	// --- Apply Go-level pagination ---
+	end := offset + params.Limit
+	if end > len(merged) {
+		end = len(merged)
+	}
+	if offset >= len(merged) {
 		return []DailyChecklistReportItem{}, total, nil
 	}
+	pageData := merged[offset:end]
+
+	// --- Split page into approved vs fallback rows ---
+	pageApproved := make([]reportRow, 0)
+	pageFallback := make([]fallbackRowType, 0)
+	for _, entry := range pageData {
+		if entry.IsApproved {
+			pageApproved = append(pageApproved, allApprovedRows[entry.Idx])
+		} else {
+			pageFallback = append(pageFallback, allFallbackRows[entry.Idx])
+		}
+	}
+
+	applyEmptyKandangFlags := func(items []DailyChecklistReportItem, kandangIDs []uint) error {
+		if len(kandangIDs) == 0 {
+			return nil
+		}
+		firstDay := time.Date(params.Year, time.Month(params.Month), 1, 0, 0, 0, 0, time.UTC)
+		lastDay := firstDay.AddDate(0, 1, 0).AddDate(0, 0, -1)
+
+		type emptyRangeRec struct {
+			KandangID uint
+			StartDate time.Time
+			EndDate   time.Time
+		}
+		var rangeRecs []emptyRangeRec
+		if err := s.Repository.DB().WithContext(c.Context()).
+			Model(&entity.DailyChecklistEmptyKandang{}).
+			Where("kandang_id IN ? AND start_date <= ? AND end_date >= ?",
+				kandangIDs, lastDay, firstDay).
+			Select("kandang_id, start_date, end_date").
+			Scan(&rangeRecs).Error; err != nil {
+			s.Log.Errorf("Failed to get empty kandang ranges for report: %+v", err)
+			return err
+		}
+
+		emptyDaysByKandang := make(map[uint]map[int]struct{})
+
+		for _, rec := range rangeRecs {
+			effectiveStart := rec.StartDate
+			if effectiveStart.Before(firstDay) {
+				effectiveStart = firstDay
+			}
+			effectiveEnd := rec.EndDate
+			if effectiveEnd.After(lastDay) {
+				effectiveEnd = lastDay
+			}
+			if effectiveStart.After(effectiveEnd) {
+				continue
+			}
+
+			if _, ok := emptyDaysByKandang[rec.KandangID]; !ok {
+				emptyDaysByKandang[rec.KandangID] = make(map[int]struct{})
+			}
+			for d := effectiveStart; !d.After(effectiveEnd); d = d.AddDate(0, 0, 1) {
+				emptyDaysByKandang[rec.KandangID][d.Day()] = struct{}{}
+			}
+		}
+
+		for i, item := range items {
+			daySet := emptyDaysByKandang[item.KandangID]
+			for day := range daySet {
+				key := strconv.Itoa(day)
+				if _, exists := items[i].DailyActivities[key]; !exists {
+					items[i].DailyActivities[key] = "Kandang kosong"
+				}
+			}
+		}
+		return nil
+	}
 
 	type comboKey struct {
 		EmployeeID uint
@@ -1507,7 +1982,7 @@ func (s dailyChecklistService) GetReport(c *fiber.Ctx, params *validation.Report
 	kandangSet := make(map[uint]struct{})
 	phaseSet := make(map[uint]struct{})
 
-	for _, row := range rows {
+	for _, row := range pageApproved {
 		key := comboKey{EmployeeID: row.EmployeeID, KandangID: row.KandangID, PhaseID: row.PhaseID}
 		comboSet[key] = struct{}{}
 		if _, ok := employeeSet[row.EmployeeID]; !ok {
@@ -1648,8 +2123,9 @@ func (s dailyChecklistService) GetReport(c *fiber.Ctx, params *validation.Report
 		return selected
 	}
 
-	items := make([]DailyChecklistReportItem, len(rows))
-	for i, row := range rows {
+	// --- Build approved items (existing logic) ---
+	approvedItems := make([]DailyChecklistReportItem, len(pageApproved))
+	for i, row := range pageApproved {
 		key := comboKey{EmployeeID: row.EmployeeID, KandangID: row.KandangID, PhaseID: row.PhaseID}
 
 		activities := dailyActivityMap[key]
@@ -1659,7 +2135,7 @@ func (s dailyChecklistService) GetReport(c *fiber.Ctx, params *validation.Report
 
 		totalChecklist := 0
 		categoryCounts := DailyChecklistReportCategory{}
-		activityOutput := make(map[string]int, len(activities))
+		activityOutput := make(map[string]any, len(activities))
 
 		for day, stat := range activities {
 			activityOutput[day] = stat.Completed
@@ -1696,7 +2172,7 @@ func (s dailyChecklistService) GetReport(c *fiber.Ctx, params *validation.Report
 			kandangPercentage = int(math.Round(float64(kandangStat.Completed) / float64(kandangStat.Total) * 100))
 		}
 
-		items[i] = DailyChecklistReportItem{
+		approvedItems[i] = DailyChecklistReportItem{
 			AreaID:          row.AreaID,
 			AreaName:        row.AreaName,
 			LocationID:      row.LocationID,
@@ -1717,5 +2193,55 @@ func (s dailyChecklistService) GetReport(c *fiber.Ctx, params *validation.Report
 		}
 	}
 
-	return items, total, nil
+	// --- Build fallback items (kandangs with no approved data) ---
+	fallbackItems := make([]DailyChecklistReportItem, len(pageFallback))
+	for i, fb := range pageFallback {
+		fallbackItems[i] = DailyChecklistReportItem{
+			AreaID:          fb.AreaID,
+			AreaName:        fb.AreaName,
+			LocationID:      fb.LocationID,
+			LocationName:    fb.LocationName,
+			KandangID:       fb.KandangID,
+			KandangName:     fb.KandangName,
+			EmployeeID:      fb.EmployeeID,
+			EmployeeName:    fb.EmployeeName,
+			PhaseName:       "",
+			DailyActivities: map[string]any{},
+			Summary:         DailyChecklistReportSummary{},
+		}
+	}
+
+	// --- Reconstruct allItems in the sorted pageData order ---
+	allItems := make([]DailyChecklistReportItem, len(pageData))
+	approvedIdx := 0
+	fallbackIdx := 0
+	for i, entry := range pageData {
+		if entry.IsApproved {
+			allItems[i] = approvedItems[approvedIdx]
+			approvedIdx++
+		} else {
+			allItems[i] = fallbackItems[fallbackIdx]
+			fallbackIdx++
+		}
+	}
+
+	// --- Collect all kandangIDs on this page (approved + fallback) for empty_kandang flags ---
+	allKandangSet := make(map[uint]struct{})
+	for _, id := range kandangIDs {
+		allKandangSet[id] = struct{}{}
+	}
+	for _, fb := range pageFallback {
+		allKandangSet[fb.KandangID] = struct{}{}
+	}
+	allKandangIDs := make([]uint, 0, len(allKandangSet))
+	for id := range allKandangSet {
+		allKandangIDs = append(allKandangIDs, id)
+	}
+
+	// --- Flag empty kandang days within this report month ---
+	if err := applyEmptyKandangFlags(allItems, allKandangIDs); err != nil {
+		return nil, 0, err
+	}
+
+	return allItems, total, nil
 }

internal/modules/daily-checklists/services/daily-checklist.service_test.go

@@ -208,8 +208,18 @@ func TestCreateOneAllowsBulkEmptyKandangWhenRangeHasOnlySoftDeletedChecklist(t *
 		Count(&activeInRange).Error; err != nil {
 		t.Fatalf("failed counting checklists in range: %v", err)
 	}
-	if activeInRange != 5 {
-		t.Fatalf("expected 5 active checklists created for range, got %d", activeInRange)
+	if activeInRange != 1 {
+		t.Fatalf("expected 1 active empty_kandang checklist created for range, got %d", activeInRange)
+	}
+
+	var emptyRangeCount int64
+	if err := db.Model(&entity.DailyChecklistEmptyKandang{}).
+		Where("kandang_id = ? AND start_date = ? AND end_date = ? AND deleted_at IS NULL", 1, mustDate(t, "2026-01-01"), mustDate(t, "2026-01-05")).
+		Count(&emptyRangeCount).Error; err != nil {
+		t.Fatalf("failed counting empty kandang ranges: %v", err)
+	}
+	if emptyRangeCount != 1 {
+		t.Fatalf("expected 1 empty kandang range record for [2026-01-01, 2026-01-05], got %d", emptyRangeCount)
 	}
 }
 
@@ -304,6 +314,18 @@ func setupDailyChecklistServiceTest(t *testing.T) (DailyChecklistService, *gorm.
 			updated_at DATETIME NULL,
 			deleted_at DATETIME NULL
 		)`,
+		`CREATE TABLE daily_checklist_empty_kandangs (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			daily_checklist_id INTEGER NOT NULL,
+			kandang_id INTEGER NOT NULL,
+			start_date DATE NOT NULL,
+			end_date DATE NOT NULL,
+			created_by INTEGER NULL,
+			deleted_by INTEGER NULL,
+			created_at DATETIME NULL,
+			updated_at DATETIME NULL,
+			deleted_at DATETIME NULL
+		)`,
 		`INSERT INTO areas (id, name, created_by, created_at, updated_at, deleted_at) VALUES (1, 'Area A', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, NULL)`,
 		`INSERT INTO locations (id, name, address, area_id, created_by, created_at, updated_at, deleted_at) VALUES (1, 'Farm A', 'Address', 1, 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, NULL)`,
 		`INSERT INTO kandang_groups (id, name, status, location_id, pic_id, created_by, created_at, updated_at, deleted_at) VALUES (1, 'Kandang A', 'ACTIVE', 1, 1, 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, NULL)`,
@@ -316,7 +338,8 @@ func setupDailyChecklistServiceTest(t *testing.T) (DailyChecklistService, *gorm.
 	}
 
 	repo := repository.NewDailyChecklistRepository(db)
-	svc := NewDailyChecklistService(repo, nil, validator.New(), nil)
+	emptyRepo := repository.NewDailyChecklistEmptyKandangRepository(db)
+	svc := NewDailyChecklistService(repo, emptyRepo, nil, validator.New(), nil)
 	return svc, db
 }
 

internal/modules/daily-checklists/validations/daily-checklist.validation.go

@@ -10,7 +10,7 @@ type Create struct {
 	Category            string `json:"category" validate:"required"`
 	Status              string `json:"status" validate:"required"`
 	EmptyKandang        bool   `json:"empty_kandang"`
-	EmptyKandangEndDate string `json:"empty_kandang_end_date"`
+	EmptyKandangEndDate string `json:"empty_kandang_end_date" validate:"omitempty"`
 }
 
 type Update struct {

internal/modules/dashboards/repositories/dashboard_stats.repository.go

@@ -119,9 +119,9 @@ func (r *DashboardRepositoryImpl) GetRecordingWeeklyMetrics(ctx context.Context,
 	var rows []RecordingWeeklyMetric
 
 	weekExpr := `CASE
-		WHEN r.day IS NULL OR r.day <= 0 THEN 1
-		WHEN UPPER(pf.category) = 'LAYING' THEN ((r.day - 1) / 7 + 1) + 17
-		ELSE ((r.day - 1) / 7 + 1)
+		WHEN r.day IS NULL OR r.day < 0 THEN 1
+		WHEN UPPER(pf.category) = 'LAYING' THEN (r.day / 7 + 1) + 17
+		ELSE (r.day / 7 + 1)
 	END`
 
 	db := r.DB().WithContext(ctx).
@@ -503,9 +503,9 @@ func (r *DashboardRepositoryImpl) GetComparisonWeeklyMetrics(ctx context.Context
 
 	var rows []ComparisonWeeklyMetric
 	weekExpr := `CASE
-		WHEN r.day IS NULL OR r.day <= 0 THEN 1
-		WHEN UPPER(pf.category) = 'LAYING' THEN ((r.day - 1) / 7 + 1) + 17
-		ELSE ((r.day - 1) / 7 + 1)
+		WHEN r.day IS NULL OR r.day < 0 THEN 1
+		WHEN UPPER(pf.category) = 'LAYING' THEN (r.day / 7 + 1) + 17
+		ELSE (r.day / 7 + 1)
 	END`
 
 	db := r.DB().WithContext(ctx).
@@ -574,9 +574,9 @@ func (r *DashboardRepositoryImpl) GetEggQualityWeeklyMetrics(ctx context.Context
 	var rows []EggQualityWeeklyMetric
 
 	weekExpr := `CASE
-		WHEN r.day IS NULL OR r.day <= 0 THEN 1
-		WHEN UPPER(pf.category) = 'LAYING' THEN ((r.day - 1) / 7 + 1) + 17
-		ELSE ((r.day - 1) / 7 + 1)
+		WHEN r.day IS NULL OR r.day < 0 THEN 1
+		WHEN UPPER(pf.category) = 'LAYING' THEN (r.day / 7 + 1) + 17
+		ELSE (r.day / 7 + 1)
 	END`
 
 	db := r.DB().WithContext(ctx).
@@ -616,9 +616,9 @@ func (r *DashboardRepositoryImpl) GetEggWeightWeeklyGrams(ctx context.Context, s
 	var rows []WeeklyEggWeightMetric
 
 	weekExpr := `CASE
-		WHEN r.day IS NULL OR r.day <= 0 THEN 1
-		WHEN UPPER(pf.category) = 'LAYING' THEN ((r.day - 1) / 7 + 1) + 17
-		ELSE ((r.day - 1) / 7 + 1)
+		WHEN r.day IS NULL OR r.day < 0 THEN 1
+		WHEN UPPER(pf.category) = 'LAYING' THEN (r.day / 7 + 1) + 17
+		ELSE (r.day / 7 + 1)
 	END`
 
 	db := r.DB().WithContext(ctx).
@@ -647,9 +647,9 @@ func (r *DashboardRepositoryImpl) GetFeedUsageWeeklyByUom(ctx context.Context, s
 	var rows []WeeklyFeedUsageMetric
 
 	weekExpr := `CASE
-		WHEN r.day IS NULL OR r.day <= 0 THEN 1
-		WHEN UPPER(pf.category) = 'LAYING' THEN ((r.day - 1) / 7 + 1) + 17
-		ELSE ((r.day - 1) / 7 + 1)
+		WHEN r.day IS NULL OR r.day < 0 THEN 1
+		WHEN UPPER(pf.category) = 'LAYING' THEN (r.day / 7 + 1) + 17
+		ELSE (r.day / 7 + 1)
 	END`
 
 	db := r.DB().WithContext(ctx).

internal/modules/expenses/controllers/expense.controller.go

@@ -65,6 +65,8 @@ func (u *ExpenseController) GetAll(c *fiber.Ctx) error {
 		RealizationStatus:     strings.TrimSpace(c.Query("realization_status", "")),
 		ProjectFlockID:        uint64(c.QueryInt("project_flock_id", 0)),
 		ProjectFlockKandangID: uint64(c.QueryInt("project_flock_kandang_id", 0)),
+		SortBy:                strings.TrimSpace(c.Query("sort_by", "")),
+		SortOrder:             strings.TrimSpace(c.Query("sort_order", "")),
 	}
 
 	if isAllExpenseExcelExportRequest(c) {
@@ -481,6 +483,27 @@ func (u *ExpenseController) CompleteExpense(c *fiber.Ctx) error {
 		})
 }
 
+func (u *ExpenseController) Pay(c *fiber.Ctx) error {
+	expenseID := c.Params("id")
+	id, err := strconv.Atoi(expenseID)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid expense ID")
+	}
+
+	expense, err := u.ExpenseService.Pay(c, uint(id))
+	if err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).
+		JSON(response.Success{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Pay expense successfully",
+			Data:    expense,
+		})
+}
+
 func ensureExpenseBulkApprovalPermission(c *fiber.Ctx, targetStep approvalutils.ApprovalStep) error {
 	requiredPerms := []string{}
 

internal/modules/expenses/dto/expense.dto.go

@@ -29,6 +29,7 @@ type ExpenseBaseDTO struct {
 	RealizationDate *time.Time                       `json:"realization_date,omitempty"`
 	TransactionDate time.Time                        `json:"transaction_date"`
 	Location        *locationDTO.LocationRelationDTO `json:"location,omitempty"`
+		IsPaid          bool                             `json:"is_paid"`
 }
 
 type ExpenseListDTO struct {
@@ -86,6 +87,7 @@ type KandangGroupDTO struct {
 type DocumentDTO struct {
 	ID   uint64 `json:"id"`
 	Path string `json:"path"`
+	Name string `json:"name"`
 }
 
 // === MAPPERS ===
@@ -126,6 +128,7 @@ func ToExpenseBaseDTO(e *entity.Expense) ExpenseBaseDTO {
 		RealizationDate: realizationDate,
 		TransactionDate: e.TransactionDate,
 		Location:        location,
+		IsPaid:          e.IsPaid,
 	}
 }
 
@@ -184,6 +187,7 @@ func ToExpenseDetailDTO(e *entity.Expense) ExpenseDetailDTO {
 		documents = append(documents, DocumentDTO{
 			ID:   uint64(doc.Id),
 			Path: doc.Path,
+			Name: doc.Name,
 		})
 	}
 
@@ -191,6 +195,7 @@ func ToExpenseDetailDTO(e *entity.Expense) ExpenseDetailDTO {
 		realizationDocs = append(realizationDocs, DocumentDTO{
 			ID:   uint64(doc.Id),
 			Path: doc.Path,
+			Name: doc.Name,
 		})
 	}
 

internal/modules/expenses/repositories/expense_realization.repository.go

@@ -177,10 +177,48 @@ func (r *ExpenseRealizationRepositoryImpl) GetAllWithFilters(ctx context.Context
 		return nil, 0, err
 	}
 
+	sortExpr := "expense_realizations.created_at"
+	order := "DESC"
+	if filters.SortOrder == "asc" {
+		order = "ASC"
+	}
+	switch filters.SortBy {
+	case "po_number":
+		sortExpr = "expenses.po_number"
+	case "reference_number":
+		sortExpr = "expenses.reference_number"
+	case "realization_date":
+		sortExpr = "expenses.realization_date"
+	case "transaction_date":
+		sortExpr = "expenses.transaction_date"
+	case "category":
+		sortExpr = "expenses.category"
+	case "product":
+		sortExpr = "(SELECT name FROM nonstocks WHERE id = expense_nonstocks.nonstock_id)"
+	case "supplier":
+		sortExpr = "suppliers.name"
+	case "location":
+		sortExpr = "(SELECT l.name FROM kandangs k JOIN locations l ON l.id = k.location_id WHERE k.id = expense_nonstocks.kandang_id)"
+	case "kandang":
+		sortExpr = "(SELECT name FROM kandangs WHERE id = expense_nonstocks.kandang_id)"
+	case "qty_pengajuan":
+		sortExpr = "expense_nonstocks.qty"
+	case "price_pengajuan":
+		sortExpr = "expense_nonstocks.price"
+	case "total_pengajuan":
+		sortExpr = "expense_nonstocks.qty * expense_nonstocks.price"
+	case "qty_realisasi":
+		sortExpr = "expense_realizations.qty"
+	case "price_realisasi":
+		sortExpr = "expense_realizations.price"
+	case "total_realisasi":
+		sortExpr = "expense_realizations.qty * expense_realizations.price"
+	}
+
 	if err := db.
 		Offset(offset).
 		Limit(limit).
-		Order("expense_realizations.created_at DESC").
+		Order(sortExpr + " " + order).
 		Find(&realizations).Error; err != nil {
 		return nil, 0, err
 	}

internal/modules/expenses/route.go

@@ -36,6 +36,7 @@ func ExpenseRoutes(v1 fiber.Router, u user.UserService, s expense.ExpenseService
 	route.Post("/:id/realizations", m.RequirePermissions(m.P_ExpenseCreateRealizations), ctrl.CreateRealization)
 	route.Patch("/:id/realizations", m.RequirePermissions(m.P_ExpenseUpdateRealizations), ctrl.UpdateRealization)
 	route.Post("/:id/complete", m.RequirePermissions(m.P_ExpenseCompleteExpense), ctrl.CompleteExpense)
+	route.Patch("/:id/pay", m.RequirePermissions(m.P_ExpenseCreateRealizations), ctrl.Pay)
 	route.Delete("/:id/documents/:documentId", m.RequirePermissions(m.P_ExpenseDocument), ctrl.DeleteDocument)
 	route.Delete("/:id/realization-documents/:documentId", m.RequirePermissions(m.P_ExpenseDocumentRealizations), ctrl.DeleteRealizationDocument)
 }

internal/modules/expenses/services/expense.service.go

@@ -36,6 +36,7 @@ type ExpenseService interface {
 	DeleteOne(ctx *fiber.Ctx, id uint64) error
 	CreateRealization(ctx *fiber.Ctx, expenseID uint, req *validation.CreateRealization) (*expenseDto.ExpenseDetailDTO, error)
 	CompleteExpense(ctx *fiber.Ctx, id uint, notes *string) (*expenseDto.ExpenseDetailDTO, error)
+	Pay(ctx *fiber.Ctx, id uint) (*expenseDto.ExpenseDetailDTO, error)
 	UpdateRealization(ctx *fiber.Ctx, expenseID uint, req *validation.UpdateRealization) (*expenseDto.ExpenseDetailDTO, error)
 	DeleteDocument(ctx *fiber.Ctx, expenseID uint, documentID uint64, isRealization bool) error
 	Approval(ctx *fiber.Ctx, req *validation.ApprovalRequest, approvalType string) ([]expenseDto.ExpenseDetailDTO, error)
@@ -288,7 +289,40 @@ func (s expenseService) GetAll(c *fiber.Ctx, params *validation.Query) ([]expens
 				like,
 			)
 		}
-		return db.Order("expenses.created_at DESC").Order("expenses.updated_at DESC")
+		sortBy := strings.TrimSpace(params.SortBy)
+		sortOrder := strings.ToUpper(strings.TrimSpace(params.SortOrder))
+		if sortOrder == "" {
+			sortOrder = "DESC"
+		}
+
+		switch sortBy {
+		case "reference_number":
+			return db.Order("expenses.reference_number " + sortOrder)
+		case "transaction_date":
+			return db.Order("expenses.transaction_date " + sortOrder)
+		case "realization_date":
+			return db.Order("expenses.realization_date " + sortOrder)
+		case "location":
+			return db.Order("(SELECT COALESCE(name,'') FROM locations WHERE id = expenses.location_id) " + sortOrder)
+		case "created_user":
+			return db.Order("(SELECT COALESCE(name,'') FROM users WHERE id = expenses.created_by) " + sortOrder)
+		case "supplier":
+			return db.Order("(SELECT COALESCE(name,'') FROM suppliers WHERE id = expenses.supplier_id) " + sortOrder)
+		case "grand_total":
+			return db.Order(`(SELECT COALESCE(
+				(SELECT SUM(er.qty * er.price) FROM expense_realizations er
+				 JOIN expense_nonstocks en ON en.id = er.expense_nonstock_id
+				 WHERE en.expense_id = expenses.id),
+				(SELECT SUM(en2.qty * en2.price) FROM expense_nonstocks en2
+				 WHERE en2.expense_id = expenses.id),
+			0)) ` + sortOrder)
+		case "is_paid":
+			return db.Order("expenses.is_paid " + sortOrder)
+		case "created_at":
+			return db.Order("expenses.created_at " + sortOrder)
+		default:
+			return db.Order("expenses.created_at DESC").Order("expenses.updated_at DESC")
+		}
 	})
 
 	if scopeErr != nil {
@@ -342,6 +376,18 @@ func (s expenseService) GetOne(c *fiber.Ctx, id uint) (*expenseDto.ExpenseDetail
 	expense.LatestApproval = approval
 
 	responseDTO := expenseDto.ToExpenseDetailDTO(expense)
+
+	for i := range responseDTO.Documents {
+		if url, err := commonSvc.ResolveDocumentURL(c.Context(), s.DocumentSvc, responseDTO.Documents[i].Path, 15*time.Minute); err == nil && url != "" {
+			responseDTO.Documents[i].Path = url
+		}
+	}
+	for i := range responseDTO.RealizationDocs {
+		if url, err := commonSvc.ResolveDocumentURL(c.Context(), s.DocumentSvc, responseDTO.RealizationDocs[i].Path, 15*time.Minute); err == nil && url != "" {
+			responseDTO.RealizationDocs[i].Path = url
+		}
+	}
+
 	return &responseDTO, nil
 }
 
@@ -1298,6 +1344,41 @@ func (s *expenseService) CompleteExpense(c *fiber.Ctx, id uint, notes *string) (
 	return responseDTO, nil
 }
 
+func (s *expenseService) Pay(c *fiber.Ctx, id uint) (*expenseDto.ExpenseDetailDTO, error) {
+	if err := commonSvc.EnsureRelations(c.Context(),
+		commonSvc.RelationCheck{Name: "Expense", ID: &id, Exists: s.Repository.IdExists},
+	); err != nil {
+		return nil, err
+	}
+
+	expense, err := s.Repository.GetByID(c.Context(), id, nil)
+	if err != nil {
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to get expense")
+	}
+	if expense.IsPaid {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Expense is already paid")
+	}
+
+	latestApproval, err := s.ApprovalSvc.LatestByTarget(c.Context(), utils.ApprovalWorkflowExpense, id, func(db *gorm.DB) *gorm.DB {
+		return db.Where("action = ?", entity.ApprovalActionApproved)
+	})
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to validate workflow")
+	}
+	if latestApproval == nil {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Expense must be approved by Finance (step 4) before payment")
+	}
+	if latestApproval.StepNumber < uint16(utils.ExpenseStepFinance) {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Expense must be approved by Finance (step 4) before payment")
+	}
+
+	if err := s.Repository.PatchOne(c.Context(), id, map[string]any{"is_paid": true}, nil); err != nil {
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to update payment status")
+	}
+
+	return s.GetOne(c, id)
+}
+
 func (s *expenseService) UpdateRealization(c *fiber.Ctx, expenseID uint, req *validation.UpdateRealization) (*expenseDto.ExpenseDetailDTO, error) {
 	if err := s.Validate.Struct(req); err != nil {
 

internal/modules/expenses/validations/expense.validation.go

@@ -54,6 +54,8 @@ type Query struct {
 	RealizationStatus     string `query:"realization_status" validate:"omitempty,max=100"`
 	ProjectFlockID        uint64 `query:"project_flock_id" validate:"omitempty,gt=0"`
 	ProjectFlockKandangID uint64 `query:"project_flock_kandang_id" validate:"omitempty,gt=0"`
+	SortBy                string `query:"sort_by" validate:"omitempty,oneof=reference_number transaction_date realization_date location created_user supplier grand_total is_paid created_at"`
+	SortOrder             string `query:"sort_order" validate:"omitempty,oneof=asc desc ASC DESC"`
 }
 
 type CreateRealization struct {

internal/modules/finance/transactions/controllers/transaction.controller.go

@@ -97,6 +97,8 @@ func (u *TransactionController) GetAll(c *fiber.Ctx) error {
 		CustomerIDs:      customerIDs,
 		SupplierIDs:      supplierIDs,
 		SortDate:         c.Query("sort_date", ""),
+		SortBy:           c.Query("sort_by", ""),
+		SortOrder:        c.Query("sort_order", ""),
 		StartDate:        c.Query("start_date", ""),
 		EndDate:          c.Query("end_date", ""),
 	}

internal/modules/finance/transactions/services/transaction.service.go

@@ -72,27 +72,36 @@ func (s transactionService) GetAll(c *fiber.Ctx, params *validation.Query) ([]en
 	transactions, total, err := s.Repository.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
 		db = s.withRelations(db)
 
-		if params.Search != "" {
-			like := "%" + strings.ToLower(strings.TrimSpace(params.Search)) + "%"
+		needsPartyJoin := params.Search != "" || params.SortBy == "customer_name"
+		needsBankJoin := params.Search != "" || params.SortBy == "bank"
+
+		if needsPartyJoin {
 			db = db.Joins(
 				"LEFT JOIN customers ON customers.id = payments.party_id AND payments.party_type = ? AND customers.deleted_at IS NULL",
 				string(utils.PaymentPartyCustomer),
 			).Joins(
 				"LEFT JOIN suppliers ON suppliers.id = payments.party_id AND payments.party_type = ? AND suppliers.deleted_at IS NULL",
 				string(utils.PaymentPartySupplier),
-			).Joins(
-				"LEFT JOIN banks ON banks.id = payments.bank_id AND banks.deleted_at IS NULL",
 			)
+		}
+		if needsBankJoin {
+			db = db.Joins("LEFT JOIN banks ON banks.id = payments.bank_id AND banks.deleted_at IS NULL")
+		}
+
+		if params.Search != "" {
+			like := "%" + strings.ToLower(strings.TrimSpace(params.Search)) + "%"
 			db = db.Where(
-				`LOWER(payment_code) LIKE ? OR
+				`(LOWER(payment_code) LIKE ? OR
 				LOWER(COALESCE(reference_number, '')) LIKE ? OR
 				LOWER(COALESCE(payment_method, '')) LIKE ? OR
 				LOWER(COALESCE(transaction_type, '')) LIKE ? OR
 				LOWER(COALESCE(notes, '')) LIKE ? OR
 				LOWER(COALESCE(customers.name, '')) LIKE ? OR
 				LOWER(COALESCE(suppliers.name, '')) LIKE ? OR
-				LOWER(COALESCE(banks.name, '')) LIKE ?`,
-				like, like, like, like, like, like, like, like,
+				LOWER(COALESCE(banks.name, '')) LIKE ? OR
+				CAST(payments.nominal AS TEXT) LIKE ? OR
+				TO_CHAR(payments.payment_date, 'YYYY-MM-DD') LIKE ?)`,
+				like, like, like, like, like, like, like, like, like, like,
 			)
 		}
 
@@ -136,7 +145,7 @@ func (s transactionService) GetAll(c *fiber.Ctx, params *validation.Query) ([]en
 			db = db.Where("payment_date < ?", *endDate)
 		}
 
-		return applyTransactionSort(db, params.SortDate)
+		return applyTransactionSort(db, params.SortBy, params.SortOrder, params.SortDate)
 	})
 
 	if err != nil {
@@ -268,13 +277,39 @@ func parseTransactionDateRange(startDate, endDate string) (*time.Time, *time.Tim
 	return startPtr, endPtr, nil
 }
 
-func applyTransactionSort(db *gorm.DB, sortDate string) *gorm.DB {
+func applyTransactionSort(db *gorm.DB, sortBy, sortOrder, sortDate string) *gorm.DB {
+	order := "DESC"
+	if strings.ToUpper(strings.TrimSpace(sortOrder)) == "ASC" {
+		order = "ASC"
+	}
+
+	switch strings.ToLower(strings.TrimSpace(sortBy)) {
+	case "payment_code":
+		return db.Order("payments.payment_code " + order)
+	case "reference_number":
+		return db.Order("payments.reference_number " + order)
+	case "transaction_type":
+		return db.Order("payments.transaction_type " + order)
+	case "customer_name":
+		return db.Order("COALESCE(customers.name, suppliers.name) " + order)
+	case "payment_date":
+		return db.Order("payments.payment_date " + order)
+	case "created_at":
+		return db.Order("payments.created_at " + order)
+	case "payment_method":
+		return db.Order("payments.payment_method " + order)
+	case "bank":
+		return db.Order("banks.account_number " + order)
+	case "expense_amount":
+		return db.Order("CASE WHEN payments.direction = 'OUT' THEN payments.nominal ELSE 0 END " + order)
+	case "income_amount":
+		return db.Order("CASE WHEN payments.direction = 'IN' THEN payments.nominal ELSE 0 END " + order)
+	}
+
 	switch strings.ToLower(strings.TrimSpace(sortDate)) {
 	case "created_at":
-		return db.Order("created_at DESC").Order("payment_date DESC")
-	case "payment_date":
-		return db.Order("payment_date DESC").Order("created_at DESC")
+		return db.Order("payments.created_at DESC").Order("payments.payment_date DESC")
 	default:
-		return db.Order("payment_date DESC").Order("created_at DESC")
+		return db.Order("payments.payment_date DESC").Order("payments.created_at DESC")
 	}
 }

internal/modules/finance/transactions/validations/transaction.validation.go

@@ -17,6 +17,8 @@ type Query struct {
 	CustomerIDs      []uint   `query:"customer_ids" validate:"omitempty,dive,gt=0"`
 	SupplierIDs      []uint   `query:"supplier_ids" validate:"omitempty,dive,gt=0"`
 	SortDate         string   `query:"sort_date" validate:"omitempty,oneof=created_at payment_date"`
+	SortBy           string   `query:"sort_by" validate:"omitempty,oneof=payment_code reference_number transaction_type customer_name payment_date created_at payment_method bank expense_amount income_amount"`
+	SortOrder        string   `query:"sort_order" validate:"omitempty,oneof=asc desc"`
 	StartDate        string   `query:"start_date" validate:"omitempty,datetime=2006-01-02"`
 	EndDate          string   `query:"end_date" validate:"omitempty,datetime=2006-01-02"`
 }

internal/modules/inventory/adjustments/dto/adjustment.dto.go

@@ -33,6 +33,7 @@ type ProjectFlockRelationDTO struct {
 type WarehouseRelationDTO struct {
 	Id       uint                 `json:"id"`
 	Name     string               `json:"name"`
+	Type     string               `json:"type"`
 	Location *LocationRelationDTO `json:"location,omitempty"`
 }
 
@@ -113,6 +114,7 @@ func ToWarehouseRelationDTO(e *entity.Warehouse) *WarehouseRelationDTO {
 	return &WarehouseRelationDTO{
 		Id:       e.Id,
 		Name:     e.Name,
+		Type:     e.Type,
 		Location: ToLocationRelationDTO(e.Location),
 	}
 }

internal/modules/inventory/adjustments/validations/adjustment.validation.go

@@ -16,7 +16,7 @@ type Create struct {
 
 type Query struct {
 	Page               int    `query:"page" validate:"omitempty,min=1"`
-	Limit              int    `query:"limit" validate:"omitempty,min=1,max=100"`
+	Limit              int    `query:"limit" validate:"omitempty,min=1"`
 	ProductID          uint   `query:"product_id" validate:"omitempty,min=0"`
 	WarehouseID        uint   `query:"warehouse_id" validate:"omitempty,min=0"`
 	TransactionType    string `query:"transaction_type" validate:"omitempty,max=100"`

internal/modules/inventory/product-stocks/controllers/product-stock.controller.go

@@ -25,9 +25,10 @@ func NewProductStockController(productStockService service.ProductStockService)
 
 func (u *ProductStockController) GetAll(c *fiber.Ctx) error {
 	query := &validation.Query{
-		Page:   c.QueryInt("page", 1),
-		Limit:  c.QueryInt("limit", 10),
-		Search: c.Query("search", ""),
+		Page:              c.QueryInt("page", 1),
+		Limit:             c.QueryInt("limit", 10),
+		Search:            c.Query("search", ""),
+		ProductCategoryID: uint(c.QueryInt("product_category_id", 0)),
 	}
 
 	if query.Page < 1 || query.Limit < 1 {

internal/modules/inventory/product-stocks/services/product-stock.service.go

@@ -129,6 +129,9 @@ func (s productStockService) GetAll(c *fiber.Ctx, params *validation.Query) ([]e
 		if params.Search != "" {
 			db = db.Where("products.name ILIKE ?", "%"+params.Search+"%")
 		}
+		if params.ProductCategoryID > 0 {
+			db = db.Where("products.product_category_id = ?", params.ProductCategoryID)
+		}
 		return db.Order("products.created_at DESC").Order("products.updated_at DESC")
 	})
 

internal/modules/inventory/product-stocks/validations/product-stock.validation.go

@@ -9,7 +9,8 @@ type Update struct {
 }
 
 type Query struct {
-	Page   int    `query:"page" validate:"omitempty,number,min=1,gt=0"`
-	Limit  int    `query:"limit" validate:"omitempty,number,min=1,max=100,gt=0"`
-	Search string `query:"search" validate:"omitempty,max=50"`
+	Page              int    `query:"page" validate:"omitempty,number,min=1,gt=0"`
+	Limit             int    `query:"limit" validate:"omitempty,number,min=1,gt=0"`
+	Search            string `query:"search" validate:"omitempty,max=50"`
+	ProductCategoryID uint   `query:"product_category_id" validate:"omitempty"`
 }

internal/modules/inventory/product-warehouses/dto/product_warehouse.dto.go

@@ -79,8 +79,12 @@ func ToProductWarehouseListDTO(e entity.ProductWarehouse) ProductWarehouseListDT
 	if e.Product.Id != 0 {
 		product := productDTO.ToProductRelationDTO(e.Product)
 
-		// Create a copy with flock name appended if exists
-		if e.ProjectFlockKandang != nil && e.ProjectFlockKandang.ProjectFlock.Id != 0 {
+		// Append flock name only for KANDANG-type warehouses.
+		// Farm-level (LOKASI) warehouses are shared across flocks — attaching a flock
+		// label there creates duplicates and is misleading.
+		if e.ProjectFlockKandang != nil &&
+			e.ProjectFlockKandang.ProjectFlock.Id != 0 &&
+			e.Warehouse.Type == "KANDANG" {
 			productCopy := product
 			productCopy.Name = product.Name + " (" + e.ProjectFlockKandang.ProjectFlock.FlockName + ")"
 			dto.Product = &productCopy

internal/modules/inventory/product-warehouses/repositories/product_warehouse.repository.go

@@ -7,7 +7,6 @@ import (
 
 	"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 	"gorm.io/gorm"
 )
 
@@ -23,6 +22,7 @@ type ProductWarehouseRepository interface {
 	GetByCategoryCodeAndWarehouseID(ctx context.Context, categoryCode string, warehouseId uint) ([]entity.ProductWarehouse, error)
 	GetLatestByCategoryCodeAndWarehouseID(ctx context.Context, categoryCode string, warehouseId uint, db *gorm.DB) (*entity.ProductWarehouse, error)
 	GetByFlagAndWarehouseID(ctx context.Context, flagName string, warehouseId uint) ([]entity.ProductWarehouse, error)
+	GetByFlagsAndWarehouseID(ctx context.Context, flagNames []string, excludeFlagNames []string, warehouseId uint) ([]entity.ProductWarehouse, error)
 	GetFirstProductByFlag(ctx context.Context, flagName string) (*entity.Product, error)
 	ListProductIDsByFlagPrefixes(ctx context.Context, prefixes []string, visibleStatus *bool) ([]uint, error)
 	ApplyFlagsFilter(db *gorm.DB, flags []string) *gorm.DB
@@ -165,42 +165,16 @@ func (r *ProductWarehouseRepositoryImpl) ApplyFlagsFilter(db *gorm.DB, flags []s
 		return db
 	}
 
-	fallbackCategoryCodes := utils.LegacyProductCategoryCodesForFlags(flags)
-
-	db = db.
-		Joins("JOIN products p_flag ON p_flag.id = product_warehouses.product_id").
-		Joins("LEFT JOIN product_categories pc_flag ON pc_flag.id = p_flag.product_category_id")
-
-	actualFlagFilter := `
-		EXISTS (
-			SELECT 1
-			FROM flags f_flag
-			WHERE f_flag.flagable_id = p_flag.id
-			  AND f_flag.flagable_type = ?
-			  AND f_flag.name IN ?
-		)
-	`
-
-	if len(fallbackCategoryCodes) == 0 {
-		return db.Where(actualFlagFilter, entity.FlagableTypeProduct, flags).Distinct()
-	}
-
 	return db.
-		Where(
-			`(`+actualFlagFilter+`) OR (
-				NOT EXISTS (
-					SELECT 1
-					FROM flags f_any
-					WHERE f_any.flagable_id = p_flag.id
-					  AND f_any.flagable_type = ?
-				)
-				AND pc_flag.code IN ?
-			)`,
-			entity.FlagableTypeProduct,
-			flags,
-			entity.FlagableTypeProduct,
-			fallbackCategoryCodes,
-		).
+		Where(`
+			EXISTS (
+				SELECT 1
+				FROM flags f_flag
+				WHERE f_flag.flagable_id = product_warehouses.product_id
+				  AND f_flag.flagable_type = ?
+				  AND f_flag.name IN ?
+			)
+		`, entity.FlagableTypeProduct, flags).
 		Distinct()
 }
 
@@ -430,6 +404,27 @@ func (r *ProductWarehouseRepositoryImpl) GetByFlagAndWarehouseID(ctx context.Con
 	return productWarehouses, nil
 }
 
+func (r *ProductWarehouseRepositoryImpl) GetByFlagsAndWarehouseID(ctx context.Context, flagNames []string, excludeFlagNames []string, warehouseId uint) ([]entity.ProductWarehouse, error) {
+	var productWarehouses []entity.ProductWarehouse
+	q := r.DB().WithContext(ctx).Model(&entity.ProductWarehouse{}).
+		Joins("JOIN products ON products.id = product_warehouses.product_id").
+		Joins("JOIN flags ON flags.flagable_id = products.id AND flags.flagable_type = 'products'").
+		Where("flags.name IN ? AND product_warehouses.warehouse_id = ?", flagNames, warehouseId)
+	if len(excludeFlagNames) > 0 {
+		q = q.Where("NOT EXISTS (SELECT 1 FROM flags ef WHERE ef.flagable_id = products.id AND ef.flagable_type = 'products' AND ef.name IN ?)", excludeFlagNames)
+	}
+	err := q.Order("product_warehouses.id DESC").
+		Preload("Product").
+		Preload("Product.ProductCategory").
+		Preload("Product.Uom").
+		Preload("Warehouse").
+		Find(&productWarehouses).Error
+	if err != nil {
+		return nil, err
+	}
+	return productWarehouses, nil
+}
+
 func (r *ProductWarehouseRepositoryImpl) GetFirstProductByFlag(ctx context.Context, flagName string) (*entity.Product, error) {
 	var product entity.Product
 	err := r.DB().WithContext(ctx).

internal/modules/inventory/product-warehouses/repositories/product_warehouse.repository_test.go

@@ -117,7 +117,7 @@ func insertProductWarehouseTestFixtures(t *testing.T, db *gorm.DB) {
 	}
 }
 
-func TestApplyFlagsFilterIncludesLegacyCategoryFallback(t *testing.T) {
+func TestApplyFlagsFilterOnlyIncludesFlaggedProducts(t *testing.T) {
 	db := setupProductWarehouseFlagFilterTestDB(t)
 	repo := NewProductWarehouseRepository(db)
 	ctx := context.Background()
@@ -131,12 +131,14 @@ func TestApplyFlagsFilterIncludesLegacyCategoryFallback(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	if len(ids) != 2 || ids[0] != 1 || ids[1] != 2 {
-		t.Fatalf("expected flagged and legacy RAW rows to match, got %v", ids)
+	// Only PW 1 (product 10, flagged PAKAN) should match.
+	// PW 2 (product 20, no flags, RAW category) must not appear — legacy fallback removed.
+	if len(ids) != 1 || ids[0] != 1 {
+		t.Fatalf("expected only flagged row to match, got %v", ids)
 	}
 }
 
-func TestApplyFlagsFilterDoesNotFallbackWhenProductAlreadyHasDifferentFlags(t *testing.T) {
+func TestApplyFlagsFilterExcludesWrongFlaggedProducts(t *testing.T) {
 	db := setupProductWarehouseFlagFilterTestDB(t)
 	repo := NewProductWarehouseRepository(db)
 	ctx := context.Background()
@@ -150,8 +152,9 @@ func TestApplyFlagsFilterDoesNotFallbackWhenProductAlreadyHasDifferentFlags(t *t
 		t.Fatalf("unexpected error: %v", err)
 	}
 
+	// PW 3 belongs to an OVK-flagged product — must not appear when filtering for PAKAN.
 	if len(ids) != 0 {
-		t.Fatalf("expected OVK-flagged product not to match PAKAN fallback, got %v", ids)
+		t.Fatalf("expected OVK-flagged product not to match PAKAN filter, got %v", ids)
 	}
 }
 

internal/modules/inventory/product-warehouses/validations/product_warehouse.validation.go

@@ -14,7 +14,7 @@ type Update struct {
 
 type Query struct {
 	Page            int    `query:"page" validate:"omitempty,number,min=1"`
-	Limit           int    `query:"limit" validate:"omitempty,number,min=1,max=100"`
+	Limit           int    `query:"limit" validate:"omitempty,number,min=1"`
 	Search          string `query:"search" validate:"omitempty"`
 	ProductId       uint   `query:"product_id" validate:"omitempty,number,min=1"`
 	WarehouseId     uint   `query:"warehouse_id" validate:"omitempty,number,min=1"`

internal/modules/inventory/route.go

@@ -10,6 +10,7 @@ import (
 	adjustments "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/adjustments"
 	productStocks "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-stocks"
 	productWarehouses "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses"
+	stockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs"
 	transfers "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/transfers"
 	// MODULE IMPORTS
 )
@@ -23,6 +24,7 @@ func RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Valida
 		adjustments.AdjustmentModule{},
 		transfers.TransferModule{},
 		productStocks.ProductStockModule{},
+		stockLogs.StockLogModule{},
 		// MODULE REGISTRY
 	}
 

internal/modules/inventory/stock-logs/controllers/stock-log.controller.go

@@ -0,0 +1,66 @@
+package controller
+
+import (
+	"math"
+	"strings"
+
+	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/validations"
+	stockLogDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/dto"
+	stockLogService "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/services"
+	"gitlab.com/mbugroup/lti-api.git/internal/response"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+type StockLogController struct {
+	StockLogService stockLogService.StockLogService
+}
+
+func NewStockLogController(s stockLogService.StockLogService) *StockLogController {
+	return &StockLogController{
+		StockLogService: s,
+	}
+}
+
+func (u *StockLogController) GetAll(c *fiber.Ctx) error {
+	query := &validation.Query{
+		Page:               c.QueryInt("page", 1),
+		Limit:              c.QueryInt("limit", 10),
+		ProductWarehouseID: uint(c.QueryInt("product_warehouse_id", 0)),
+	}
+
+	if query.Page < 1 || query.Limit < 1 {
+		return fiber.NewError(fiber.StatusBadRequest, "page and limit must be greater than 0")
+	}
+
+	// Export to Excel
+	if strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel") {
+		if query.ProductWarehouseID == 0 {
+			return fiber.NewError(fiber.StatusBadRequest, "product_warehouse_id is required for export")
+		}
+		results, err := u.StockLogService.GetAllForExport(c, query.ProductWarehouseID)
+		if err != nil {
+			return err
+		}
+		return exportStockLogListExcel(c, results)
+	}
+
+	result, totalResults, err := u.StockLogService.GetAll(c, query)
+	if err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).
+		JSON(response.SuccessWithPaginate[stockLogDTO.StockLogListDTO]{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Get all stock logs successfully",
+			Meta: response.Meta{
+				Page:         query.Page,
+				Limit:        query.Limit,
+				TotalPages:   int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
+				TotalResults: totalResults,
+			},
+			Data: stockLogDTO.ToStockLogListDTOs(result),
+		})
+}

internal/modules/inventory/stock-logs/controllers/stock-log.export.go

@@ -0,0 +1,118 @@
+package controller
+
+import (
+	"fmt"
+	"time"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/xuri/excelize/v2"
+)
+
+func exportStockLogListExcel(c *fiber.Ctx, stockLogs []entity.StockLog) error {
+	file := excelize.NewFile()
+	defer file.Close()
+
+	sheet := "Stock Logs"
+	file.SetSheetName("Sheet1", sheet)
+
+	headers := []string{
+		"ID",
+		"Tanggal",
+		"Gudang",
+		"Stok Akhir",
+		"Peningkatan",
+		"Penurunan",
+		"Jenis Transaksi",
+		"Catatan",
+		"Oleh",
+	}
+
+	// Column widths
+	colWidths := map[string]float64{
+		"A": 8,
+		"B": 20,
+		"C": 25,
+		"D": 14,
+		"E": 14,
+		"F": 14,
+		"G": 20,
+		"H": 30,
+		"I": 20,
+	}
+	for col, width := range colWidths {
+		file.SetColWidth(sheet, col, col, width)
+	}
+
+	// Header style
+	headerStyle, _ := file.NewStyle(&excelize.Style{
+		Font: &excelize.Font{
+			Bold: true,
+			Size: 11,
+		},
+		Fill: excelize.Fill{
+			Type:    "pattern",
+			Pattern: 1,
+			Color:   []string{"D9E1F2"},
+		},
+		Border: []excelize.Border{
+			{Type: "bottom", Style: 1, Color: "000000"},
+		},
+	})
+
+	// Write header row
+	for i, h := range headers {
+		cell, _ := excelize.CoordinatesToCellName(i+1, 1)
+		file.SetCellValue(sheet, cell, h)
+		file.SetCellStyle(sheet, cell, cell, headerStyle)
+	}
+
+	// Freeze header row
+	file.SetPanes(sheet, &excelize.Panes{
+		Freeze:      true,
+		YSplit:      1,
+		TopLeftCell: "A2",
+		ActivePane:  "bottomLeft",
+	})
+
+	// Write data rows
+	for i, log := range stockLogs {
+		row := i + 2
+
+		warehouseName := ""
+		if log.ProductWarehouse != nil {
+			warehouseName = log.ProductWarehouse.Warehouse.Name
+		}
+
+		userName := ""
+		if log.CreatedUser != nil {
+			userName = log.CreatedUser.Name
+		}
+
+		notes := ""
+		if log.Notes != "" {
+			notes = log.Notes
+		}
+
+		file.SetCellInt(sheet, fmt.Sprintf("A%d", row), int(log.Id))
+		file.SetCellValue(sheet, fmt.Sprintf("B%d", row), log.CreatedAt.Format("2006-01-02 15:04:05"))
+		file.SetCellValue(sheet, fmt.Sprintf("C%d", row), warehouseName)
+		file.SetCellFloat(sheet, fmt.Sprintf("D%d", row), log.Stock, 3, 64)
+		file.SetCellFloat(sheet, fmt.Sprintf("E%d", row), log.Increase, 3, 64)
+		file.SetCellFloat(sheet, fmt.Sprintf("F%d", row), log.Decrease, 3, 64)
+		file.SetCellValue(sheet, fmt.Sprintf("G%d", row), log.LoggableType)
+		file.SetCellValue(sheet, fmt.Sprintf("H%d", row), notes)
+		file.SetCellValue(sheet, fmt.Sprintf("I%d", row), userName)
+	}
+
+	buffer, err := file.WriteToBuffer()
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
+	}
+
+	filename := fmt.Sprintf("stock_logs_%s.xlsx", time.Now().Format("20060102_150405"))
+	c.Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+	c.Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, filename))
+	return c.Status(fiber.StatusOK).Send(buffer.Bytes())
+}

internal/modules/inventory/stock-logs/dto/stock-log.dto.go

@@ -0,0 +1,61 @@
+package dto
+
+import (
+	"time"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	userDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/users/dto"
+)
+
+type StockLogListDTO struct {
+	Id                 uint                     `json:"id"`
+	ProductWarehouseId uint                     `json:"product_warehouse_id"`
+	Increase           float64                  `json:"increase"`
+	Decrease           float64                  `json:"decrease"`
+	Stock              float64                  `json:"stock"`
+	LoggableType       string                   `json:"loggable_type"`
+	LoggableId         uint                     `json:"loggable_id"`
+	Notes              *string                  `json:"notes"`
+	CreatedBy          uint                     `json:"created_by"`
+	CreatedUser        *userDTO.UserRelationDTO `json:"created_user,omitempty"`
+	CreatedAt          time.Time                `json:"created_at"`
+}
+
+func ToStockLogListDTO(e entity.StockLog) StockLogListDTO {
+	var notes *string
+	if e.Notes != "" {
+		n := e.Notes
+		notes = &n
+	}
+
+	var createdUser *userDTO.UserRelationDTO
+	if e.CreatedUser != nil && e.CreatedUser.Id != 0 {
+		mapped := userDTO.ToUserRelationDTO(*e.CreatedUser)
+		createdUser = &mapped
+	}
+
+	return StockLogListDTO{
+		Id:                 e.Id,
+		ProductWarehouseId: e.ProductWarehouseId,
+		Increase:           e.Increase,
+		Decrease:           e.Decrease,
+		Stock:              e.Stock,
+		LoggableType:       e.LoggableType,
+		LoggableId:         e.LoggableId,
+		Notes:              notes,
+		CreatedBy:          e.CreatedBy,
+		CreatedUser:        createdUser,
+		CreatedAt:          e.CreatedAt,
+	}
+}
+
+func ToStockLogListDTOs(e []entity.StockLog) []StockLogListDTO {
+	if len(e) == 0 {
+		return []StockLogListDTO{}
+	}
+	result := make([]StockLogListDTO, len(e))
+	for i, log := range e {
+		result[i] = ToStockLogListDTO(log)
+	}
+	return result
+}

internal/modules/inventory/stock-logs/module.go

@@ -0,0 +1,24 @@
+package stockLogs
+
+import (
+	"github.com/go-playground/validator/v10"
+	"github.com/gofiber/fiber/v2"
+	"gorm.io/gorm"
+
+	stockLogService "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/services"
+	stockLogRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
+	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
+	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
+)
+
+type StockLogModule struct{}
+
+func (StockLogModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
+	userRepo := rUser.NewUserRepository(db)
+	userService := sUser.NewUserService(userRepo, validate)
+
+	stockLogRepo := stockLogRepo.NewStockLogRepository(db)
+	service := stockLogService.NewStockLogService(stockLogRepo, validate)
+
+	StockLogRoutes(router, userService, service)
+}

internal/modules/inventory/stock-logs/route.go

@@ -0,0 +1,19 @@
+package stockLogs
+
+import (
+	m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
+	controller "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/controllers"
+	stockLog "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/services"
+	user "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+func StockLogRoutes(v1 fiber.Router, u user.UserService, s stockLog.StockLogService) {
+	ctrl := controller.NewStockLogController(s)
+
+	route := v1.Group("/stock-logs")
+	route.Use(m.Auth(u))
+
+	route.Get("/", m.RequirePermissions(m.P_StockLogGetAll), ctrl.GetAll)
+}

internal/modules/inventory/stock-logs/services/stock-log.service.go

@@ -0,0 +1,125 @@
+package service
+
+import (
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
+	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/validations"
+	stockLogRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+
+	"github.com/go-playground/validator/v10"
+	"github.com/gofiber/fiber/v2"
+	"github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+)
+
+type StockLogService interface {
+	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.StockLog, int64, error)
+	GetAllForExport(ctx *fiber.Ctx, productWarehouseID uint) ([]entity.StockLog, error)
+}
+
+type stockLogService struct {
+	Log              *logrus.Logger
+	Validate         *validator.Validate
+	StockLogRepo     stockLogRepo.StockLogRepository
+}
+
+func NewStockLogService(
+	stockLogRepo stockLogRepo.StockLogRepository,
+	validate *validator.Validate,
+) StockLogService {
+	return &stockLogService{
+		Log:          utils.Log,
+		Validate:     validate,
+		StockLogRepo: stockLogRepo,
+	}
+}
+
+func (s *stockLogService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.StockLog, int64, error) {
+	if err := s.Validate.Struct(params); err != nil {
+		return nil, 0, err
+	}
+
+	locationScope, areaScope, err := m.ResolveLocationAreaScopes(c, s.StockLogRepo.DB())
+	if err != nil {
+		return nil, 0, err
+	}
+
+	offset := (params.Page - 1) * params.Limit
+
+	stockLogs, total, err := s.StockLogRepo.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
+		db = db.Where("product_warehouse_id = ?", params.ProductWarehouseID)
+
+		if locationScope.Restrict || areaScope.Restrict {
+			if (locationScope.Restrict && len(locationScope.IDs) == 0) || (areaScope.Restrict && len(areaScope.IDs) == 0) {
+				return db.Where("1 = 0")
+			}
+			db = db.
+				Joins("JOIN product_warehouses pw ON pw.id = stock_logs.product_warehouse_id").
+				Joins("JOIN warehouses w ON w.id = pw.warehouse_id")
+			if locationScope.Restrict {
+				db = db.Where("w.location_id IN ?", locationScope.IDs)
+			}
+			if areaScope.Restrict {
+				db = db.Where("w.area_id IN ?", areaScope.IDs)
+			}
+		}
+
+		db = db.
+			Preload("CreatedUser").
+			Order("stock_logs.created_at DESC")
+
+		return db
+	})
+	if err != nil {
+		s.Log.Errorf("Failed to get stock logs: %+v", err)
+		return nil, 0, err
+	}
+
+	if total == 0 {
+		return []entity.StockLog{}, 0, nil
+	}
+
+	return stockLogs, total, nil
+}
+
+func (s *stockLogService) GetAllForExport(c *fiber.Ctx, productWarehouseID uint) ([]entity.StockLog, error) {
+	locationScope, areaScope, err := m.ResolveLocationAreaScopes(c, s.StockLogRepo.DB())
+	if err != nil {
+		return nil, err
+	}
+
+	stockLogs, _, err := s.StockLogRepo.GetAll(c.Context(), 0, -1, func(db *gorm.DB) *gorm.DB {
+		db = db.Where("product_warehouse_id = ?", productWarehouseID)
+
+		if locationScope.Restrict || areaScope.Restrict {
+			if (locationScope.Restrict && len(locationScope.IDs) == 0) || (areaScope.Restrict && len(areaScope.IDs) == 0) {
+				return db.Where("1 = 0")
+			}
+			db = db.
+				Joins("JOIN product_warehouses pw ON pw.id = stock_logs.product_warehouse_id").
+				Joins("JOIN warehouses w ON w.id = pw.warehouse_id")
+			if locationScope.Restrict {
+				db = db.Where("w.location_id IN ?", locationScope.IDs)
+			}
+			if areaScope.Restrict {
+				db = db.Where("w.area_id IN ?", areaScope.IDs)
+			}
+		}
+
+		db = db.
+			Preload("CreatedUser").
+			Preload("ProductWarehouse").
+			Preload("ProductWarehouse.Warehouse").
+			Order("stock_logs.created_at ASC")
+
+		return db
+	})
+	if err != nil {
+		s.Log.Errorf("Failed to get stock logs for export: %+v", err)
+		return nil, err
+	}
+
+	return stockLogs, nil
+}
+

internal/modules/inventory/stock-logs/validations/stock-log.validation.go

@@ -0,0 +1,7 @@
+package validation
+
+type Query struct {
+	Page                int    `query:"page" validate:"omitempty,number,min=1,gt=0"`
+	Limit               int    `query:"limit" validate:"omitempty,number,min=1,gt=0"`
+	ProductWarehouseID  uint   `query:"product_warehouse_id" validate:"required,gt=0"`
+}

internal/modules/inventory/transfers/controllers/transfer.controller.go

@@ -25,9 +25,11 @@ func NewTransferController(transferService service.TransferService) *TransferCon
 
 func (u *TransferController) GetAll(c *fiber.Ctx) error {
 	query := &validation.Query{
-		Page:   c.QueryInt("page", 1),
-		Limit:  c.QueryInt("limit", 10),
-		Search: c.Query("search", ""),
+		Page:        c.QueryInt("page", 1),
+		Limit:       c.QueryInt("limit", 10),
+		Search:      c.Query("search", ""),
+		ProductID:   uint(c.QueryInt("product_id", 0)),
+		WarehouseID: uint(c.QueryInt("warehouse_id", 0)),
 	}
 
 	result, totalResults, err := u.TransferService.GetAll(c, query)

internal/modules/inventory/transfers/services/transfer.service.go

@@ -157,6 +157,12 @@ func (s transferService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entit
 				Where("movement_number ILIKE ? OR from_warehouses.name ILIKE ? OR to_warehouses.name ILIKE ?",
 					searchTerm, searchTerm, searchTerm)
 		}
+		if params.ProductID > 0 {
+			db = db.Joins("JOIN stock_transfer_details AS filter_std ON filter_std.stock_transfer_id = stock_transfers.id AND filter_std.deleted_at IS NULL AND filter_std.product_id = ?", params.ProductID)
+		}
+		if params.WarehouseID > 0 {
+			db = db.Where("stock_transfers.from_warehouse_id = ? OR stock_transfers.to_warehouse_id = ?", params.WarehouseID, params.WarehouseID)
+		}
 		return db.Order("created_at DESC").Order("updated_at DESC")
 	})
 

internal/modules/inventory/transfers/validations/transfer.validation.go

@@ -5,9 +5,11 @@ type Create struct {
 }
 
 type Query struct {
-	Page   int    `query:"page" validate:"omitempty,number,min=1"`
-	Limit  int    `query:"limit" validate:"omitempty,number,min=1,max=100"`
-	Search string `query:"search" validate:"omitempty,max=50"`
+	Page        int    `query:"page" validate:"omitempty,number,min=1"`
+	Limit       int    `query:"limit" validate:"omitempty,number,min=1"`
+	Search      string `query:"search" validate:"omitempty,max=50"`
+	ProductID   uint   `query:"product_id" validate:"omitempty"`
+	WarehouseID uint   `query:"warehouse_id" validate:"omitempty"`
 }
 
 type TransferProduct struct {

internal/modules/marketing/controllers/deliveryorder.controller.go

@@ -56,6 +56,12 @@ func (u *DeliveryOrdersController) GetAll(c *fiber.Ctx) error {
 		return fiber.NewError(fiber.StatusBadRequest, "Invalid product_ids")
 	}
 
+	sortBy := strings.TrimSpace(c.Query("sort_by", ""))
+	sortOrder := strings.TrimSpace(c.Query("sort_order", ""))
+	if sortOrder == "" {
+		sortOrder = "asc"
+	}
+
 	query := &validation.DeliveryOrderQuery{
 		Page:                  c.QueryInt("page", 1),
 		Limit:                 c.QueryInt("limit", 10),
@@ -66,6 +72,8 @@ func (u *DeliveryOrdersController) GetAll(c *fiber.Ctx) error {
 		MarketingId:           uint(c.QueryInt("marketing_id", 0)),
 		ProjectFlockID:        uint(c.QueryInt("project_flock_id", 0)),
 		ProjectFlockKandangID: uint(c.QueryInt("project_flock_kandang_id", 0)),
+		SortBy:                sortBy,
+		SortOrder:             sortOrder,
 	}
 
 	if isAllExcelExportRequest(c) {

internal/modules/marketing/services/deliveryorder.service.go

@@ -292,7 +292,29 @@ func (s deliveryOrdersService) GetAll(c *fiber.Ctx, params *validation.DeliveryO
 		if params.MarketingId != 0 {
 			return db.Where("id = ?", params.MarketingId)
 		}
-		return db.Order("created_at DESC").Order("updated_at DESC")
+
+		orderDir := "DESC"
+		if params.SortOrder != "" {
+			orderDir = strings.ToUpper(params.SortOrder)
+		}
+
+		switch strings.TrimSpace(params.SortBy) {
+		case "so_number":
+			return db.Order("marketings.so_number " + orderDir)
+		case "so_date":
+			return db.Order("marketings.so_date " + orderDir)
+		case "status":
+			statusSQL := "(SELECT step_name FROM approvals WHERE approvable_type = '" + utils.ApprovalWorkflowMarketing.String() + "' AND approvable_id = marketings.id ORDER BY action_at DESC, id DESC LIMIT 1) " + orderDir
+			return db.Order(statusSQL)
+		case "customer":
+			return db.Joins("LEFT JOIN customers ON customers.id = marketings.customer_id").Order("COALESCE(customers.name, '') " + orderDir)
+		case "grand_total":
+			return db.Order("(SELECT COALESCE(SUM(mp.total_price), 0) FROM marketing_products mp WHERE mp.marketing_id = marketings.id) " + orderDir)
+		case "created_at":
+			return db.Order("marketings.created_at " + orderDir)
+		default:
+			return db.Order("created_at DESC").Order("updated_at DESC")
+		}
 	})
 	if err != nil {
 		return nil, 0, err

internal/modules/marketing/services/salesorder.service.go

@@ -770,15 +770,21 @@ func (s salesOrdersService) Approval(c *fiber.Ctx, req *validation.Approve) ([]e
 
 func (s *salesOrdersService) createMarketingProductWithDelivery(ctx context.Context, marketingId uint, marketingType string, rp validation.CreateMarketingProduct, marketingProductRepo repository.MarketingProductRepository, invDeliveryRepo repository.MarketingDeliveryProductRepository) error {
 
-	totalWeight, totalPrice := s.calculatePriceByMarketingType(
-		marketingType,
-		rp.Qty,
-		rp.AvgWeight,
-		rp.UnitPrice,
-		rp.Week,
-		rp.ConvertionUnit,
-		rp.WeightPerConvertion,
-	)
+	var totalWeight, totalPrice float64
+	if rp.TotalPrice != nil {
+		totalWeight = math.Round(rp.Qty*rp.AvgWeight*100) / 100
+		totalPrice = *rp.TotalPrice
+	} else {
+		totalWeight, totalPrice = s.calculatePriceByMarketingType(
+			marketingType,
+			rp.Qty,
+			rp.AvgWeight,
+			rp.UnitPrice,
+			rp.Week,
+			rp.ConvertionUnit,
+			rp.WeightPerConvertion,
+		)
+	}
 
 	marketingProduct := &entity.MarketingProduct{
 		MarketingId:         marketingId,
@@ -821,7 +827,7 @@ func (s *salesOrdersService) calculatePriceByMarketingType(marketingType string,
 		totalPrice = math.Round(qty*unitPrice*100) / 100
 	} else if marketingType == string(utils.MarketingTypeAyamPullet) && week != nil && *week > 0 {
 		totalWeight = math.Round(qty*avgWeight*100) / 100
-		totalPrice = math.Round(unitPrice*float64(*week)*qty*100) / 100
+		totalPrice = math.Round(totalWeight*unitPrice*100) / 100
 	} else {
 		totalWeight = math.Round(qty*avgWeight*100) / 100
 

internal/modules/marketing/validations/deliveryorder.validation.go

@@ -23,7 +23,7 @@ type DeliveryOrderUpdate struct {
 
 type DeliveryOrderQuery struct {
 	Page                  int    `query:"page" validate:"omitempty,number,min=1,gt=0"`
-	Limit                 int    `query:"limit" validate:"omitempty,number,min=1,max=100,gt=0"`
+	Limit                 int    `query:"limit" validate:"omitempty,number,min=1,gt=0"`
 	Search                string `query:"search" validate:"omitempty,max=100"`
 	ProductIDs            []uint `query:"product_ids" validate:"omitempty,dive,gt=0"`
 	Status                string `query:"status" validate:"omitempty,max=50"`
@@ -31,6 +31,8 @@ type DeliveryOrderQuery struct {
 	MarketingId           uint   `query:"marketing_id" validate:"omitempty,gt=0"`
 	ProjectFlockID        uint   `query:"project_flock_id" validate:"omitempty,gt=0"`
 	ProjectFlockKandangID uint   `query:"project_flock_kandang_id" validate:"omitempty,gt=0"`
+	SortBy                string `query:"sort_by" validate:"omitempty,oneof=so_number so_date status customer grand_total created_at"`
+	SortOrder             string `query:"sort_order" validate:"omitempty,oneof=asc desc"`
 }
 
 type DeliveryOrderApprove struct {

internal/modules/marketing/validations/salesorder.validation.go

@@ -26,6 +26,7 @@ type CreateMarketingProduct struct {
 	UnitPrice           float64  `json:"unit_price" validate:"required,gt=0"`
 	Qty                 float64  `json:"qty" validate:"required,gt=0"`
 	AvgWeight           float64  `json:"avg_weight" validate:"omitempty,gt=0"`
+	TotalPrice          *float64 `json:"total_price" validate:"omitempty,gt=0"`
 }
 
 type Update struct {

internal/modules/master/areas/validations/area.validation.go

@@ -10,6 +10,6 @@ type Update struct {
 
 type Query struct {
 	Page   int    `query:"page" validate:"omitempty,number,min=1"`
-	Limit  int    `query:"limit" validate:"omitempty,number,min=1,max=100"`
+	Limit  int    `query:"limit" validate:"omitempty,number,min=1"`
 	Search string `query:"search" validate:"omitempty,max=50"`
 }

internal/modules/master/banks/validations/bank.validation.go

@@ -16,6 +16,6 @@ type Update struct {
 
 type Query struct {
 	Page   int    `query:"page" validate:"omitempty,number,min=1"`
-	Limit  int    `query:"limit" validate:"omitempty,number,min=1,max=100"`
+	Limit  int    `query:"limit" validate:"omitempty,number,min=1"`
 	Search string `query:"search" validate:"omitempty,max=50"`
 }

internal/modules/master/config-checklists/validations/config-checklist.validation.go

@@ -14,6 +14,6 @@ type Update struct {
 
 type Query struct {
 	Page   int    `query:"page" validate:"omitempty,number,min=1,gt=0"`
-	Limit  int    `query:"limit" validate:"omitempty,number,min=1,max=100,gt=0"`
+	Limit  int    `query:"limit" validate:"omitempty,number,min=1,gt=0"`
 	Search string `query:"search" validate:"omitempty,max=50"`
 }

internal/modules/master/customers/dto/customer.dto.go

@@ -14,6 +14,7 @@ type CustomerRelationDTO struct {
 	Name          string                   `json:"name"`
 	Type          string                   `json:"type"`
 	AccountNumber string                   `json:"account_number"`
+	BankName      string                   `json:"bank_name"`
 	Address       string                   `json:"address,omitempty"`
 	Balance       float64                  `json:"balance"`
 	Pic           *userDTO.UserRelationDTO `json:"pic,omitempty"`
@@ -28,6 +29,7 @@ type CustomerListDTO struct {
 	Phone         string                  `json:"phone"`
 	Email         string                  `json:"email"`
 	AccountNumber string                  `json:"account_number"`
+	BankName      string                  `json:"bank_name"`
 	Balance       float64                 `json:"balance"`
 	Pic           userDTO.UserRelationDTO `json:"pic"`
 	CreatedUser   userDTO.UserRelationDTO `json:"created_user"`
@@ -53,6 +55,7 @@ func ToCustomerRelationDTO(e entity.Customer) CustomerRelationDTO {
 		Name:          e.Name,
 		Type:          e.Type,
 		AccountNumber: e.AccountNumber,
+		BankName:      e.BankName,
 		Address:       e.Address,
 		Balance:       e.Balance,
 		Pic:           pic,
@@ -81,6 +84,7 @@ func ToCustomerListDTO(e entity.Customer) CustomerListDTO {
 		Phone:         e.Phone,
 		Email:         e.Email,
 		AccountNumber: e.AccountNumber,
+		BankName:      e.BankName,
 		Pic:           pic,
 		CreatedAt:     e.CreatedAt,
 		UpdatedAt:     e.UpdatedAt,