add command to fix reconcile fifo; fix fifo stock v2

Rc/01

See merge request mbugroup/lti-api!578

cmd/cleanup-released-stock-allocations/main.go

@@ -0,0 +1,304 @@
+// Command cleanup-released-stock-allocations menghapus baris stock_allocations
+// dengan status='RELEASED' yang sudah lewat masa retensi.
+//
+// Baris RELEASED muncul dari operasi Rollback / Reflow FIFO v2. Closing reports
+// dan flow bisnis hanya membaca status='ACTIVE', sehingga RELEASED rows aman
+// dihapus setelah masa retensi tertentu (default 90 hari).
+//
+// Cara pakai:
+//
+//	go run ./cmd/cleanup-released-stock-allocations/                          # dry-run
+//	go run ./cmd/cleanup-released-stock-allocations/ -apply                   # apply (90 hari)
+//	go run ./cmd/cleanup-released-stock-allocations/ -apply -retention-days=30
+//	go run ./cmd/cleanup-released-stock-allocations/ -apply -batch-size=5000
+//	go run ./cmd/cleanup-released-stock-allocations/ -apply -skip-vacuum
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+	"time"
+
+	"gitlab.com/mbugroup/lti-api.git/internal/config"
+	"gitlab.com/mbugroup/lti-api.git/internal/database"
+	"gitlab.com/mbugroup/lti-api.git/internal/entities"
+	"gorm.io/gorm"
+)
+
+const (
+	outputTable = "table"
+	outputJSON  = "json"
+)
+
+type options struct {
+	Apply          bool
+	Output         string
+	DBSSLMode      string
+	RetentionDays  int
+	BatchSize      int
+	SkipVacuum     bool
+}
+
+type sizeStat struct {
+	TableSize string `json:"table_size" gorm:"column:table_size"`
+	TotalSize string `json:"total_size" gorm:"column:total_size"`
+	RowCount  int64  `json:"row_count"  gorm:"column:row_count"`
+}
+
+type runSummary struct {
+	Mode             string   `json:"mode"`
+	RetentionDays    int      `json:"retention_days"`
+	CutoffTime       string   `json:"cutoff_time"`
+	BatchSize        int      `json:"batch_size"`
+	CandidateRows    int64    `json:"candidate_rows"`
+	DeletedRows      int64    `json:"deleted_rows,omitempty"`
+	BatchesExecuted  int      `json:"batches_executed,omitempty"`
+	BeforeSize       sizeStat `json:"before_size"`
+	AfterSize        sizeStat `json:"after_size,omitempty"`
+	DurationSeconds  float64  `json:"duration_seconds"`
+	VacuumExecuted   bool     `json:"vacuum_executed"`
+	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)
+
+	start := time.Now()
+	cutoff := time.Now().Add(-time.Duration(opts.RetentionDays) * 24 * time.Hour)
+
+	summary := runSummary{
+		RetentionDays: opts.RetentionDays,
+		CutoffTime:    cutoff.UTC().Format(time.RFC3339),
+		BatchSize:     opts.BatchSize,
+		OverallStatus: "PASS",
+	}
+
+	// Ambil ukuran tabel sebelum cleanup
+	before, err := fetchSizeStat(ctx, db)
+	if err != nil {
+		log.Fatalf("failed to fetch initial size: %v", err)
+	}
+	summary.BeforeSize = before
+
+	// Hitung kandidat row
+	candidate, err := countCandidates(ctx, db, cutoff)
+	if err != nil {
+		log.Fatalf("failed to count candidates: %v", err)
+	}
+	summary.CandidateRows = candidate
+
+	if candidate == 0 {
+		summary.Mode = modeLabel(opts.Apply)
+		summary.DurationSeconds = time.Since(start).Seconds()
+		fmt.Printf("No RELEASED rows older than %d days found. Nothing to do.\n", opts.RetentionDays)
+		render(opts.Output, summary)
+		return
+	}
+
+	if !opts.Apply {
+		summary.Mode = "DRY_RUN"
+		summary.DurationSeconds = time.Since(start).Seconds()
+		render(opts.Output, summary)
+		fmt.Println()
+		fmt.Println("Re-run with -apply to actually delete the rows above.")
+		return
+	}
+
+	summary.Mode = "APPLY"
+
+	deleted, batches, err := applyCleanup(ctx, db, cutoff, opts.BatchSize)
+	summary.DeletedRows = deleted
+	summary.BatchesExecuted = batches
+	if err != nil {
+		summary.OverallStatus = "FAIL"
+		render(opts.Output, summary)
+		log.Fatalf("apply failed after %d batches (%d rows deleted): %v", batches, deleted, err)
+	}
+
+	// VACUUM ANALYZE supaya space benar-benar dibebaskan ke OS
+	if !opts.SkipVacuum {
+		if err := runVacuum(ctx, db); err != nil {
+			// VACUUM gagal jangan-mengaborkan, log saja
+			log.Printf("WARN: VACUUM ANALYZE gagal: %v", err)
+		} else {
+			summary.VacuumExecuted = true
+		}
+	}
+
+	after, err := fetchSizeStat(ctx, db)
+	if err != nil {
+		log.Printf("WARN: gagal ambil ukuran tabel setelah cleanup: %v", err)
+	} else {
+		summary.AfterSize = after
+	}
+
+	summary.DurationSeconds = time.Since(start).Seconds()
+	render(opts.Output, summary)
+}
+
+func parseFlags() (*options, error) {
+	var opts options
+	flag.BoolVar(&opts.Apply, "apply", false, "Apply deletion (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.IntVar(&opts.RetentionDays, "retention-days", 90, "Keep RELEASED rows newer than N days")
+	flag.IntVar(&opts.BatchSize, "batch-size", 10000, "Rows deleted per transaction")
+	flag.BoolVar(&opts.SkipVacuum, "skip-vacuum", false, "Skip VACUUM ANALYZE after cleanup")
+	flag.Parse()
+
+	opts.Output = strings.ToLower(strings.TrimSpace(opts.Output))
+	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)
+	}
+	if opts.RetentionDays < 0 {
+		return nil, fmt.Errorf("retention-days must be >= 0, got %d", opts.RetentionDays)
+	}
+	if opts.BatchSize <= 0 {
+		return nil, fmt.Errorf("batch-size must be > 0, got %d", opts.BatchSize)
+	}
+
+	return &opts, nil
+}
+
+func countCandidates(ctx context.Context, db *gorm.DB, cutoff time.Time) (int64, error) {
+	var count int64
+	err := db.WithContext(ctx).
+		Table("stock_allocations").
+		Where("status = ?", entities.StockAllocationStatusReleased).
+		Where("released_at IS NOT NULL AND released_at < ?", cutoff).
+		Count(&count).Error
+	return count, err
+}
+
+func applyCleanup(ctx context.Context, db *gorm.DB, cutoff time.Time, batchSize int) (int64, int, error) {
+	var totalDeleted int64
+	batches := 0
+
+	for {
+		var affected int64
+		err := db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+			// Pakai CTE supaya LIMIT bisa dipakai bersama DELETE di PostgreSQL.
+			// `released_at IS NOT NULL` defensif — rows lama dari migrasi mungkin
+			// NULL meski status=RELEASED.
+			res := tx.Exec(`
+DELETE FROM stock_allocations
+WHERE id IN (
+    SELECT id FROM stock_allocations
+    WHERE status = ?
+      AND released_at IS NOT NULL
+      AND released_at < ?
+    ORDER BY id ASC
+    LIMIT ?
+)
+`, entities.StockAllocationStatusReleased, cutoff, batchSize)
+			if res.Error != nil {
+				return res.Error
+			}
+			affected = res.RowsAffected
+			return nil
+		})
+		if err != nil {
+			return totalDeleted, batches, err
+		}
+
+		if affected == 0 {
+			break
+		}
+
+		totalDeleted += affected
+		batches++
+		log.Printf("batch %d: deleted %d rows (running total: %d)", batches, affected, totalDeleted)
+
+		if affected < int64(batchSize) {
+			break
+		}
+	}
+
+	return totalDeleted, batches, nil
+}
+
+func runVacuum(ctx context.Context, db *gorm.DB) error {
+	// VACUUM tidak bisa di-jalankan dalam transaksi.
+	// gorm SkipDefaultTransaction sudah true, tapi tetap aman menggunakan raw DB.
+	sqlDB, err := db.DB()
+	if err != nil {
+		return err
+	}
+	_, err = sqlDB.ExecContext(ctx, "VACUUM ANALYZE stock_allocations")
+	return err
+}
+
+func fetchSizeStat(ctx context.Context, db *gorm.DB) (sizeStat, error) {
+	var stat sizeStat
+	err := db.WithContext(ctx).Raw(`
+SELECT
+    pg_size_pretty(pg_relation_size('stock_allocations')) AS table_size,
+    pg_size_pretty(pg_total_relation_size('stock_allocations')) AS total_size,
+    (SELECT COUNT(*) FROM stock_allocations)::bigint AS row_count
+`).Scan(&stat).Error
+	return stat, err
+}
+
+func modeLabel(apply bool) string {
+	if apply {
+		return "APPLY"
+	}
+	return "DRY_RUN"
+}
+
+func render(mode string, summary runSummary) {
+	if mode == outputJSON {
+		enc := json.NewEncoder(os.Stdout)
+		enc.SetIndent("", "  ")
+		_ = enc.Encode(summary)
+		return
+	}
+
+	fmt.Printf("=== Cleanup RELEASED stock_allocations ===\n")
+	fmt.Printf("Mode               : %s\n", summary.Mode)
+	fmt.Printf("Retention days     : %d (cutoff < %s)\n", summary.RetentionDays, summary.CutoffTime)
+	fmt.Printf("Batch size         : %d\n", summary.BatchSize)
+	fmt.Printf("Candidate rows     : %d\n", summary.CandidateRows)
+
+	fmt.Printf("\n--- Before ---\n")
+	fmt.Printf("Total rows         : %d\n", summary.BeforeSize.RowCount)
+	fmt.Printf("Table size         : %s\n", summary.BeforeSize.TableSize)
+	fmt.Printf("Total size (idx)   : %s\n", summary.BeforeSize.TotalSize)
+
+	if summary.Mode == "APPLY" {
+		fmt.Printf("\n--- Apply ---\n")
+		fmt.Printf("Deleted rows       : %d\n", summary.DeletedRows)
+		fmt.Printf("Batches executed   : %d\n", summary.BatchesExecuted)
+		fmt.Printf("VACUUM executed    : %v\n", summary.VacuumExecuted)
+
+		if summary.AfterSize.RowCount > 0 || summary.AfterSize.TableSize != "" {
+			fmt.Printf("\n--- After ---\n")
+			fmt.Printf("Total rows         : %d\n", summary.AfterSize.RowCount)
+			fmt.Printf("Table size         : %s\n", summary.AfterSize.TableSize)
+			fmt.Printf("Total size (idx)   : %s\n", summary.AfterSize.TotalSize)
+		}
+	}
+
+	fmt.Printf("\nDuration           : %.2fs\n", summary.DurationSeconds)
+	fmt.Printf("Overall status     : %s\n", summary.OverallStatus)
+}

cmd/reconcile-fifo-total-used/main.go

@@ -0,0 +1,484 @@
+// Command reconcile-fifo-total-used memperbaiki "phantom total_used" pada
+// stockable lot FIFO v2 (recording_eggs, stock_transfer_details, dst.).
+//
+// LATAR BELAKANG
+// Sebelum fix di population_allocation.go, ReleaseByUsable melepas SEMUA alokasi
+// CONSUME sebuah usable (termasuk RECORDING_EGG / STOCK_TRANSFER_IN) tanpa
+// men-decrement total_used stockable-nya. Akibatnya total_used "nyangkut" lebih
+// besar dari jumlah alokasi ACTIVE yang membackup-nya (phantom) → available
+// dihitung 0 padahal stok fisik ada → Delivery Order telur nyangkut di pending.
+//
+// PERBAIKAN
+// Sumber kebenaran konsumsi = stock_allocations status ACTIVE & purpose CONSUME.
+// Command ini menyetel ulang total_used setiap lot = SUM(alokasi ACTIVE CONSUME
+// untuk lot itu), lalu menjalankan FIFO v2 Reflow per (PW, flag group) sehingga
+// pending dialokasi ulang ke stok yang kini available dan product_warehouses.qty
+// dihitung ulang.
+//
+// PENTING: jalankan command ini SETELAH fix kode (population_allocation.go)
+// ter-deploy, dan SEBELUM mengaktifkan blok over-sell telur.
+//
+// Cara pakai:
+//
+//	go run ./cmd/reconcile-fifo-total-used/ -pw=1292                 # dry-run 1 PW
+//	go run ./cmd/reconcile-fifo-total-used/ -pw=1292 -apply          # apply 1 PW
+//	go run ./cmd/reconcile-fifo-total-used/ -pw=1292,1296,1268 -apply
+//	go run ./cmd/reconcile-fifo-total-used/ -pw=1292 -apply -output=json
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	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"
+
+	"github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+	gormlogger "gorm.io/gorm/logger"
+)
+
+const (
+	outputTable = "table"
+	outputJSON  = "json"
+)
+
+var identifierRe = regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_]*$`)
+
+type options struct {
+	Apply     bool
+	Output    string
+	DBSSLMode string
+	PWs       []uint
+}
+
+// stockableRule menggambarkan satu jenis stockable (mis. RECORDING_EGG) beserta
+// tabel & kolom yang dipakai FIFO v2 untuk melacak stok masuk.
+type stockableRule struct {
+	LegacyTypeKey       string
+	SourceTable         string
+	SourceIDColumn      string
+	UsedQuantityCol     string
+	ProductWarehouseCol string
+	QuantityCol         string
+	ScopeSQL            string
+}
+
+type pwResult struct {
+	ProductWarehouseID uint     `json:"product_warehouse_id"`
+	Product            string   `json:"product"`
+	Warehouse          string   `json:"warehouse"`
+	FlagGroups         []string `json:"flag_groups"`
+
+	QtyBefore       float64 `json:"qty_before"`
+	TotalUsedBefore float64 `json:"total_used_before"`
+	ActiveConsume   float64 `json:"active_consume"`
+	Phantom         float64 `json:"phantom"`
+	PendingBefore   float64 `json:"pending_before"`
+
+	QtyAfter     float64 `json:"qty_after,omitempty"`
+	PendingAfter float64 `json:"pending_after,omitempty"`
+
+	Status string `json:"status"`
+	Error  string `json:"error,omitempty"`
+}
+
+type runSummary struct {
+	Mode            string     `json:"mode"`
+	TargetPWs       []uint     `json:"target_pws"`
+	Results         []pwResult `json:"results"`
+	DurationSeconds float64    `json:"duration_seconds"`
+	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)
+	// Quiet the per-query GORM logging; this command emits its own summary and
+	// the reflow step would otherwise produce a very noisy query log.
+	db = db.Session(&gorm.Session{Logger: gormlogger.Default.LogMode(gormlogger.Silent)})
+
+	logger := logrus.New()
+	logger.SetLevel(logrus.WarnLevel)
+	svc := commonSvc.NewFifoStockV2Service(db, logger)
+
+	start := time.Now()
+
+	stockableRules, err := loadStockableRules(ctx, db)
+	if err != nil {
+		log.Fatalf("failed to load stockable route rules: %v", err)
+	}
+	pendingRules, err := loadUsablePendingRules(ctx, db)
+	if err != nil {
+		log.Fatalf("failed to load usable route rules: %v", err)
+	}
+
+	summary := runSummary{
+		Mode:          modeLabel(opts.Apply),
+		TargetPWs:     opts.PWs,
+		OverallStatus: "PASS",
+	}
+
+	for _, pw := range opts.PWs {
+		res := reconcilePW(ctx, db, svc, pw, stockableRules, pendingRules, opts.Apply)
+		if res.Status == "FAIL" {
+			summary.OverallStatus = "FAIL"
+		}
+		summary.Results = append(summary.Results, res)
+	}
+
+	summary.DurationSeconds = time.Since(start).Seconds()
+	render(opts.Output, summary)
+
+	if !opts.Apply {
+		fmt.Println("\nDry-run only. Re-run with -apply to reset total_used and reflow the PW(s) above.")
+	}
+	if summary.OverallStatus == "FAIL" {
+		os.Exit(1)
+	}
+}
+
+// reconcilePW mengukur kondisi PW, lalu (jika -apply) menyetel ulang total_used
+// tiap lot dan menjalankan reflow, semuanya dalam satu transaksi.
+func reconcilePW(
+	ctx context.Context,
+	db *gorm.DB,
+	svc commonSvc.FifoStockV2Service,
+	pw uint,
+	stockableRules []stockableRule,
+	pendingRules []stockableRule,
+	apply bool,
+) pwResult {
+	res := pwResult{ProductWarehouseID: pw, Status: "OK"}
+
+	if name, wh, err := loadPWIdentity(ctx, db, pw); err != nil {
+		res.Status = "FAIL"
+		res.Error = fmt.Sprintf("load identity: %v", err)
+		return res
+	} else {
+		res.Product, res.Warehouse = name, wh
+	}
+
+	flagGroups, err := loadFlagGroups(ctx, db, pw)
+	if err != nil {
+		res.Status = "FAIL"
+		res.Error = fmt.Sprintf("load flag groups: %v", err)
+		return res
+	}
+	res.FlagGroups = flagGroups
+
+	res.QtyBefore, _ = loadQty(ctx, db, pw)
+	res.TotalUsedBefore, _ = sumStockableUsed(ctx, db, pw, stockableRules)
+	res.ActiveConsume, _ = loadActiveConsume(ctx, db, pw)
+	res.PendingBefore, _ = sumPending(ctx, db, pw, pendingRules)
+	res.Phantom = res.TotalUsedBefore - res.ActiveConsume
+
+	if !apply {
+		return res
+	}
+
+	err = db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		for _, rule := range stockableRules {
+			if err := recomputeUsed(ctx, tx, rule, pw); err != nil {
+				return fmt.Errorf("recompute %s: %w", rule.LegacyTypeKey, err)
+			}
+		}
+		for _, fg := range flagGroups {
+			if _, err := svc.Reflow(ctx, commonSvc.FifoStockV2ReflowRequest{
+				FlagGroupCode:      fg,
+				ProductWarehouseID: pw,
+				Tx:                 tx,
+			}); err != nil {
+				return fmt.Errorf("reflow flag_group=%s: %w", fg, err)
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		res.Status = "FAIL"
+		res.Error = err.Error()
+		return res
+	}
+
+	res.QtyAfter, _ = loadQty(ctx, db, pw)
+	res.PendingAfter, _ = sumPending(ctx, db, pw, pendingRules)
+	return res
+}
+
+func recomputeUsed(ctx context.Context, tx *gorm.DB, rule stockableRule, pw uint) error {
+	q := fmt.Sprintf(`
+UPDATE %s t
+SET %s = COALESCE((
+    SELECT SUM(sa.qty) FROM stock_allocations sa
+    WHERE sa.stockable_type = ?
+      AND sa.stockable_id = t.%s
+      AND sa.status = 'ACTIVE'
+      AND sa.allocation_purpose = 'CONSUME'
+), 0)
+WHERE t.%s = ?`, rule.SourceTable, rule.UsedQuantityCol, rule.SourceIDColumn, rule.ProductWarehouseCol)
+	if strings.TrimSpace(rule.ScopeSQL) != "" {
+		q += " AND (" + rule.ScopeSQL + ")"
+	}
+	return tx.WithContext(ctx).Exec(q, rule.LegacyTypeKey, pw).Error
+}
+
+// ---- loaders ----
+
+func loadStockableRules(ctx context.Context, db *gorm.DB) ([]stockableRule, error) {
+	type row struct {
+		LegacyTypeKey       string `gorm:"column:legacy_type_key"`
+		SourceTable         string `gorm:"column:source_table"`
+		SourceIDColumn      string `gorm:"column:source_id_column"`
+		UsedQuantityCol     string `gorm:"column:used_quantity_col"`
+		ProductWarehouseCol string `gorm:"column:product_warehouse_col"`
+		QuantityCol         string `gorm:"column:quantity_col"`
+		ScopeSQL            string `gorm:"column:scope_sql"`
+	}
+	var rows []row
+	err := db.WithContext(ctx).
+		Table("fifo_stock_v2_route_rules").
+		Select("DISTINCT legacy_type_key, source_table, source_id_column, COALESCE(used_quantity_col,'') AS used_quantity_col, product_warehouse_col, COALESCE(quantity_col,'') AS quantity_col, COALESCE(scope_sql,'') AS scope_sql").
+		Where("lane = ? AND is_active = TRUE", "STOCKABLE").
+		Where("used_quantity_col IS NOT NULL AND used_quantity_col <> ''").
+		Scan(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+
+	out := make([]stockableRule, 0, len(rows))
+	seen := map[string]bool{}
+	for _, r := range rows {
+		if !validIdentifiers(r.SourceTable, r.SourceIDColumn, r.UsedQuantityCol, r.ProductWarehouseCol) {
+			return nil, fmt.Errorf("unsafe identifier in route rule %s (table=%s used=%s pw=%s)", r.LegacyTypeKey, r.SourceTable, r.UsedQuantityCol, r.ProductWarehouseCol)
+		}
+		key := r.LegacyTypeKey + "|" + r.SourceTable + "|" + r.UsedQuantityCol + "|" + r.ProductWarehouseCol
+		if seen[key] {
+			continue
+		}
+		seen[key] = true
+		out = append(out, stockableRule(r))
+	}
+	return out, nil
+}
+
+func loadUsablePendingRules(ctx context.Context, db *gorm.DB) ([]stockableRule, error) {
+	type row struct {
+		SourceTable         string `gorm:"column:source_table"`
+		ProductWarehouseCol string `gorm:"column:product_warehouse_col"`
+		PendingCol          string `gorm:"column:pending_quantity_col"`
+		ScopeSQL            string `gorm:"column:scope_sql"`
+	}
+	var rows []row
+	err := db.WithContext(ctx).
+		Table("fifo_stock_v2_route_rules").
+		Select("DISTINCT source_table, product_warehouse_col, pending_quantity_col, COALESCE(scope_sql,'') AS scope_sql").
+		Where("lane = ? AND is_active = TRUE", "USABLE").
+		Where("pending_quantity_col IS NOT NULL AND pending_quantity_col <> ''").
+		Scan(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+	out := make([]stockableRule, 0, len(rows))
+	seen := map[string]bool{}
+	for _, r := range rows {
+		if !validIdentifiers(r.SourceTable, r.ProductWarehouseCol, r.PendingCol) {
+			return nil, fmt.Errorf("unsafe identifier in usable rule (table=%s pw=%s pending=%s)", r.SourceTable, r.ProductWarehouseCol, r.PendingCol)
+		}
+		key := r.SourceTable + "|" + r.PendingCol + "|" + r.ProductWarehouseCol
+		if seen[key] {
+			continue
+		}
+		seen[key] = true
+		out = append(out, stockableRule{
+			SourceTable:         r.SourceTable,
+			ProductWarehouseCol: r.ProductWarehouseCol,
+			UsedQuantityCol:     r.PendingCol, // reuse field as the column to SUM
+			ScopeSQL:            r.ScopeSQL,
+		})
+	}
+	return out, nil
+}
+
+func loadPWIdentity(ctx context.Context, db *gorm.DB, pw uint) (string, string, error) {
+	type row struct {
+		Product   string `gorm:"column:product"`
+		Warehouse string `gorm:"column:warehouse"`
+	}
+	var out row
+	err := db.WithContext(ctx).
+		Table("product_warehouses pw").
+		Select("p.name AS product, w.name AS warehouse").
+		Joins("JOIN products p ON p.id = pw.product_id").
+		Joins("JOIN warehouses w ON w.id = pw.warehouse_id").
+		Where("pw.id = ?", pw).
+		Take(&out).Error
+	return out.Product, out.Warehouse, err
+}
+
+func loadFlagGroups(ctx context.Context, db *gorm.DB, pw uint) ([]string, error) {
+	var groups []string
+	err := db.WithContext(ctx).
+		Table("stock_allocations").
+		Distinct("flag_group_code").
+		Where("product_warehouse_id = ? AND flag_group_code IS NOT NULL AND flag_group_code <> ''", pw).
+		Order("flag_group_code ASC").
+		Scan(&groups).Error
+	return groups, err
+}
+
+func loadQty(ctx context.Context, db *gorm.DB, pw uint) (float64, error) {
+	var v float64
+	err := db.WithContext(ctx).
+		Table("product_warehouses").
+		Select("COALESCE(qty,0)").
+		Where("id = ?", pw).
+		Scan(&v).Error
+	return v, err
+}
+
+func loadActiveConsume(ctx context.Context, db *gorm.DB, pw uint) (float64, error) {
+	var v float64
+	err := db.WithContext(ctx).
+		Table("stock_allocations").
+		Select("COALESCE(SUM(qty),0)").
+		Where("product_warehouse_id = ? AND status = 'ACTIVE' AND allocation_purpose = 'CONSUME'", pw).
+		Scan(&v).Error
+	return v, err
+}
+
+func sumStockableUsed(ctx context.Context, db *gorm.DB, pw uint, rules []stockableRule) (float64, error) {
+	total := 0.0
+	for _, rule := range rules {
+		v, err := sumColumn(ctx, db, rule.SourceTable, rule.UsedQuantityCol, rule.ProductWarehouseCol, rule.ScopeSQL, pw)
+		if err != nil {
+			return total, err
+		}
+		total += v
+	}
+	return total, nil
+}
+
+func sumPending(ctx context.Context, db *gorm.DB, pw uint, rules []stockableRule) (float64, error) {
+	total := 0.0
+	for _, rule := range rules {
+		v, err := sumColumn(ctx, db, rule.SourceTable, rule.UsedQuantityCol, rule.ProductWarehouseCol, rule.ScopeSQL, pw)
+		if err != nil {
+			return total, err
+		}
+		total += v
+	}
+	return total, nil
+}
+
+func sumColumn(ctx context.Context, db *gorm.DB, table, col, pwCol, scope string, pw uint) (float64, error) {
+	q := fmt.Sprintf("SELECT COALESCE(SUM(%s),0) FROM %s WHERE %s = ?", col, table, pwCol)
+	if strings.TrimSpace(scope) != "" {
+		q += " AND (" + scope + ")"
+	}
+	var v float64
+	err := db.WithContext(ctx).Raw(q, pw).Scan(&v).Error
+	return v, err
+}
+
+// ---- flags / render ----
+
+func parseFlags() (*options, error) {
+	var opts options
+	var pwsRaw string
+	flag.BoolVar(&opts.Apply, "apply", false, "Apply the reconciliation (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(&pwsRaw, "pw", "", "Comma-separated product_warehouse ids to reconcile (required)")
+	flag.Parse()
+
+	opts.Output = strings.ToLower(strings.TrimSpace(opts.Output))
+	if opts.Output == "" {
+		opts.Output = outputTable
+	}
+	if opts.Output != outputTable && opts.Output != outputJSON {
+		return nil, fmt.Errorf("unsupported --output=%s", opts.Output)
+	}
+
+	pwsRaw = strings.TrimSpace(pwsRaw)
+	if pwsRaw == "" {
+		return nil, fmt.Errorf("-pw is required (e.g. -pw=1292 or -pw=1292,1296)")
+	}
+	for _, part := range strings.Split(pwsRaw, ",") {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		id, err := strconv.ParseUint(part, 10, 64)
+		if err != nil || id == 0 {
+			return nil, fmt.Errorf("invalid product_warehouse id %q", part)
+		}
+		opts.PWs = append(opts.PWs, uint(id))
+	}
+	if len(opts.PWs) == 0 {
+		return nil, fmt.Errorf("no valid product_warehouse ids parsed from -pw")
+	}
+	return &opts, nil
+}
+
+func validIdentifiers(ids ...string) bool {
+	for _, id := range ids {
+		if !identifierRe.MatchString(id) {
+			return false
+		}
+	}
+	return true
+}
+
+func modeLabel(apply bool) string {
+	if apply {
+		return "APPLY"
+	}
+	return "DRY_RUN"
+}
+
+func render(mode string, summary runSummary) {
+	if mode == outputJSON {
+		enc := json.NewEncoder(os.Stdout)
+		enc.SetIndent("", "  ")
+		_ = enc.Encode(summary)
+		return
+	}
+
+	fmt.Printf("=== Reconcile FIFO total_used ===\n")
+	fmt.Printf("Mode            : %s\n", summary.Mode)
+	for _, r := range summary.Results {
+		fmt.Printf("\n--- PW %d (%s @ %s) [%s] ---\n", r.ProductWarehouseID, r.Product, r.Warehouse, r.Status)
+		if r.Error != "" {
+			fmt.Printf("ERROR           : %s\n", r.Error)
+		}
+		fmt.Printf("Flag groups     : %s\n", strings.Join(r.FlagGroups, ", "))
+		fmt.Printf("qty (before)    : %.3f\n", r.QtyBefore)
+		fmt.Printf("Σ total_used    : %.3f\n", r.TotalUsedBefore)
+		fmt.Printf("Σ active CONSUME: %.3f\n", r.ActiveConsume)
+		fmt.Printf("PHANTOM         : %.3f  (total_used yang akan dilepas)\n", r.Phantom)
+		fmt.Printf("pending (before): %.3f\n", r.PendingBefore)
+		if summary.Mode == "APPLY" && r.Status == "OK" {
+			fmt.Printf("qty (after)     : %.3f\n", r.QtyAfter)
+			fmt.Printf("pending (after) : %.3f\n", r.PendingAfter)
+		}
+	}
+	fmt.Printf("\nDuration        : %.2fs\n", summary.DurationSeconds)
+	fmt.Printf("Overall status  : %s\n", summary.OverallStatus)
+}

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

@@ -102,11 +102,17 @@ type HppV2CostRepository interface {
 	GetProjectFlockKandangContext(ctx context.Context, projectFlockKandangId uint) (*HppV2ProjectFlockKandangContext, error)
 	GetProjectFlockKandangIDs(ctx context.Context, projectFlockId uint) ([]uint, error)
 	GetLatestTransferInputByProjectFlockKandangID(ctx context.Context, projectFlockKandangId uint, period time.Time) (*HppV2LatestTransferInputRow, error)
+	// GetAllTransferInputsByProjectFlockKandangID return SEMUA approved transfer ke target kandang
+	// itu, untuk skenario multi-source di mana 1 target menerima dari multiple transfer terpisah.
+	// Setiap row = 1 transfer dengan cost basis & chick_in_date sendiri (per source). Order:
+	// effective_date ASC, id ASC (kronologis).
+	GetAllTransferInputsByProjectFlockKandangID(ctx context.Context, projectFlockKandangId uint, period time.Time) ([]HppV2LatestTransferInputRow, error)
 	GetManualDepreciationInputByProjectFlockID(ctx context.Context, projectFlockID uint) (*HppV2ManualDepreciationInputRow, error)
 	GetRecordingStockRoutingAdjustmentCostByProjectFlockID(ctx context.Context, projectFlockID uint, periodDate time.Time) (float64, error)
 	GetFarmDepreciationSnapshotByProjectFlockIDAndPeriod(ctx context.Context, projectFlockID uint, periodDate time.Time) (*HppV2FarmDepreciationSnapshotRow, error)
 	GetEarliestChickInDateByProjectFlockID(ctx context.Context, projectFlockID uint) (*time.Time, error)
-	GetDepreciationPercents(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, error)
+	GetChickinPopulationByPFKForFarm(ctx context.Context, projectFlockID uint) (map[uint]float64, error)
+	GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, map[string]*time.Time, error)
 	ListUsageCostRowsByProductFlags(ctx context.Context, projectFlockKandangIDs []uint, flagNames []string, date *time.Time) ([]HppV2UsageCostRow, error)
 	ListAdjustmentCostRowsByProductFlags(ctx context.Context, projectFlockKandangIDs []uint, flagNames []string, date *time.Time) ([]HppV2AdjustmentCostRow, error)
 	ListExpenseRealizationRowsByProjectFlockKandangIDs(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time, ekspedisi bool) ([]HppV2ExpenseCostRow, error)
@@ -230,6 +236,62 @@ LIMIT 1
 	return &row, nil
 }
 
+func (r *HppV2RepositoryImpl) GetAllTransferInputsByProjectFlockKandangID(
+	ctx context.Context,
+	projectFlockKandangId uint,
+	period time.Time,
+) ([]HppV2LatestTransferInputRow, error) {
+	var rows []HppV2LatestTransferInputRow
+	query := `
+WITH latest_transfer_approval AS (
+	SELECT a.approvable_id, a.action
+	FROM approvals a
+	JOIN (
+		SELECT approvable_id, MAX(action_at) AS latest_action_at
+		FROM approvals
+		WHERE approvable_type = @approval_type
+		GROUP BY approvable_id
+	) la
+		ON la.approvable_id = a.approvable_id
+		AND la.latest_action_at = a.action_at
+	WHERE a.approvable_type = @approval_type
+),
+approved_transfers AS (
+	SELECT
+		lt.id,
+		lt.from_project_flock_id,
+		COALESCE(DATE(lt.effective_move_date), DATE(lt.economic_cutoff_date), DATE(lt.transfer_date)) AS effective_date
+	FROM laying_transfers lt
+	JOIN latest_transfer_approval lta ON lta.approvable_id = lt.id
+	WHERE lt.deleted_at IS NULL
+	  AND lt.executed_at IS NOT NULL
+	  AND lta.action = 'APPROVED'
+)
+SELECT
+	ltt.target_project_flock_kandang_id AS project_flock_kandang_id,
+	at.from_project_flock_id AS source_project_flock_id,
+	at.effective_date AS transfer_date,
+	ltt.total_qty AS transfer_qty,
+	at.id AS transfer_id
+FROM laying_transfer_targets ltt
+JOIN approved_transfers at ON at.id = ltt.laying_transfer_id
+WHERE ltt.deleted_at IS NULL
+  AND ltt.target_project_flock_kandang_id = @project_flock_kandang_id
+  AND at.effective_date <= DATE(@period_date)
+ORDER BY at.effective_date ASC, at.id ASC
+`
+
+	err := r.db.WithContext(ctx).Raw(query, map[string]any{
+		"approval_type":            utils.ApprovalWorkflowTransferToLaying.String(),
+		"project_flock_kandang_id": projectFlockKandangId,
+		"period_date":              period,
+	}).Scan(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
 func (r *HppV2RepositoryImpl) GetManualDepreciationInputByProjectFlockID(
 	ctx context.Context,
 	projectFlockID uint,
@@ -373,42 +435,74 @@ func (r *HppV2RepositoryImpl) GetEarliestChickInDateByProjectFlockID(ctx context
 	return selected.ChickInDate, nil
 }
 
-func (r *HppV2RepositoryImpl) GetDepreciationPercents(
+func (r *HppV2RepositoryImpl) GetChickinPopulationByPFKForFarm(
 	ctx context.Context,
-	houseTypes []string,
-	maxDay int,
-) (map[string]map[int]float64, error) {
-	result := make(map[string]map[int]float64)
-	if len(houseTypes) == 0 || maxDay <= 0 {
-		return result, nil
-	}
-
+	projectFlockID uint,
+) (map[uint]float64, error) {
 	type row struct {
-		HouseType           string
-		Day                 int
-		DepreciationPercent float64
+		ProjectFlockKandangID uint    `gorm:"column:project_flock_kandang_id"`
+		TotalQty              float64 `gorm:"column:total_qty"`
 	}
-
-	rows := make([]row, 0)
+	var rows []row
 	err := r.db.WithContext(ctx).
-		Table("house_depreciation_standards").
-		Select("house_type::text AS house_type, day, depreciation_percent").
-		Where("house_type::text IN ?", houseTypes).
-		Where("day <= ?", maxDay).
-		Order("house_type ASC, day ASC").
+		Table("project_chickins AS pc").
+		Select("pc.project_flock_kandang_id, SUM(pc.usage_qty) AS total_qty").
+		Joins("JOIN project_flock_kandangs AS pfk ON pfk.id = pc.project_flock_kandang_id").
+		Where("pc.deleted_at IS NULL").
+		Where("pfk.project_flock_id = ?", projectFlockID).
+		Group("pc.project_flock_kandang_id").
 		Scan(&rows).Error
 	if err != nil {
 		return nil, err
 	}
+	result := make(map[uint]float64, len(rows))
+	for _, x := range rows {
+		result[x.ProjectFlockKandangID] = x.TotalQty
+	}
+	return result, nil
+}
+
+func (r *HppV2RepositoryImpl) GetMultiplicationPercentages(
+	ctx context.Context,
+	houseTypes []string,
+	maxDay int,
+) (map[string]map[int]float64, map[string]*time.Time, error) {
+	result := make(map[string]map[int]float64)
+	effectiveDates := make(map[string]*time.Time)
+	if len(houseTypes) == 0 || maxDay <= 0 {
+		return result, effectiveDates, nil
+	}
+
+	type row struct {
+		HouseType                string
+		Day                      int
+		MultiplicationPercentage float64
+		EffectiveDate            *time.Time
+	}
+
+	rows := make([]row, 0)
+	err := r.db.WithContext(ctx).Raw(`
+		SELECT DISTINCT ON (house_type::text, day)
+			house_type::text AS house_type, day, multiplication_percentage, effective_date
+		FROM house_depreciation_standards
+		WHERE house_type::text IN ? AND day <= ?
+		ORDER BY house_type, day, effective_date DESC NULLS LAST
+	`, houseTypes, maxDay).Scan(&rows).Error
+	if err != nil {
+		return nil, nil, err
+	}
 
 	for _, item := range rows {
 		if _, exists := result[item.HouseType]; !exists {
 			result[item.HouseType] = make(map[int]float64)
 		}
-		result[item.HouseType][item.Day] = item.DepreciationPercent
+		result[item.HouseType][item.Day] = item.MultiplicationPercentage
+		if _, tracked := effectiveDates[item.HouseType]; !tracked {
+			effectiveDates[item.HouseType] = item.EffectiveDate
+		}
 	}
 
-	return result, nil
+	return result, effectiveDates, nil
 }
 
 func (r *HppV2RepositoryImpl) ListUsageCostRowsByProductFlags(

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

@@ -6,8 +6,8 @@ import (
 )
 
 const (
-	depreciationStartAgeDayCloseHouse = 155
-	depreciationStartAgeDayOpenHouse  = 176
+	depreciationStartAgeDayCloseHouse = 175
+	depreciationStartAgeDayOpenHouse  = 175
 )
 
 func NormalizeDepreciationHouseType(raw string) string {
@@ -26,8 +26,8 @@ func DepreciationStartAgeDay(houseType string) int {
 }
 
 func FlockAgeDay(originDate time.Time, periodDate time.Time) int {
-	origin := time.Date(originDate.Year(), originDate.Month(), originDate.Day(), 0, 0, 0, 0, originDate.Location())
-	period := time.Date(periodDate.Year(), periodDate.Month(), periodDate.Day(), 0, 0, 0, 0, periodDate.Location())
+	origin := time.Date(originDate.Year(), originDate.Month(), originDate.Day(), 0, 0, 0, 0, time.UTC)
+	period := time.Date(periodDate.Year(), periodDate.Month(), periodDate.Day(), 0, 0, 0, 0, time.UTC)
 	if period.Before(origin) {
 		return 0
 	}
@@ -47,9 +47,9 @@ func CalculateDepreciationAtDayN(
 	initialPulletCost float64,
 	dayN int,
 	houseType string,
-	percentByHouseType map[string]map[int]float64,
+	multiplicationByHouseType map[string]map[int]float64,
 ) (float64, float64, float64) {
-	return CalculateDepreciationFromDayRange(initialPulletCost, 1, dayN, houseType, percentByHouseType)
+	return CalculateDepreciationFromDayRange(initialPulletCost, 1, dayN, houseType, multiplicationByHouseType)
 }
 
 func CalculateDepreciationFromDayRange(
@@ -57,8 +57,8 @@ func CalculateDepreciationFromDayRange(
 	startDay int,
 	endDay int,
 	houseType string,
-	percentByHouseType map[string]map[int]float64,
-) (float64, float64, float64) {
+	multiplicationByHouseType map[string]map[int]float64,
+) (pulletCostDayN, depreciationValue, multiplicationPercentage float64) {
 	if initialPulletCost <= 0 || endDay <= 0 {
 		return 0, 0, 0
 	}
@@ -70,30 +70,30 @@ func CalculateDepreciationFromDayRange(
 	}
 
 	normalizedHouseType := NormalizeDepreciationHouseType(houseType)
-	housePercent, exists := percentByHouseType[normalizedHouseType]
+	houseMult, exists := multiplicationByHouseType[normalizedHouseType]
 	if !exists {
 		return 0, 0, 0
 	}
 
 	current := initialPulletCost
-	pulletCostDayN := 0.0
-	depreciationValue := 0.0
-	depreciationPercent := 0.0
 	for day := startDay; day <= endDay; day++ {
-		pct := housePercent[day]
-		dep := current * (pct / 100)
+		mult, ok := houseMult[day]
+		if !ok {
+			// No standard for this day → assume no depreciation (mult=1).
+			mult = 1.0
+		}
 		if day == endDay {
 			pulletCostDayN = current
-			depreciationValue = dep
-			depreciationPercent = pct
+			multiplicationPercentage = mult
+			depreciationValue = current * (1.0 - mult)
 		}
-		current -= dep
+		current = current * mult
 		if current < 0 {
 			current = 0
 		}
 	}
 
-	return pulletCostDayN, depreciationValue, depreciationPercent
+	return pulletCostDayN, depreciationValue, multiplicationPercentage
 }
 
 func CalculateEffectiveDepreciationPercent(totalDepreciationValue, totalPulletCostDayN float64) float64 {

internal/common/service/common.fifo_payment.service.go

@@ -0,0 +1,393 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"strings"
+	"time"
+
+	"github.com/sirupsen/logrus"
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gorm.io/gorm"
+)
+
+// ParentKind enumerasi parent yang punya grand_total dari SUM children.
+type ParentKind string
+
+const (
+	ParentKindPurchase  ParentKind = "PURCHASE"
+	ParentKindMarketing ParentKind = "MARKETING"
+	ParentKindExpense   ParentKind = "EXPENSE"
+)
+
+// AllocationKind enumerasi sub-row anak target FIFO allocation.
+type AllocationKind string
+
+const (
+	AllocKindPurchaseItem             AllocationKind = "PURCHASE_ITEM"
+	AllocKindMarketingDeliveryProduct AllocationKind = "MDP"
+	AllocKindExpenseRealization       AllocationKind = "EXPENSE_REALIZATION"
+)
+
+// fifoEpsilon untuk float comparison saat FIFO matching.
+const fifoEpsilon = 0.001
+
+// FifoPaymentService meng-orchestrate FIFO allocation antara payments dan
+// sub-row anak (purchase_items / marketing_delivery_products / expense_realizations).
+type FifoPaymentService interface {
+	// ReallocateForParty wipe allocations untuk semua payment party tsb,
+	// lalu re-FIFO dari history (sort children by date ASC, payments by payment_date ASC).
+	// Caller WAJIB pass tx untuk konsistensi dengan mutasi upstream.
+	ReallocateForParty(ctx context.Context, tx *gorm.DB, partyType string, partyID uint) error
+
+	// RecomputeGrandTotal refresh parent.grand_total = SUM children eligible amount.
+	RecomputeGrandTotal(ctx context.Context, tx *gorm.DB, kind ParentKind, parentID uint) error
+}
+
+type fifoPaymentService struct {
+	db     *gorm.DB
+	logger *logrus.Logger
+}
+
+func NewFifoPaymentService(db *gorm.DB, logger *logrus.Logger) FifoPaymentService {
+	if logger == nil {
+		logger = logrus.StandardLogger()
+	}
+	return &fifoPaymentService{db: db, logger: logger}
+}
+
+func (s *fifoPaymentService) txOrDB(tx *gorm.DB) *gorm.DB {
+	if tx != nil {
+		return tx
+	}
+	return s.db
+}
+
+type childRow struct {
+	Kind      AllocationKind
+	ChildID   uint64
+	Amount    float64
+	Remaining float64
+}
+
+type paymentRow struct {
+	ID      uint
+	Nominal float64
+	Date    time.Time
+}
+
+// ReallocateForParty acquire advisory lock then perform full re-FIFO.
+// Jika tx nil, function buka transaction sendiri (advisory lock harus dalam TX).
+func (s *fifoPaymentService) ReallocateForParty(ctx context.Context, tx *gorm.DB, partyType string, partyID uint) error {
+	if partyID == 0 {
+		return nil
+	}
+	party := strings.ToUpper(strings.TrimSpace(partyType))
+	if party != string(utils.PaymentPartyCustomer) && party != string(utils.PaymentPartySupplier) {
+		return fmt.Errorf("fifoPayment: invalid party_type %q", partyType)
+	}
+	if tx == nil {
+		return s.db.WithContext(ctx).Transaction(func(innerTx *gorm.DB) error {
+			return s.reallocateInTx(ctx, innerTx, party, partyID)
+		})
+	}
+	return s.reallocateInTx(ctx, tx, party, partyID)
+}
+
+func (s *fifoPaymentService) reallocateInTx(ctx context.Context, tx *gorm.DB, party string, partyID uint) error {
+	db := tx.WithContext(ctx)
+
+	// Advisory lock per (party_type, party_id) — 1-arg form (bigint).
+	// Postgres 2-arg form butuh kedua param int4, sedangkan party_id bisa lebih besar.
+	lockKey := fmt.Sprintf("payment_alloc:%s:%d", party, partyID)
+	if err := db.Exec("SELECT pg_advisory_xact_lock(hashtext(?)::bigint)", lockKey).Error; err != nil {
+		return fmt.Errorf("fifoPayment: advisory lock: %w", err)
+	}
+
+	// Wipe existing allocations untuk semua payment party tsb
+	if err := db.Exec(`
+		DELETE FROM payment_allocations
+		WHERE payment_id IN (
+			SELECT id FROM payments
+			WHERE party_type = ? AND party_id = ? AND deleted_at IS NULL
+		)
+	`, party, partyID).Error; err != nil {
+		return fmt.Errorf("fifoPayment: wipe allocations: %w", err)
+	}
+
+	children, err := s.fetchChildren(ctx, db, party, partyID)
+	if err != nil {
+		return err
+	}
+	if len(children) == 0 {
+		return nil
+	}
+
+	// Fetch SEMUA payments termasuk SALDO_AWAL agar allocation tercatat di DB
+	// (SaldoAwal opening credit harus consume oldest debts; tanpa allocation row,
+	// debt yang ter-cover SaldoAwal akan tampak "Belum Lunas" di report).
+	payments, err := s.fetchAllPayments(ctx, db, party, partyID)
+	if err != nil {
+		return err
+	}
+
+	// Greedy: per payment, alokasi ke children tertua dengan remaining > 0
+	allocs := make([]entity.PaymentAllocation, 0, len(payments))
+	now := time.Now()
+	for _, pay := range payments {
+		remaining := pay.Nominal
+		if remaining <= fifoEpsilon {
+			continue
+		}
+		for i := range children {
+			if remaining <= fifoEpsilon {
+				break
+			}
+			if children[i].Remaining <= fifoEpsilon {
+				continue
+			}
+			used := math.Min(remaining, children[i].Remaining)
+			children[i].Remaining -= used
+			remaining -= used
+
+			alloc := entity.PaymentAllocation{
+				PaymentId:   pay.ID,
+				Amount:      used,
+				AllocatedAt: now,
+			}
+			switch children[i].Kind {
+			case AllocKindPurchaseItem:
+				id := uint(children[i].ChildID)
+				alloc.PurchaseItemId = &id
+			case AllocKindMarketingDeliveryProduct:
+				id := uint(children[i].ChildID)
+				alloc.MarketingDeliveryProductId = &id
+			case AllocKindExpenseRealization:
+				id := children[i].ChildID
+				alloc.ExpenseRealizationId = &id
+			}
+			allocs = append(allocs, alloc)
+		}
+	}
+
+	if len(allocs) == 0 {
+		return nil
+	}
+	// Batch insert allocations
+	if err := db.CreateInBatches(&allocs, 500).Error; err != nil {
+		return fmt.Errorf("fifoPayment: insert allocations: %w", err)
+	}
+	return nil
+}
+
+// fetchChildren return eligible sub-rows sorted by date ASC, id ASC.
+func (s *fifoPaymentService) fetchChildren(ctx context.Context, db *gorm.DB, party string, partyID uint) ([]childRow, error) {
+	if party == string(utils.PaymentPartySupplier) {
+		return s.fetchSupplierChildren(ctx, db, partyID)
+	}
+	return s.fetchCustomerChildren(ctx, db, partyID)
+}
+
+func (s *fifoPaymentService) fetchSupplierChildren(ctx context.Context, db *gorm.DB, supplierID uint) ([]childRow, error) {
+	// purchase_items eligible: purchases approval latest step >= Receiving (4), action != REJECTED, received_date IS NOT NULL
+	var purchaseRows []chronoRow
+	purchaseSQL := `
+		SELECT 'PURCHASE_ITEM' AS kind,
+		       pi.id::BIGINT AS child_id,
+		       pi.total_price AS amount,
+		       pi.received_date AS sort_date,
+		       pi.id::BIGINT AS sort_id
+		FROM purchase_items pi
+		JOIN purchases p ON p.id = pi.purchase_id
+		JOIN LATERAL (
+			SELECT a.step_number, a.action
+			FROM approvals a
+			WHERE a.approvable_type = ? AND a.approvable_id = p.id
+			ORDER BY a.action_at DESC, a.id DESC
+			LIMIT 1
+		) la ON TRUE
+		WHERE p.supplier_id = ?
+		  AND p.deleted_at IS NULL
+		  AND pi.received_date IS NOT NULL
+		  AND la.step_number >= ?
+		  AND (la.action IS NULL OR la.action <> ?)
+		  AND pi.total_price > 0
+		ORDER BY pi.received_date ASC, pi.id ASC
+	`
+	if err := db.WithContext(ctx).Raw(purchaseSQL,
+		string(utils.ApprovalWorkflowPurchase),
+		supplierID,
+		uint16(utils.PurchaseStepReceiving),
+		string(entity.ApprovalActionRejected),
+	).Scan(&purchaseRows).Error; err != nil {
+		return nil, fmt.Errorf("fifoPayment: fetch purchase items: %w", err)
+	}
+
+	// expense_realizations via expense_nonstocks → expenses, approval latest step >= Realisasi (5)
+	// Sort pakai e.transaction_date (bukan realization_date) supaya FIFO match dengan tanggal yang
+	// dipakai report sebagai "tanggal dokumen" — user assume FIFO = lunasi yang transaction_date paling tua dulu.
+	var expenseRows []chronoRow
+	expenseSQL := `
+		SELECT 'EXPENSE_REALIZATION' AS kind,
+		       er.id::BIGINT AS child_id,
+		       (er.qty * er.price) AS amount,
+		       e.transaction_date AS sort_date,
+		       er.id::BIGINT AS sort_id
+		FROM expense_realizations er
+		JOIN expense_nonstocks en ON en.id = er.expense_nonstock_id
+		JOIN expenses e ON e.id = en.expense_id
+		JOIN LATERAL (
+			SELECT a.step_number, a.action
+			FROM approvals a
+			WHERE a.approvable_type = ? AND a.approvable_id = e.id
+			ORDER BY a.action_at DESC, a.id DESC
+			LIMIT 1
+		) la ON TRUE
+		WHERE e.supplier_id = ?
+		  AND e.deleted_at IS NULL
+		  AND la.step_number >= ?
+		  AND (la.action IS NULL OR la.action <> ?)
+		  AND (er.qty * er.price) > 0
+		ORDER BY e.transaction_date ASC, e.id ASC, er.id ASC
+	`
+	if err := db.WithContext(ctx).Raw(expenseSQL,
+		string(utils.ApprovalWorkflowExpense),
+		supplierID,
+		uint16(utils.ExpenseStepRealisasi),
+		string(entity.ApprovalActionRejected),
+	).Scan(&expenseRows).Error; err != nil {
+		return nil, fmt.Errorf("fifoPayment: fetch expense realizations: %w", err)
+	}
+
+	// Merge in chronological order (kedua list sudah sorted; merge stable)
+	merged := mergeSortedByDate(purchaseRows, expenseRows)
+	out := make([]childRow, 0, len(merged))
+	for _, r := range merged {
+		out = append(out, childRow{
+			Kind:      AllocationKind(r.Kind),
+			ChildID:   r.ChildID,
+			Amount:    r.Amount,
+			Remaining: r.Amount,
+		})
+	}
+	return out, nil
+}
+
+func (s *fifoPaymentService) fetchCustomerChildren(ctx context.Context, db *gorm.DB, customerID uint) ([]childRow, error) {
+	var mdpRows []chronoRow
+	sql := `
+		SELECT 'MDP' AS kind,
+		       mdp.id::BIGINT AS child_id,
+		       mdp.total_price AS amount,
+		       mdp.delivery_date AS sort_date,
+		       mdp.id::BIGINT AS sort_id
+		FROM marketing_delivery_products mdp
+		JOIN marketing_products mp ON mp.id = mdp.marketing_product_id
+		JOIN marketings m ON m.id = mp.marketing_id
+		WHERE m.customer_id = ?
+		  AND m.deleted_at IS NULL
+		  AND mdp.delivery_date IS NOT NULL
+		  AND mdp.total_price > 0
+		ORDER BY mdp.delivery_date ASC, mdp.id ASC
+	`
+	if err := db.WithContext(ctx).Raw(sql, customerID).Scan(&mdpRows).Error; err != nil {
+		return nil, fmt.Errorf("fifoPayment: fetch marketing delivery products: %w", err)
+	}
+	out := make([]childRow, 0, len(mdpRows))
+	for _, r := range mdpRows {
+		out = append(out, childRow{
+			Kind:      AllocationKind(r.Kind),
+			ChildID:   r.ChildID,
+			Amount:    r.Amount,
+			Remaining: r.Amount,
+		})
+	}
+	return out, nil
+}
+
+// fetchAllPayments return SEMUA payments (termasuk SALDO_AWAL) sort by payment_date ASC, id ASC.
+// SALDO_AWAL diperlakukan sebagai payment tertua agar opening credit otomatis consume oldest debts via FIFO.
+func (s *fifoPaymentService) fetchAllPayments(ctx context.Context, db *gorm.DB, party string, partyID uint) ([]paymentRow, error) {
+	var rows []paymentRow
+	sql := `
+		SELECT id, nominal, payment_date AS date
+		FROM payments
+		WHERE party_type = ? AND party_id = ?
+		  AND deleted_at IS NULL
+		  AND nominal > 0
+		ORDER BY payment_date ASC, id ASC
+	`
+	if err := db.WithContext(ctx).Raw(sql, party, partyID).Scan(&rows).Error; err != nil {
+		return nil, fmt.Errorf("fifoPayment: fetch payments: %w", err)
+	}
+	return rows, nil
+}
+
+// RecomputeGrandTotal refresh parent.grand_total dari SUM children eligible amount.
+func (s *fifoPaymentService) RecomputeGrandTotal(ctx context.Context, tx *gorm.DB, kind ParentKind, parentID uint) error {
+	db := s.txOrDB(tx).WithContext(ctx)
+	if parentID == 0 {
+		return nil
+	}
+	switch kind {
+	case ParentKindPurchase:
+		return db.Exec(`
+			UPDATE purchases p
+			SET grand_total = COALESCE((SELECT SUM(total_price) FROM purchase_items WHERE purchase_id = p.id), 0)
+			WHERE p.id = ?
+		`, parentID).Error
+	case ParentKindMarketing:
+		return db.Exec(`
+			UPDATE marketings m
+			SET grand_total = COALESCE((
+				SELECT SUM(mdp.total_price)
+				FROM marketing_delivery_products mdp
+				JOIN marketing_products mp ON mp.id = mdp.marketing_product_id
+				WHERE mp.marketing_id = m.id AND mdp.delivery_date IS NOT NULL
+			), 0)
+			WHERE m.id = ?
+		`, parentID).Error
+	case ParentKindExpense:
+		return db.Exec(`
+			UPDATE expenses e
+			SET grand_total = 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 = e.id
+			), 0)
+			WHERE e.id = ?
+		`, parentID).Error
+	default:
+		return fmt.Errorf("fifoPayment: unknown parent kind %q", kind)
+	}
+}
+
+// chronoRow row antara untuk merge sort children.
+type chronoRow struct {
+	Kind     string
+	ChildID  uint64
+	Amount   float64
+	SortDate time.Time
+	SortID   uint64
+}
+
+func mergeSortedByDate(a, b []chronoRow) []chronoRow {
+	out := make([]chronoRow, 0, len(a)+len(b))
+	i, j := 0, 0
+	for i < len(a) && j < len(b) {
+		if a[i].SortDate.Before(b[j].SortDate) ||
+			(a[i].SortDate.Equal(b[j].SortDate) && a[i].SortID < b[j].SortID) {
+			out = append(out, a[i])
+			i++
+		} else {
+			out = append(out, b[j])
+			j++
+		}
+	}
+	out = append(out, a[i:]...)
+	out = append(out, b[j:]...)
+	return out
+}

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

@@ -1191,26 +1191,72 @@ func (s *hppV2Service) getDepreciationComponent(
 		}, nil
 	}
 
-	if totalPulletCost <= 0 {
-		return nil, nil
-	}
-
-	transferInput, err := s.hppRepo.GetLatestTransferInputByProjectFlockKandangID(context.Background(), projectFlockKandangId, periodDate)
+	// Multi-source support: 1 target kandang bisa menerima dari MULTIPLE transfer terpisah
+	// (tiap transfer = 1 source kandang). Depresiasi per target = SUM dari per-transfer depresiasi.
+	// Setiap transfer dihitung dengan chick_in_date source-nya sendiri dan cost basis pro-rated
+	// berdasarkan qty share (transfer.qty / totalTransferQty).
+	transferInputs, err := s.hppRepo.GetAllTransferInputsByProjectFlockKandangID(context.Background(), projectFlockKandangId, periodDate)
 	if err != nil {
 		return nil, err
 	}
 
-	var part *HppV2ComponentPart
-	if transferInput != nil && transferInput.SourceProjectFlockID > 0 {
-		part, err = s.buildNormalTransferDepreciationPart(contextRow, transferInput, periodDate, totalPulletCost)
-		if err != nil {
-			return nil, err
+	// Filter valid transfers (punya source flock id)
+	validTransfers := make([]commonRepo.HppV2LatestTransferInputRow, 0, len(transferInputs))
+	totalTransferQty := 0.0
+	for _, t := range transferInputs {
+		if t.SourceProjectFlockID == 0 {
+			continue
 		}
-	} else {
-		part, err = s.buildManualCutoverDepreciationPart(projectFlockKandangId, contextRow, periodDate, totalPulletCost)
-		if err != nil {
-			return nil, err
+		validTransfers = append(validTransfers, t)
+		totalTransferQty += t.TransferQty
+	}
+
+	if len(validTransfers) > 0 {
+		if totalPulletCost <= 0 {
+			return nil, nil
 		}
+
+		totalDepreciation := 0.0
+		parts := make([]HppV2ComponentPart, 0, len(validTransfers))
+		for i := range validTransfers {
+			t := validTransfers[i]
+			// Pro-rate cost basis per transfer berdasarkan qty share.
+			// CATATAN: pendekatan ini AKURAT kalau cost per ekor sama antar source flock.
+			// Kalau cost per ekor berbeda signifikan antar source, follow-up: refactor
+			// `buildGrowingUsagePart` untuk multi-source-flock cost computation.
+			transferCostBasis := totalPulletCost
+			if totalTransferQty > 0 && len(validTransfers) > 1 {
+				transferCostBasis = totalPulletCost * (t.TransferQty / totalTransferQty)
+			}
+
+			part, partErr := s.buildNormalTransferDepreciationPart(contextRow, &t, periodDate, transferCostBasis)
+			if partErr != nil {
+				return nil, partErr
+			}
+			if part == nil {
+				continue
+			}
+			totalDepreciation += part.Total
+			parts = append(parts, *part)
+		}
+
+		if len(parts) == 0 {
+			return nil, nil
+		}
+
+		return &HppV2Component{
+			Code:   hppV2ComponentDepreciation,
+			Title:  "Depreciation",
+			Scopes: []string{hppV2ScopeProductionCost},
+			Total:  totalDepreciation,
+			Parts:  parts,
+		}, nil
+	}
+
+	// Fallback: manual cut-over (kandang tanpa transfer record)
+	part, err := s.buildManualCutoverDepreciationPart(projectFlockKandangId, contextRow, periodDate, totalPulletCost)
+	if err != nil {
+		return nil, err
 	}
 	if part == nil {
 		return nil, nil
@@ -1344,20 +1390,27 @@ func (s *hppV2Service) buildNormalTransferDepreciationPart(
 	}
 
 	houseType := NormalizeDepreciationHouseType(contextRow.HouseType)
-	percentByHouseType, err := s.hppRepo.GetDepreciationPercents(context.Background(), []string{houseType}, scheduleDay)
+	multiplicationByHouseType, effectiveDates, err := s.hppRepo.GetMultiplicationPercentages(context.Background(), []string{houseType}, scheduleDay)
 	if err != nil {
 		return nil, err
 	}
 
-	pulletCostDayN, depreciationValue, depreciationPercent := CalculateDepreciationAtDayN(
+	pulletCostDayN, depreciationValue, multiplicationPercentage := CalculateDepreciationAtDayN(
 		totalPulletCost,
 		scheduleDay,
 		contextRow.HouseType,
-		percentByHouseType,
+		multiplicationByHouseType,
 	)
-	if depreciationValue <= 0 {
+	if depreciationValue <= 0 && pulletCostDayN <= 0 {
 		return nil, nil
 	}
+	totalValueAfter := pulletCostDayN * multiplicationPercentage
+	depreciationPercent := (1.0 - multiplicationPercentage) * 100.0
+
+	var standardEffectiveDate string
+	if ed, ok := effectiveDates[houseType]; ok && ed != nil {
+		standardEffectiveDate = formatDateOnly(*ed)
+	}
 
 	return &HppV2ComponentPart{
 		Code:   hppV2PartDepreciationNormal,
@@ -1365,13 +1418,17 @@ func (s *hppV2Service) buildNormalTransferDepreciationPart(
 		Scopes: []string{hppV2ScopeProductionCost},
 		Total:  depreciationValue,
 		Details: map[string]any{
-			"basis_total":             totalPulletCost,
-			"pullet_cost_day_n":       pulletCostDayN,
-			"depreciation_percent":    depreciationPercent,
-			"schedule_day":            scheduleDay,
-			"origin_date":             formatDateOnly(*originDate),
-			"transfer_date":           formatDateOnly(transferInput.TransferDate),
-			"source_project_flock_id": transferInput.SourceProjectFlockID,
+			"basis_total":                           totalPulletCost,
+			"pullet_cost_day_n":                     pulletCostDayN,
+			"multiplication_percentage":             multiplicationPercentage,
+			"total_value_pullet_after_depreciation": totalValueAfter,
+			"depreciation_percent":                  depreciationPercent,
+			"schedule_day":                          scheduleDay,
+			"origin_date":                           formatDateOnly(*originDate),
+			"transfer_date":                         formatDateOnly(transferInput.TransferDate),
+			"source_project_flock_id":               transferInput.SourceProjectFlockID,
+			"standard_effective_date":               standardEffectiveDate,
+			"kandang_population":                    transferInput.TransferQty,
 		},
 		References: []HppV2Reference{
 			{
@@ -1392,7 +1449,7 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 	periodDate time.Time,
 	totalPulletCost float64,
 ) (*HppV2ComponentPart, error) {
-	if contextRow == nil || totalPulletCost <= 0 {
+	if contextRow == nil {
 		return nil, nil
 	}
 
@@ -1407,6 +1464,21 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 		return nil, nil
 	}
 
+	populations, err := s.hppRepo.GetChickinPopulationByPFKForFarm(context.Background(), contextRow.ProjectFlockID)
+	if err != nil {
+		return nil, err
+	}
+	var totalPopulation float64
+	for _, qty := range populations {
+		totalPopulation += qty
+	}
+	kandangPopulation := populations[projectFlockKandangId]
+	if totalPopulation <= 0 || kandangPopulation <= 0 {
+		return nil, nil
+	}
+	populationShare := kandangPopulation / totalPopulation
+	basis := manualInput.TotalCost * populationShare
+
 	originDate, err := s.hppRepo.GetEarliestChickInDateByProjectFlockID(context.Background(), contextRow.ProjectFlockID)
 	if err != nil {
 		return nil, err
@@ -1427,21 +1499,29 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 	}
 
 	houseType := NormalizeDepreciationHouseType(contextRow.HouseType)
-	percentByHouseType, err := s.hppRepo.GetDepreciationPercents(context.Background(), []string{houseType}, reportScheduleDay)
+	multiplicationByHouseType, effectiveDates, err := s.hppRepo.GetMultiplicationPercentages(context.Background(), []string{houseType}, reportScheduleDay)
 	if err != nil {
 		return nil, err
 	}
 
-	pulletCostDayN, depreciationValue, depreciationPercent := CalculateDepreciationFromDayRange(
-		totalPulletCost,
+	pulletCostDayN, depreciationValue, multiplicationPercentage := CalculateDepreciationFromDayRange(
+		basis,
 		startDay,
 		reportScheduleDay,
 		contextRow.HouseType,
-		percentByHouseType,
+		multiplicationByHouseType,
 	)
-	if depreciationValue <= 0 {
+	if depreciationValue <= 0 && pulletCostDayN <= 0 {
 		return nil, nil
 	}
+	totalValueAfter := pulletCostDayN * multiplicationPercentage
+	depreciationPercent := (1.0 - multiplicationPercentage) * 100.0
+	_ = totalPulletCost
+
+	var standardEffectiveDate string
+	if ed, ok := effectiveDates[houseType]; ok && ed != nil {
+		standardEffectiveDate = formatDateOnly(*ed)
+	}
 
 	return &HppV2ComponentPart{
 		Code:   hppV2PartDepreciationCutover,
@@ -1449,15 +1529,21 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 		Scopes: []string{hppV2ScopeProductionCost},
 		Total:  depreciationValue,
 		Details: map[string]any{
-			"basis_total":           totalPulletCost,
-			"pullet_cost_day_n":     pulletCostDayN,
-			"depreciation_percent":  depreciationPercent,
-			"schedule_day":          reportScheduleDay,
-			"start_schedule_day":    startDay,
-			"origin_date":           formatDateOnly(*originDate),
-			"cutover_date":          formatDateOnly(manualInput.CutoverDate),
-			"manual_input_id":       manualInput.ID,
-			"project_flock_kandang": projectFlockKandangId,
+			"basis_total":                           basis,
+			"manual_input_total":                    manualInput.TotalCost,
+			"population_share":                      populationShare,
+			"pullet_cost_day_n":                     pulletCostDayN,
+			"multiplication_percentage":             multiplicationPercentage,
+			"total_value_pullet_after_depreciation": totalValueAfter,
+			"depreciation_percent":                  depreciationPercent,
+			"schedule_day":                          reportScheduleDay,
+			"start_schedule_day":                    startDay,
+			"origin_date":                           formatDateOnly(*originDate),
+			"cutover_date":                          formatDateOnly(manualInput.CutoverDate),
+			"manual_input_id":                       manualInput.ID,
+			"project_flock_kandang":                 projectFlockKandangId,
+			"standard_effective_date":               standardEffectiveDate,
+			"kandang_population":                    kandangPopulation,
 		},
 		References: []HppV2Reference{
 			{
@@ -1465,7 +1551,7 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 				ID:           manualInput.ID,
 				Date:         formatDateOnly(manualInput.CutoverDate),
 				Qty:          1,
-				Total:        totalPulletCost,
+				Total:        manualInput.TotalCost,
 				AppliedTotal: depreciationValue,
 			},
 		},
@@ -1724,7 +1810,7 @@ func partHasScope(part *HppV2ComponentPart, scope string) bool {
 }
 
 func dateOnly(value time.Time) time.Time {
-	return time.Date(value.Year(), value.Month(), value.Day(), 0, 0, 0, 0, value.Location())
+	return time.Date(value.Year(), value.Month(), value.Day(), 0, 0, 0, 0, time.UTC)
 }
 
 func formatDateOnly(value time.Time) string {

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

@@ -57,6 +57,14 @@ func (s *hppV2RepoStub) GetLatestTransferInputByProjectFlockKandangID(_ context.
 	return s.latestTransferByPFK[projectFlockKandangId], nil
 }
 
+func (s *hppV2RepoStub) GetAllTransferInputsByProjectFlockKandangID(_ context.Context, projectFlockKandangId uint, _ time.Time) ([]commonRepo.HppV2LatestTransferInputRow, error) {
+	row := s.latestTransferByPFK[projectFlockKandangId]
+	if row == nil {
+		return []commonRepo.HppV2LatestTransferInputRow{}, nil
+	}
+	return []commonRepo.HppV2LatestTransferInputRow{*row}, nil
+}
+
 func (s *hppV2RepoStub) GetManualDepreciationInputByProjectFlockID(_ context.Context, projectFlockID uint) (*commonRepo.HppV2ManualDepreciationInputRow, error) {
 	return s.manualInputByProject[projectFlockID], nil
 }
@@ -93,6 +101,19 @@ func (s *hppV2RepoStub) GetDepreciationPercents(_ context.Context, houseTypes []
 	return result, nil
 }
 
+// GetMultiplicationPercentages — alias yang sama dengan GetDepreciationPercents untuk match
+// interface HppV2CostRepository (interface dipakai method name baru ini).
+func (s *hppV2RepoStub) GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, map[string]*time.Time, error) {
+	vals, err := s.GetDepreciationPercents(ctx, houseTypes, maxDay)
+	return vals, make(map[string]*time.Time), err
+}
+
+// GetChickinPopulationByPFKForFarm — return populasi per PFK dari satu project flock.
+// Stub minimal: return empty map (depreciation manual cutover tidak di-test di sini).
+func (s *hppV2RepoStub) GetChickinPopulationByPFKForFarm(_ context.Context, _ uint) (map[uint]float64, error) {
+	return map[uint]float64{}, nil
+}
+
 func (s *hppV2RepoStub) ListUsageCostRowsByProductFlags(_ context.Context, projectFlockKandangIDs []uint, flagNames []string, _ *time.Time) ([]commonRepo.HppV2UsageCostRow, error) {
 	return append([]commonRepo.HppV2UsageCostRow{}, s.usageRowsByKey[stubKey(projectFlockKandangIDs, flagNames)]...), nil
 }

internal/common/service/fifo_stock_v2/population_allocation.go

@@ -45,7 +45,16 @@ func ReleasePopulationConsumptionByUsable(
 		}
 	}
 
-	return stockAllocationRepo.ReleaseByUsable(ctx, usableType, usableID, nil, nil)
+	// Only release the PROJECT_FLOCK_POPULATION allocations here. Releasing the
+	// other CONSUME allocations of this usable (RECORDING_EGG, STOCK_TRANSFER_IN,
+	// PURCHASE_ITEMS, etc.) would orphan their stockable total_used because this
+	// path only restores total_used_qty for population lots — leaving the FIFO
+	// stock counters permanently inflated (phantom stock). Those stock
+	// allocations are owned by the FIFO Reflow/Rollback path, which decrements
+	// total_used correctly via adjustStockableUsedQuantity.
+	return stockAllocationRepo.ReleaseByUsable(ctx, usableType, usableID, nil, func(db *gorm.DB) *gorm.DB {
+		return db.Where("stockable_type = ?", fifo.StockableKeyProjectFlockPopulation.String())
+	})
 }
 
 func AllocatePopulationConsumption(

internal/config/config.go

@@ -121,9 +121,12 @@ func init() {
 	// Redis
 	RedisURL = viper.GetString("REDIS_URL")
 
+	// TransferToLayingGrowingMaxWeek: batas umur (minggu dari chick_in) yang masih boleh ditransfer ke laying.
+	// Disatukan dengan depreciation_start_age_day = 175 hari = 25 minggu, agar konsisten antara batas transfer
+	// dan kapan depresiasi mulai berjalan.
 	TransferToLayingGrowingMaxWeek = viper.GetInt("TRANSFER_TO_LAYING_GROWING_MAX_WEEK")
 	if TransferToLayingGrowingMaxWeek <= 0 {
-		TransferToLayingGrowingMaxWeek = 19
+		TransferToLayingGrowingMaxWeek = 25
 	}
 
 	// Object storage

internal/database/migrations/20260522113148_fix_adjustment_stock_532_price.down.sql

@@ -0,0 +1,4 @@
+UPDATE adjustment_stocks
+SET price = 9535,
+    grand_total = ROUND(8700 * 9535, 3)
+WHERE id = 532 AND adj_number = 'ADJ-00507';

internal/database/migrations/20260522113148_fix_adjustment_stock_532_price.up.sql

@@ -0,0 +1,5 @@
+
+UPDATE adjustment_stocks
+SET price = 12635,
+    grand_total = ROUND(8700 * 12635, 3)
+WHERE id = 532 AND adj_number = 'ADJ-00507';

internal/database/migrations/20260523035647_consolidate_pullet_cikaum_locations.down.sql

@@ -0,0 +1,31 @@
+BEGIN;
+
+-- Rollback konsolidasi: kembalikan data ke loc 18 / 25 sesuai snapshot pre-migration.
+-- Order: un-soft-delete locations dulu agar FK tidak gagal saat UPDATE child.
+
+-- 1. Un-soft-delete locations
+UPDATE locations SET deleted_at = NULL WHERE id IN (18, 25);
+
+-- 2. project_flocks: PF 30 -> 18, PF 25 & 31 -> 25
+UPDATE project_flocks SET location_id = 18, updated_at = NOW() WHERE id = 30;
+UPDATE project_flocks SET location_id = 25, updated_at = NOW() WHERE id IN (25, 31);
+
+-- 3. kandangs: K9, K72, K117 -> 18; K10, K73, K116 -> 25
+UPDATE kandangs SET location_id = 18, updated_at = NOW() WHERE id IN (9, 72, 117);
+UPDATE kandangs SET location_id = 25, updated_at = NOW() WHERE id IN (10, 73, 116);
+
+-- 4. kandang_groups: KG 26, 68 -> 18; KG 27, 67 -> 25
+UPDATE kandang_groups SET location_id = 18, updated_at = NOW() WHERE id IN (26, 68);
+UPDATE kandang_groups SET location_id = 25, updated_at = NOW() WHERE id IN (27, 67);
+
+-- 5. warehouses: W27, W145, W152 -> 18; W3, W146, W153 -> 25
+UPDATE warehouses SET location_id = 18, updated_at = NOW() WHERE id IN (27, 145, 152);
+UPDATE warehouses SET location_id = 25, updated_at = NOW() WHERE id IN (3, 146, 153);
+
+-- 6. expenses: list eksplisit per location
+UPDATE expenses SET location_id = 18, updated_at = NOW()
+WHERE id IN (36, 345, 500, 501, 502, 503, 504, 505, 506, 507, 508);
+UPDATE expenses SET location_id = 25, updated_at = NOW()
+WHERE id IN (9, 37, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518);
+
+COMMIT;

internal/database/migrations/20260523035647_consolidate_pullet_cikaum_locations.up.sql

@@ -0,0 +1,34 @@
+BEGIN;
+
+-- Konsolidasi 3 lokasi "Pullet Cikaum" jadi 1.
+-- Pindahkan semua data di loc 18 (Pullet Cikaum 1) & 25 (Pullet Cikaum 2) ke loc 2 (Pullet Cikaum).
+-- Urutan wajib: semua UPDATE child harus selesai SEBELUM soft-delete locations,
+-- karena trigger trg_soft_delete_fk_locations akan RAISE EXCEPTION untuk FK
+-- RESTRICT (project_flocks, kandangs, kandang_groups, expenses) atau SET NULL
+-- untuk warehouses kalau masih ada child yang reference.
+
+-- 1. project_flocks (PF 25, 30, 31)
+UPDATE project_flocks SET location_id = 2, updated_at = NOW()
+WHERE location_id IN (18, 25);
+
+-- 2. kandangs (K9, K72, K117, K10, K73, K116)
+UPDATE kandangs SET location_id = 2, updated_at = NOW()
+WHERE location_id IN (18, 25);
+
+-- 3. kandang_groups (KG 26, 68, 27, 67)
+UPDATE kandang_groups SET location_id = 2, updated_at = NOW()
+WHERE location_id IN (18, 25);
+
+-- 4. warehouses (W3, W27, W145, W146, W152, W153)
+UPDATE warehouses SET location_id = 2, updated_at = NOW()
+WHERE location_id IN (18, 25);
+
+-- 5. expenses (23 row BOP)
+UPDATE expenses SET location_id = 2, updated_at = NOW()
+WHERE location_id IN (18, 25);
+
+-- 6. Soft-delete locations 18 & 25 (kosong, aman karena semua child sudah pindah)
+UPDATE locations SET deleted_at = NOW()
+WHERE id IN (18, 25) AND deleted_at IS NULL;
+
+COMMIT;

internal/database/migrations/20260528121631_normalize_warehouse_jamali_10_to_25.down.sql

@@ -0,0 +1,99 @@
+BEGIN;
+
+-- ============================================================
+-- Rollback dynamic via audit snapshots di schema `migration_audit.jamali_w10_*`.
+-- Semua reverse dibaca dari snapshot yang dibuat oleh UP migration —
+-- tidak ada IDs/qty yang hardcode. Robust terhadap data drift antara
+-- dump time dan UP apply time (misalnya row baru warehouse_id=10
+-- yang muncul setelah dump diambil).
+--
+-- LIMITASI: FK relinks di stock_logs / stock_allocations / recording_eggs /
+-- marketing_products / dll. TIDAK direverse di sini (skip audit per-row
+-- untuk hemat storage ~40MB). Setelah down, 9 PW W10 yang di-restore
+-- akan kosong dari child rows (semua child masih pointing ke W25 PW
+-- yang sebelumnya menerima merge). Untuk rollback penuh, restore DB
+-- dari backup pre-migration.
+-- ============================================================
+
+-- Guard: pastikan audit tables ada (kalau tidak, fail-loud)
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM information_schema.tables
+    WHERE table_schema = 'migration_audit'
+      AND table_name = 'jamali_w10_pw_deleted_snapshot'
+  ) THEN
+    RAISE EXCEPTION 'Audit table migration_audit.jamali_w10_* tidak ditemukan. UP migration belum dijalankan atau audit sudah di-drop. Restore dari DB backup jika perlu.';
+  END IF;
+END $$;
+
+-- 1. Un-soft-delete warehouse 10 (kalau memang di-softdelete oleh UP)
+UPDATE warehouses w
+SET deleted_at = NULL, updated_at = NOW()
+FROM migration_audit.jamali_w10_warehouse_softdeleted a
+WHERE w.id = a.id;
+
+-- 2. Un-soft-delete stock_transfers self-loop yang disoft-delete UP step 7.1
+UPDATE stock_transfers st
+SET deleted_at = NULL, updated_at = NOW()
+FROM migration_audit.jamali_w10_st_softdeleted a
+WHERE st.id = a.id;
+
+-- 3. Reverse stock_transfers redirect (CASE-based dari snapshot was_from_w10/was_to_w10)
+UPDATE stock_transfers st
+SET from_warehouse_id = CASE WHEN a.was_from_w10 THEN 10 ELSE st.from_warehouse_id END,
+    to_warehouse_id   = CASE WHEN a.was_to_w10   THEN 10 ELSE st.to_warehouse_id   END,
+    updated_at = NOW()
+FROM migration_audit.jamali_w10_st_redirected a
+WHERE st.id = a.id;
+
+-- 3b. Self-loop transfers (W10<->W25 awal) juga punya from_warehouse_id=25 atau
+-- to_warehouse_id=25 setelah UP step 7.2. Karena snapshot jamali_w10_st_softdeleted
+-- punya kolom from_warehouse_id & to_warehouse_id asli, pakai itu untuk reverse.
+UPDATE stock_transfers st
+SET from_warehouse_id = 10, updated_at = NOW()
+FROM migration_audit.jamali_w10_st_softdeleted a
+WHERE st.id = a.id AND a.from_warehouse_id = 10;
+
+UPDATE stock_transfers st
+SET to_warehouse_id = 10, updated_at = NOW()
+FROM migration_audit.jamali_w10_st_softdeleted a
+WHERE st.id = a.id AND a.to_warehouse_id = 10;
+
+-- 4. Reverse purchase_items.warehouse_id 25 -> 10
+UPDATE purchase_items
+SET warehouse_id = 10
+WHERE id IN (SELECT id FROM migration_audit.jamali_w10_purchase_items);
+
+-- 5. Reverse W10-only PW (warehouse_id 25 -> 10, restore pfk asli dari snapshot)
+UPDATE product_warehouses pw
+SET warehouse_id = 10, project_flock_kandang_id = a.original_pfk
+FROM migration_audit.jamali_w10_pw_w10only_snapshot a
+WHERE pw.id = a.id;
+
+-- 6. Subtract qty dari W25 PW (reverse merge)
+-- WARNING: kalau W25 qty sudah dikonsumsi pasca-UP (sales/recording/dll),
+-- hasil bisa negatif. Tidak ada CHECK constraint di product_warehouses.qty,
+-- jadi silent. Operator harus verifikasi manual post-down:
+--   SELECT id, qty FROM product_warehouses WHERE qty < 0;
+UPDATE product_warehouses pw
+SET qty = pw.qty - a.merged_qty
+FROM migration_audit.jamali_w10_qty_merge a
+WHERE pw.id = a.target_pw_id;
+
+-- 7. Re-INSERT 9 W10 PW rows yang di-DELETE oleh UP (PK asli + qty asli)
+INSERT INTO product_warehouses (id, product_id, warehouse_id, qty, project_flock_kandang_id)
+SELECT id, product_id, 10, qty, project_flock_kandang_id
+FROM migration_audit.jamali_w10_pw_deleted_snapshot;
+
+-- 8. Cleanup audit tables (drop satu per satu, tidak wildcard untuk safety)
+DROP TABLE migration_audit.jamali_w10_pw_deleted_snapshot;
+DROP TABLE migration_audit.jamali_w10_qty_merge;
+DROP TABLE migration_audit.jamali_w10_pw_w10only_snapshot;
+DROP TABLE migration_audit.jamali_w10_st_softdeleted;
+DROP TABLE migration_audit.jamali_w10_st_redirected;
+DROP TABLE migration_audit.jamali_w10_purchase_items;
+DROP TABLE migration_audit.jamali_w10_warehouse_softdeleted;
+-- Schema migration_audit dipertahankan (bisa dipakai migration lain di masa depan)
+
+COMMIT;

internal/database/migrations/20260528121631_normalize_warehouse_jamali_10_to_25.up.sql

@@ -0,0 +1,241 @@
+BEGIN;
+
+-- ============================================================
+-- Normalisasi warehouse 10 (Jamali NON_AKTIF) -> 25 (Gudang Farm Jamali)
+-- Background: Dua warehouse LOKASI di area & lokasi sama (area_id=6,
+-- location_id=16). W10 sudah ditandai NON_AKTIF tapi masih punya 13
+-- product_warehouses, 3,590 stock_logs, ~790K stock_allocations,
+-- 332 marketing_products, 17 purchase_items, dan 14 stock_transfers.
+-- Migration ini konsolidasikan semua relasi ke W25 lalu soft-delete W10.
+--
+-- Klasifikasi data:
+-- A. 9 product_warehouses W10 overlap dengan W25 (sama product_id, pfk=NULL)
+--    -> merge qty ke W25, relink semua FK ke product_warehouses.id,
+--       lalu DELETE W10 PW rows.
+-- B. 4 product_warehouses W10-only -> UPDATE warehouse_id=25.
+--    Rows 1188/1189/1190 punya pfk=98 (anomali LOKASI, seharusnya NULL
+--    per aturan di CLAUDE.md [2026-05-06]) -> normalisasi sekalian.
+-- C. 17 purchase_items.warehouse_id=10 -> UPDATE 25 (no unique conflict).
+-- D. 3 stock_transfers W10<->W25 (PND-LTI-00107/00109/00119) akan jadi
+--    self-loop W25<->W25 setelah merge -> soft-delete.
+-- E. 12 stock_transfers EGG_FARM_CUTOVER to_warehouse_id=10 -> UPDATE 25.
+-- F. warehouse_id=10 sendiri -> soft-delete.
+--
+-- UP membuat 7 snapshot table di schema `migration_audit.jamali_w10_*`
+-- sebelum mutasi. DOWN baca snapshot itu untuk reverse dynamic (tidak
+-- hardcode IDs/qty), sehingga apapun yang ada di production saat UP
+-- dijalankan akan ter-audit dan ter-reverse. FK relinks
+-- (stock_logs/stock_allocations/dll) TIDAK di-audit (storage ~40MB)
+-- — limitation: tidak bisa di-reverse DOWN, full rollback = DB backup.
+-- ============================================================
+
+-- STEP -1: Buat schema audit + snapshot tables (idempotent rerun via DROP IF EXISTS)
+CREATE SCHEMA IF NOT EXISTS migration_audit;
+
+DROP TABLE IF EXISTS migration_audit.jamali_w10_pw_deleted_snapshot;
+DROP TABLE IF EXISTS migration_audit.jamali_w10_qty_merge;
+DROP TABLE IF EXISTS migration_audit.jamali_w10_pw_w10only_snapshot;
+DROP TABLE IF EXISTS migration_audit.jamali_w10_st_softdeleted;
+DROP TABLE IF EXISTS migration_audit.jamali_w10_st_redirected;
+DROP TABLE IF EXISTS migration_audit.jamali_w10_purchase_items;
+DROP TABLE IF EXISTS migration_audit.jamali_w10_warehouse_softdeleted;
+
+-- Snapshot 9 W10 PW yang akan di-DELETE (overlap dgn W25, pfk=NULL)
+CREATE TABLE migration_audit.jamali_w10_pw_deleted_snapshot AS
+SELECT pw10.id, pw10.product_id, pw10.qty, pw10.project_flock_kandang_id
+FROM product_warehouses pw10
+JOIN product_warehouses pw25
+  ON pw25.product_id = pw10.product_id
+ AND pw25.warehouse_id = 25
+ AND pw25.project_flock_kandang_id IS NULL
+WHERE pw10.warehouse_id = 10 AND pw10.project_flock_kandang_id IS NULL;
+
+-- Snapshot qty delta per W25 target (untuk reverse subtract)
+CREATE TABLE migration_audit.jamali_w10_qty_merge AS
+SELECT pw25.id AS target_pw_id, pw10.id AS source_pw_id, pw10.qty AS merged_qty
+FROM product_warehouses pw10
+JOIN product_warehouses pw25
+  ON pw25.product_id = pw10.product_id
+ AND pw25.warehouse_id = 25
+ AND pw25.project_flock_kandang_id IS NULL
+WHERE pw10.warehouse_id = 10 AND pw10.project_flock_kandang_id IS NULL;
+
+-- Snapshot W10-only PW (yang akan di-UPDATE warehouse_id 10->25)
+CREATE TABLE migration_audit.jamali_w10_pw_w10only_snapshot AS
+SELECT pw10.id, pw10.project_flock_kandang_id AS original_pfk
+FROM product_warehouses pw10
+WHERE pw10.warehouse_id = 10
+  AND pw10.id NOT IN (SELECT id FROM migration_audit.jamali_w10_pw_deleted_snapshot);
+
+-- Snapshot stock_transfers yang akan di-soft-delete (self-loop W10<->W25)
+-- Simpan from/to_warehouse_id asli supaya DOWN bisa reverse direction tepat
+CREATE TABLE migration_audit.jamali_w10_st_softdeleted AS
+SELECT id, movement_number, from_warehouse_id, to_warehouse_id
+FROM stock_transfers
+WHERE deleted_at IS NULL
+  AND ((from_warehouse_id = 10 AND to_warehouse_id = 25)
+    OR (from_warehouse_id = 25 AND to_warehouse_id = 10));
+
+-- Snapshot stock_transfers yang akan di-UPDATE (W10<->other, bukan self-loop)
+CREATE TABLE migration_audit.jamali_w10_st_redirected AS
+SELECT id,
+       (from_warehouse_id = 10) AS was_from_w10,
+       (to_warehouse_id = 10)   AS was_to_w10
+FROM stock_transfers
+WHERE deleted_at IS NULL
+  AND (from_warehouse_id = 10 OR to_warehouse_id = 10)
+  AND id NOT IN (SELECT id FROM migration_audit.jamali_w10_st_softdeleted);
+
+-- Snapshot purchase_items IDs (cheap, ~17 rows)
+CREATE TABLE migration_audit.jamali_w10_purchase_items AS
+SELECT id FROM purchase_items WHERE warehouse_id = 10;
+
+-- Snapshot warehouses soft-delete flag (1 row, kalau memang masih aktif)
+CREATE TABLE migration_audit.jamali_w10_warehouse_softdeleted AS
+SELECT id FROM warehouses WHERE id = 10 AND deleted_at IS NULL;
+
+-- STEP 0: Pre-check sanity (idempotent guards)
+DO $$
+DECLARE v_count INT;
+BEGIN
+  SELECT COUNT(*) INTO v_count FROM warehouses
+  WHERE id IN (10, 25) AND type = 'LOKASI' AND area_id = 6 AND location_id = 16;
+  IF v_count <> 2 THEN
+    RAISE EXCEPTION 'Pre-check: warehouse 10/25 schema mismatch (got % rows)', v_count;
+  END IF;
+
+  SELECT COUNT(*) INTO v_count FROM purchase_items a
+  JOIN purchase_items b ON a.purchase_id = b.purchase_id
+    AND a.product_id = b.product_id
+    AND a.id <> b.id
+  WHERE a.warehouse_id = 10 AND b.warehouse_id = 25;
+  IF v_count > 0 THEN
+    RAISE EXCEPTION 'Pre-check: % purchase_items unique conflict (purchase_id,product_id)', v_count;
+  END IF;
+END $$;
+
+-- STEP 1: Merge qty W10 -> W25 untuk overlap (pfk=NULL)
+UPDATE product_warehouses pw25
+SET qty = pw25.qty + pw10.qty
+FROM product_warehouses pw10
+WHERE pw10.warehouse_id = 10 AND pw10.project_flock_kandang_id IS NULL
+  AND pw25.warehouse_id = 25 AND pw25.project_flock_kandang_id IS NULL
+  AND pw25.product_id = pw10.product_id;
+
+-- STEP 2: Build temp mapping (W10 PW id -> W25 PW id) untuk overlap saja
+CREATE TEMP TABLE _pw_map ON COMMIT DROP AS
+SELECT pw10.id AS old_id, pw25.id AS new_id
+FROM product_warehouses pw10
+JOIN product_warehouses pw25
+  ON pw25.product_id = pw10.product_id
+ AND pw25.warehouse_id = 25
+ AND pw25.project_flock_kandang_id IS NULL
+WHERE pw10.warehouse_id = 10 AND pw10.project_flock_kandang_id IS NULL;
+
+CREATE INDEX ON _pw_map(old_id);
+
+-- STEP 3: Relink semua FK ke product_warehouses.id (hanya rows di _pw_map)
+UPDATE stock_logs SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE stock_logs.product_warehouse_id = m.old_id;
+
+UPDATE stock_allocations SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE stock_allocations.product_warehouse_id = m.old_id;
+
+UPDATE recording_eggs SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE recording_eggs.product_warehouse_id = m.old_id;
+
+UPDATE recording_stocks SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE recording_stocks.product_warehouse_id = m.old_id;
+
+UPDATE recording_depletions SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE recording_depletions.product_warehouse_id = m.old_id;
+UPDATE recording_depletions SET source_product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE recording_depletions.source_product_warehouse_id = m.old_id;
+
+UPDATE adjustment_stocks SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE adjustment_stocks.product_warehouse_id = m.old_id;
+
+UPDATE marketing_products SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE marketing_products.product_warehouse_id = m.old_id;
+
+UPDATE marketing_delivery_products SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE marketing_delivery_products.product_warehouse_id = m.old_id;
+
+UPDATE project_chickins SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE project_chickins.product_warehouse_id = m.old_id;
+
+UPDATE project_chickin_details SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE project_chickin_details.product_warehouse_id = m.old_id;
+
+UPDATE project_flock_populations SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE project_flock_populations.product_warehouse_id = m.old_id;
+
+UPDATE laying_transfers SET source_product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE laying_transfers.source_product_warehouse_id = m.old_id;
+
+UPDATE laying_transfer_sources SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE laying_transfer_sources.product_warehouse_id = m.old_id;
+
+UPDATE laying_transfer_targets SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE laying_transfer_targets.product_warehouse_id = m.old_id;
+
+UPDATE stock_transfer_details SET source_product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE stock_transfer_details.source_product_warehouse_id = m.old_id;
+UPDATE stock_transfer_details SET dest_product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE stock_transfer_details.dest_product_warehouse_id = m.old_id;
+
+UPDATE purchase_items SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE purchase_items.product_warehouse_id = m.old_id;
+
+-- FIFO v2 tables (kosong di dump 2026-05-25, defensive)
+UPDATE fifo_stock_v2_operation_log SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE fifo_stock_v2_operation_log.product_warehouse_id = m.old_id;
+UPDATE fifo_stock_v2_reflow_checkpoints SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE fifo_stock_v2_reflow_checkpoints.product_warehouse_id = m.old_id;
+UPDATE fifo_stock_v2_shadow_allocations SET product_warehouse_id = m.new_id
+  FROM _pw_map m WHERE fifo_stock_v2_shadow_allocations.product_warehouse_id = m.old_id;
+
+-- STEP 4: Hard-delete W10 PW yang sudah merged (9 rows expected)
+DELETE FROM product_warehouses WHERE id IN (SELECT old_id FROM _pw_map);
+
+-- STEP 5: Sisa W10 PW (4 rows: 1188/1189/1190/1196) -> warehouse_id=25,
+-- pfk dinormalisasi ke NULL sekalian (LOKASI rule)
+UPDATE product_warehouses
+SET warehouse_id = 25, project_flock_kandang_id = NULL
+WHERE warehouse_id = 10;
+
+-- STEP 6: purchase_items.warehouse_id (17 rows)
+UPDATE purchase_items SET warehouse_id = 25 WHERE warehouse_id = 10;
+
+-- STEP 7: stock_transfers
+-- 7.1 Soft-delete self-loop (W10<->W25 akan jadi W25<->W25)
+UPDATE stock_transfers
+SET deleted_at = NOW(), updated_at = NOW()
+WHERE deleted_at IS NULL
+  AND ((from_warehouse_id = 10 AND to_warehouse_id = 25)
+    OR (from_warehouse_id = 25 AND to_warehouse_id = 10));
+
+-- 7.2 Sisa W10<->other -> 25 (12 EGG_FARM_CUTOVER ke W10)
+UPDATE stock_transfers SET from_warehouse_id = 25, updated_at = NOW() WHERE from_warehouse_id = 10;
+UPDATE stock_transfers SET to_warehouse_id = 25, updated_at = NOW() WHERE to_warehouse_id = 10;
+
+-- STEP 8: Soft-delete warehouse 10 sendiri
+UPDATE warehouses SET deleted_at = NOW(), updated_at = NOW()
+WHERE id = 10 AND deleted_at IS NULL;
+
+-- STEP 9: Post-check (fail-fast jika ada residu)
+DO $$
+DECLARE v_count INT;
+BEGIN
+  SELECT COUNT(*) INTO v_count FROM product_warehouses WHERE warehouse_id = 10;
+  IF v_count <> 0 THEN RAISE EXCEPTION 'product_warehouses W10 residual %', v_count; END IF;
+
+  SELECT COUNT(*) INTO v_count FROM purchase_items WHERE warehouse_id = 10;
+  IF v_count <> 0 THEN RAISE EXCEPTION 'purchase_items W10 residual %', v_count; END IF;
+
+  SELECT COUNT(*) INTO v_count FROM stock_transfers
+  WHERE deleted_at IS NULL AND (from_warehouse_id = 10 OR to_warehouse_id = 10);
+  IF v_count <> 0 THEN RAISE EXCEPTION 'stock_transfers W10 residual %', v_count; END IF;
+END $$;
+
+COMMIT;

internal/database/migrations/20260528123243_fix_stock_log_drift_jamali_merge.down.sql

@@ -0,0 +1,29 @@
+BEGIN;
+
+-- ============================================================
+-- Rollback stock_log drift fix: DELETE corrective rows yang di-insert UP.
+-- IDs ditarik dari audit table `migration_audit.jamali_w10_stocklog_corrections`.
+-- Setelah delete, `last_stock_log.stock` kembali ke nilai pre-fix (drift muncul lagi).
+-- ============================================================
+
+-- Guard: audit table harus ada
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM information_schema.tables
+    WHERE table_schema = 'migration_audit'
+      AND table_name = 'jamali_w10_stocklog_corrections'
+  ) THEN
+    RAISE EXCEPTION
+      'Audit table migration_audit.jamali_w10_stocklog_corrections tidak ditemukan. UP belum dijalankan atau audit sudah di-drop.';
+  END IF;
+END $$;
+
+-- DELETE corrective stock_logs yang di-insert oleh UP
+DELETE FROM stock_logs
+WHERE id IN (SELECT stock_log_id FROM migration_audit.jamali_w10_stocklog_corrections);
+
+-- Cleanup audit table
+DROP TABLE migration_audit.jamali_w10_stocklog_corrections;
+
+COMMIT;

internal/database/migrations/20260528123243_fix_stock_log_drift_jamali_merge.up.sql

@@ -0,0 +1,111 @@
+BEGIN;
+
+-- ============================================================
+-- Fix stock_log drift pasca-merge warehouse Jamali (NON_AKTIF) -> Gudang Farm Jamali.
+-- Follow-up migration setelah 20260528121631_normalize_warehouse_jamali_10_to_25.
+--
+-- Setelah merge, `stock_logs.stock` (running ledger) drift dari
+-- `product_warehouses.qty` karena: pre-existing drift di W10 + W25 sources,
+-- plus FIFO reflow yang trigger pasca-merge (Recording-Edit) recompute
+-- pw.qty tapi stock_logs tidak ikut update.
+--
+-- Migration ini insert 1 ADJUSTMENT stock_log corrective per PW yang drift
+-- supaya `last_stock_log.stock = pw.qty`. Logic ekivalen dengan
+-- `cmd/fix-stock-log-drift`.
+--
+-- Karakteristik dynamic:
+--   - Tidak hardcode PW IDs atau drift values
+--   - Iterate via merge target + W10-only kept PWs (data-driven dari snapshot)
+--   - Per PW: hitung drift runtime, skip kalau negligible (< 0.001) atau no logs
+--   - Track stock_log IDs yang di-insert untuk DOWN reverse
+-- ============================================================
+
+-- Guard: previous migration (normalisasi) audit harus ada
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM information_schema.tables
+    WHERE table_schema = 'migration_audit'
+      AND table_name = 'jamali_w10_qty_merge'
+  ) THEN
+    RAISE EXCEPTION
+      'Migration 20260528121631 (normalize_warehouse_jamali) belum dijalankan atau audit-nya sudah di-drop. Apply UP-nya dulu sebelum migration ini.';
+  END IF;
+END $$;
+
+-- Audit table untuk track stock_log IDs yang di-insert (untuk DOWN reverse)
+DROP TABLE IF EXISTS migration_audit.jamali_w10_stocklog_corrections;
+CREATE TABLE migration_audit.jamali_w10_stocklog_corrections (
+  stock_log_id BIGINT NOT NULL PRIMARY KEY,
+  product_warehouse_id BIGINT NOT NULL,
+  drift NUMERIC(15,3) NOT NULL,
+  inserted_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Insert corrective ADJUSTMENT stock_log untuk tiap PW yang drift
+DO $$
+DECLARE
+  rec RECORD;
+  v_last_log_stock NUMERIC(15,3);
+  v_drift NUMERIC(15,3);
+  v_new_log_id BIGINT;
+  v_inserts INT := 0;
+BEGIN
+  FOR rec IN (
+    SELECT pw.id AS pw_id, pw.qty AS qty
+    FROM product_warehouses pw
+    WHERE pw.id IN (
+      -- Merge target W25 PWs (9 rows)
+      SELECT target_pw_id FROM migration_audit.jamali_w10_qty_merge
+      UNION
+      -- W10-only PWs yang di-update warehouse_id 10->25 (4 rows)
+      SELECT id FROM migration_audit.jamali_w10_pw_w10only_snapshot
+    )
+  ) LOOP
+    -- Ambil stock akhir di stock_logs ledger
+    SELECT stock INTO v_last_log_stock
+    FROM stock_logs
+    WHERE product_warehouse_id = rec.pw_id
+    ORDER BY id DESC
+    LIMIT 1;
+
+    -- PW tanpa stock_logs entry (mis. 1188/1189/1190 ayam) -> skip
+    IF v_last_log_stock IS NULL THEN
+      CONTINUE;
+    END IF;
+
+    v_drift := rec.qty - v_last_log_stock;
+
+    -- Drift negligible -> skip
+    IF ABS(v_drift) < 0.001 THEN
+      CONTINUE;
+    END IF;
+
+    -- Insert corrective ADJUSTMENT stock_log
+    INSERT INTO stock_logs (
+      product_warehouse_id, loggable_type, loggable_id,
+      notes, increase, decrease, stock, created_by, created_at
+    ) VALUES (
+      rec.pw_id,
+      'ADJUSTMENT',
+      0,
+      'Koreksi stock_log drift pasca-merge warehouse Jamali (migration 20260528123243)',
+      CASE WHEN v_drift > 0 THEN v_drift ELSE 0 END,
+      CASE WHEN v_drift < 0 THEN -v_drift ELSE 0 END,
+      rec.qty,
+      1,
+      NOW()
+    ) RETURNING id INTO v_new_log_id;
+
+    -- Track ke audit table untuk DOWN
+    INSERT INTO migration_audit.jamali_w10_stocklog_corrections (
+      stock_log_id, product_warehouse_id, drift
+    ) VALUES (v_new_log_id, rec.pw_id, v_drift);
+
+    v_inserts := v_inserts + 1;
+  END LOOP;
+
+  RAISE NOTICE 'Inserted % corrective stock_logs to align ledger with pw.qty', v_inserts;
+END $$;
+
+COMMIT;

internal/database/migrations/20260528175508_add_grand_total_to_marketings_expenses.down.sql

@@ -0,0 +1,3 @@
+ALTER TABLE marketings DROP COLUMN IF EXISTS grand_total;
+ALTER TABLE expenses DROP COLUMN IF EXISTS grand_total;
+ALTER TABLE purchases DROP COLUMN IF EXISTS grand_total;

internal/database/migrations/20260528175508_add_grand_total_to_marketings_expenses.up.sql

@@ -0,0 +1,42 @@
+-- Marketing belum punya grand_total. Tambahkan dengan DEFAULT 0.
+ALTER TABLE marketings ADD COLUMN grand_total NUMERIC(15, 3) NOT NULL DEFAULT 0;
+
+-- Expense grand_total sebelumnya di-drop di migration 20251125055613. Re-add.
+ALTER TABLE expenses ADD COLUMN grand_total NUMERIC(15, 3) NOT NULL DEFAULT 0;
+
+ALTER TABLE purchases ADD COLUMN grand_total NUMERIC(15, 3) NOT NULL DEFAULT 0;
+
+-- Backfill nilai grand_total dari children:
+-- marketings.grand_total = SUM marketing_delivery_products.total_price (WHERE delivery_date IS NOT NULL)
+UPDATE marketings m
+SET grand_total = COALESCE(s.t, 0)
+FROM (
+    SELECT mp.marketing_id AS marketing_id, SUM(mdp.total_price) AS t
+    FROM marketing_delivery_products mdp
+    JOIN marketing_products mp ON mp.id = mdp.marketing_product_id
+    WHERE mdp.delivery_date IS NOT NULL
+    GROUP BY mp.marketing_id
+) s
+WHERE s.marketing_id = m.id;
+
+-- expenses.grand_total = SUM(expense_realizations.qty * expense_realizations.price) via expense_nonstocks
+UPDATE expenses e
+SET grand_total = COALESCE(s.t, 0)
+FROM (
+    SELECT en.expense_id AS expense_id, SUM(er.qty * er.price) AS t
+    FROM expense_realizations er
+    JOIN expense_nonstocks en ON en.id = er.expense_nonstock_id
+    GROUP BY en.expense_id
+) s
+WHERE s.expense_id = e.id;
+
+-- purchases.grand_total sudah ada sejak migration 20251104084555.
+-- Recompute juga untuk safety supaya konsisten dengan SUM purchase_items.total_price.
+UPDATE purchases p
+SET grand_total = COALESCE(s.t, 0)
+FROM (
+    SELECT purchase_id, SUM(total_price) AS t
+    FROM purchase_items
+    GROUP BY purchase_id
+) s
+WHERE s.purchase_id = p.id;

internal/database/migrations/20260528175642_create_payment_allocations.down.sql

@@ -0,0 +1,5 @@
+DROP INDEX IF EXISTS idx_payments_party_active;
+DROP INDEX IF EXISTS idx_mdp_delivery_date_partial;
+DROP INDEX IF EXISTS idx_purchase_items_received_date_partial;
+
+DROP TABLE IF EXISTS payment_allocations;

internal/database/migrations/20260528175642_create_payment_allocations.up.sql

@@ -0,0 +1,27 @@
+-- Tabel payment_allocations menyimpan hasil FIFO matching antara payment dengan
+-- sub-row anak (purchase_item / marketing_delivery_product / expense_realization).
+-- Setiap allocation row HARUS terhubung ke tepat 1 child via 3 nullable FK
+-- (polymorphic-via-multiple-nullable-FK; lebih aman dari single polymorphic kolom).
+CREATE TABLE IF NOT EXISTS payment_allocations (
+    id BIGSERIAL PRIMARY KEY,
+    payment_id BIGINT NOT NULL REFERENCES payments(id) ON DELETE CASCADE,
+    purchase_item_id BIGINT NULL REFERENCES purchase_items(id) ON DELETE CASCADE,
+    marketing_delivery_product_id BIGINT NULL REFERENCES marketing_delivery_products(id) ON DELETE CASCADE,
+    expense_realization_id BIGINT NULL REFERENCES expense_realizations(id) ON DELETE CASCADE,
+    amount NUMERIC(15, 3) NOT NULL CHECK (amount > 0),
+    allocated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    CONSTRAINT chk_payment_alloc_exactly_one CHECK (
+        num_nonnulls(purchase_item_id, marketing_delivery_product_id, expense_realization_id) = 1
+    )
+);
+
+CREATE INDEX IF NOT EXISTS idx_payment_alloc_payment ON payment_allocations (payment_id);
+CREATE INDEX IF NOT EXISTS idx_payment_alloc_purchase_item ON payment_allocations (purchase_item_id) WHERE purchase_item_id IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_payment_alloc_mdp ON payment_allocations (marketing_delivery_product_id) WHERE marketing_delivery_product_id IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_payment_alloc_realization ON payment_allocations (expense_realization_id) WHERE expense_realization_id IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_payment_alloc_allocated_at ON payment_allocations (allocated_at);
+
+-- Helper partial indexes untuk FIFO loop performance
+CREATE INDEX IF NOT EXISTS idx_purchase_items_received_date_partial ON purchase_items (received_date) WHERE received_date IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_mdp_delivery_date_partial ON marketing_delivery_products (delivery_date) WHERE delivery_date IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_payments_party_active ON payments (party_type, party_id, payment_date) WHERE deleted_at IS NULL;

internal/database/migrations/20260528175729_backfill_payment_allocations.down.sql

@@ -0,0 +1,4 @@
+-- Rollback backfill: hapus semua allocations dan drop function.
+TRUNCATE payment_allocations;
+
+DROP FUNCTION IF EXISTS fn_fifo_backfill_party(TEXT, BIGINT);

internal/database/migrations/20260528175729_backfill_payment_allocations.up.sql

@@ -0,0 +1,170 @@
+-- Backfill payment_allocations untuk data historis via FIFO simulation.
+-- Seluruh migration ini berjalan dalam 1 transaction (golang-migrate default).
+-- Jika ada party yang gagal di tengah loop, seluruh backfill ROLLBACK otomatis.
+
+-- Fungsi inti: FIFO greedy untuk 1 party (supplier/customer).
+-- Algoritma:
+--   1. Hapus payment_allocations existing untuk party tsb (idempotent).
+--   2. Kumpulkan eligible children sort by date ASC ke array (kind, id, amount, remaining).
+--   3. Konsumsi creditCarry (SUM payment SALDO_AWAL) ke children tertua — TIDAK insert allocation row.
+--   4. Loop payments (selain SALDO_AWAL) ORDER BY payment_date ASC: greedy alokasi ke child tertua dengan remaining > 0.
+--   5. Sisa nominal payment tidak insert row (otomatis credit balance untuk dokumen baru).
+CREATE OR REPLACE FUNCTION fn_fifo_backfill_party(
+    p_party_type TEXT,
+    p_party_id BIGINT
+) RETURNS VOID AS $func$
+DECLARE
+    v_party_type TEXT := UPPER(p_party_type);
+    v_payment RECORD;
+    v_child RECORD;
+    v_remaining NUMERIC(15, 3);
+    v_used NUMERIC(15, 3);
+    v_eps CONSTANT NUMERIC(15, 3) := 0.001;
+BEGIN
+    -- Acquire advisory lock untuk anti-race (1-arg form: hashtext returns int4, cast ke bigint)
+    PERFORM pg_advisory_xact_lock(hashtext('payment_alloc:' || v_party_type || ':' || p_party_id::text)::bigint);
+
+    -- Hapus allocations existing untuk party tsb (idempotent ulang-jalan)
+    DELETE FROM payment_allocations pa
+    USING payments p
+    WHERE pa.payment_id = p.id
+      AND p.party_type = v_party_type
+      AND p.party_id = p_party_id;
+
+    -- TEMP table untuk antrian children (sort sudah ada di INSERT...SELECT ORDER BY)
+    CREATE TEMP TABLE IF NOT EXISTS _children_queue (
+        seq BIGSERIAL PRIMARY KEY,
+        kind TEXT NOT NULL,           -- 'PURCHASE_ITEM' / 'MDP' / 'EXPENSE_REALIZATION'
+        child_id BIGINT NOT NULL,
+        amount NUMERIC(15, 3) NOT NULL,
+        remaining NUMERIC(15, 3) NOT NULL
+    ) ON COMMIT DROP;
+    TRUNCATE _children_queue;
+
+    IF v_party_type = 'SUPPLIER' THEN
+        -- purchase_items eligible: received_date IS NOT NULL, approval latest step >= 4 (Receiving), action != REJECTED
+        INSERT INTO _children_queue (kind, child_id, amount, remaining)
+        SELECT 'PURCHASE_ITEM', pi.id, pi.total_price, pi.total_price
+        FROM purchase_items pi
+        JOIN purchases p ON p.id = pi.purchase_id
+        JOIN LATERAL (
+            SELECT a.step_number, a.action
+            FROM approvals a
+            WHERE a.approvable_type = 'PURCHASES' AND a.approvable_id = p.id
+            ORDER BY a.action_at DESC, a.id DESC
+            LIMIT 1
+        ) la ON true
+        WHERE p.supplier_id = p_party_id
+          AND p.deleted_at IS NULL
+          AND pi.received_date IS NOT NULL
+          AND la.step_number >= 4
+          AND (la.action IS NULL OR la.action <> 'REJECTED')
+          AND pi.total_price > 0
+        ORDER BY pi.received_date ASC, pi.id ASC;
+
+        -- expense_realizations eligible: parent expense approval latest step >= 5 (Realisasi), action != REJECTED.
+        -- Sort pakai e.transaction_date supaya FIFO konsisten dengan tanggal yang di-display di report.
+        INSERT INTO _children_queue (kind, child_id, amount, remaining)
+        SELECT 'EXPENSE_REALIZATION', er.id, (er.qty * er.price), (er.qty * er.price)
+        FROM expense_realizations er
+        JOIN expense_nonstocks en ON en.id = er.expense_nonstock_id
+        JOIN expenses e ON e.id = en.expense_id
+        JOIN LATERAL (
+            SELECT a.step_number, a.action
+            FROM approvals a
+            WHERE a.approvable_type = 'EXPENSES' AND a.approvable_id = e.id
+            ORDER BY a.action_at DESC, a.id DESC
+            LIMIT 1
+        ) la ON true
+        WHERE e.supplier_id = p_party_id
+          AND e.deleted_at IS NULL
+          AND la.step_number >= 5
+          AND (la.action IS NULL OR la.action <> 'REJECTED')
+          AND (er.qty * er.price) > 0
+        ORDER BY e.transaction_date ASC, e.id ASC, er.id ASC;
+
+    ELSIF v_party_type = 'CUSTOMER' THEN
+        -- marketing_delivery_products eligible: delivery_date IS NOT NULL (match current report behavior, tidak filter approval)
+        INSERT INTO _children_queue (kind, child_id, amount, remaining)
+        SELECT 'MDP', mdp.id, mdp.total_price, mdp.total_price
+        FROM marketing_delivery_products mdp
+        JOIN marketing_products mp ON mp.id = mdp.marketing_product_id
+        JOIN marketings m ON m.id = mp.marketing_id
+        WHERE m.customer_id = p_party_id
+          AND m.deleted_at IS NULL
+          AND mdp.delivery_date IS NOT NULL
+          AND mdp.total_price > 0
+        ORDER BY mdp.delivery_date ASC, mdp.id ASC;
+    ELSE
+        RETURN;
+    END IF;
+
+    -- Skip jika tidak ada children eligible
+    IF NOT EXISTS (SELECT 1 FROM _children_queue) THEN
+        RETURN;
+    END IF;
+
+    -- Loop SEMUA payments termasuk SALDO_AWAL ORDER BY payment_date ASC, id ASC.
+    -- SALDO_AWAL diperlakukan sebagai payment tertua sehingga opening credit otomatis
+    -- consume oldest debts via FIFO. Tanpa allocation row, debt yang ter-cover SaldoAwal
+    -- akan tampak "Belum Lunas" di report.
+    FOR v_payment IN
+        SELECT id, nominal
+        FROM payments
+        WHERE party_type = v_party_type
+          AND party_id = p_party_id
+          AND deleted_at IS NULL
+          AND nominal > v_eps
+        ORDER BY payment_date ASC, id ASC
+    LOOP
+        v_remaining := v_payment.nominal;
+
+        -- Greedy alokasi ke children tertua dengan remaining > 0
+        FOR v_child IN
+            SELECT seq, kind, child_id, remaining
+            FROM _children_queue
+            WHERE remaining > v_eps
+            ORDER BY seq ASC
+        LOOP
+            EXIT WHEN v_remaining <= v_eps;
+
+            -- v_child.remaining is snapshot at cursor open; re-fetch latest to avoid drift in same payment iter
+            SELECT remaining INTO v_used FROM _children_queue WHERE seq = v_child.seq;
+            IF v_used <= v_eps THEN
+                CONTINUE;
+            END IF;
+
+            v_used := LEAST(v_remaining, v_used);
+            UPDATE _children_queue SET remaining = remaining - v_used WHERE seq = v_child.seq;
+            v_remaining := v_remaining - v_used;
+
+            IF v_child.kind = 'PURCHASE_ITEM' THEN
+                INSERT INTO payment_allocations (payment_id, purchase_item_id, amount, allocated_at)
+                VALUES (v_payment.id, v_child.child_id, v_used, NOW());
+            ELSIF v_child.kind = 'MDP' THEN
+                INSERT INTO payment_allocations (payment_id, marketing_delivery_product_id, amount, allocated_at)
+                VALUES (v_payment.id, v_child.child_id, v_used, NOW());
+            ELSIF v_child.kind = 'EXPENSE_REALIZATION' THEN
+                INSERT INTO payment_allocations (payment_id, expense_realization_id, amount, allocated_at)
+                VALUES (v_payment.id, v_child.child_id, v_used, NOW());
+            END IF;
+        END LOOP;
+    END LOOP;
+END;
+$func$ LANGUAGE plpgsql;
+
+-- Invoke per-party. Gagal di satu party → entire transaction ROLLBACK.
+DO $do$
+DECLARE
+    r RECORD;
+BEGIN
+    FOR r IN
+        SELECT DISTINCT party_type, party_id
+        FROM payments
+        WHERE deleted_at IS NULL
+          AND party_id IS NOT NULL
+    LOOP
+        PERFORM fn_fifo_backfill_party(r.party_type, r.party_id);
+    END LOOP;
+END;
+$do$;

internal/database/migrations/20260529085659_normalize_po_number_to_pr_pattern.down.sql

@@ -0,0 +1,8 @@
+-- IRREVERSIBLE migration: po_number lama (counter-based) tidak di-backup
+-- saat UP karena user secara eksplisit pilih "tanpa backup table".
+-- Down ini hanya raise notice supaya operator sadar harus restore dari
+-- DB-level backup terpisah kalau memang perlu rollback.
+DO $$
+BEGIN
+  RAISE NOTICE 'WARNING: Migration 20260529143940_normalize_po_number_to_pr_pattern is irreversible. Original counter-based PO numbers were not backed up. Restore from DB-level backup if rollback is required.';
+END $$;

internal/database/migrations/20260529085659_normalize_po_number_to_pr_pattern.up.sql

@@ -0,0 +1,87 @@
+BEGIN;
+
+-- ============================================================
+-- Normalize purchases.po_number agar mengikuti pr_number (swap prefix).
+-- Contoh: pr_number='PR-LTI-0050' -> po_number='PO-LTI-0050'
+--
+-- Konteks: sebelumnya pr_number dan po_number punya counter sequential
+-- terpisah (lihat purchase.repository.go NextPrNumber / NextPoNumber yang
+-- dihapus seiring migration ini), sehingga selalu diverge. Setelah
+-- perubahan code (ApproveManagerPurchase derive PO dari PR), historis
+-- perlu di-backfill supaya konsisten.
+--
+-- Juga update expenses.po_number (snapshot dari expense_bridge.go)
+-- supaya konsisten dengan purchases.
+--
+-- Constraint uq_purchases_po_number adalah NOT DEFERRABLE (per-row check),
+-- jadi single UPDATE bulk gagal di swap-conflict (contoh: row A mau jadi
+-- 'PO-LTI-0700' tapi row B masih punya 'PO-LTI-0700' -> error 23505).
+-- Solusi: capture target ke temp table, NULL dulu, baru set nilai derived.
+--
+-- IRREVERSIBLE: nilai po_number lama (counter-based) tidak di-backup.
+-- Kalau ada kegagalan di tengah, COMMIT tidak terjadi -> ROLLBACK otomatis.
+-- ============================================================
+
+-- 1. Capture target IDs (snapshot rencana update — sebelum perubahan apapun)
+CREATE TEMP TABLE _purchases_po_normalize_ids ON COMMIT DROP AS
+SELECT id
+FROM purchases
+WHERE po_number IS NOT NULL
+  AND pr_number LIKE 'PR-LTI-%'
+  AND po_number <> REPLACE(pr_number, 'PR-LTI-', 'PO-LTI-');
+
+-- 2. Update expenses DULU — join via current po_number masih valid sebelum step 3-4
+UPDATE expenses e
+SET po_number = REPLACE(p.pr_number, 'PR-LTI-', 'PO-LTI-')
+FROM purchases p
+JOIN _purchases_po_normalize_ids n ON n.id = p.id
+WHERE e.po_number = p.po_number
+  AND e.po_number IS NOT NULL
+  AND e.po_number <> '';
+
+-- 3. NULL-kan purchases.po_number untuk target — lepas constraint conflict
+UPDATE purchases
+SET po_number = NULL
+WHERE id IN (SELECT id FROM _purchases_po_normalize_ids);
+
+-- 4. Set nilai derived dari pr_number (sekarang aman karena slot lama sudah NULL)
+UPDATE purchases p
+SET po_number = REPLACE(p.pr_number, 'PR-LTI-', 'PO-LTI-')
+FROM _purchases_po_normalize_ids n
+WHERE p.id = n.id;
+
+-- 5. Sanity check — fail (auto-rollback) kalau masih ada mismatch
+DO $$
+DECLARE
+  v_mismatch_purchases INT;
+  v_mismatch_expenses INT;
+  v_target_count INT;
+BEGIN
+  SELECT COUNT(*) INTO v_target_count FROM _purchases_po_normalize_ids;
+
+  SELECT COUNT(*) INTO v_mismatch_purchases
+  FROM purchases
+  WHERE po_number IS NOT NULL
+    AND pr_number LIKE 'PR-LTI-%'
+    AND po_number <> REPLACE(pr_number, 'PR-LTI-', 'PO-LTI-');
+
+  IF v_mismatch_purchases > 0 THEN
+    RAISE EXCEPTION 'Normalize failed: % purchases rows still have mismatched po_number', v_mismatch_purchases;
+  END IF;
+
+  SELECT COUNT(*) INTO v_mismatch_expenses
+  FROM expenses e
+  JOIN purchases p ON e.po_number = p.po_number
+  WHERE p.pr_number LIKE 'PR-LTI-%'
+    AND e.po_number IS NOT NULL
+    AND e.po_number <> ''
+    AND e.po_number <> REPLACE(p.pr_number, 'PR-LTI-', 'PO-LTI-');
+
+  IF v_mismatch_expenses > 0 THEN
+    RAISE EXCEPTION 'Normalize failed: % expenses rows still have mismatched po_number', v_mismatch_expenses;
+  END IF;
+
+  RAISE NOTICE 'Normalize complete: % purchases rows updated', v_target_count;
+END $$;
+
+COMMIT;

internal/database/migrations/20260529144454_unify_close_house_depreciation_standard.down.sql

@@ -0,0 +1,17 @@
+-- Hapus open_house dan close_house rows dengan effective_date baru
+DELETE FROM house_depreciation_standards
+WHERE house_type IN ('open_house', 'close_house') AND effective_date = '2026-05-29';
+
+-- Hapus kolom multiplication_percentage
+ALTER TABLE house_depreciation_standards DROP COLUMN multiplication_percentage;
+
+-- Invalidate snapshot cache
+DELETE FROM farm_depreciation_snapshots;
+
+-- Kembalikan unique constraint lama
+ALTER TABLE house_depreciation_standards
+    DROP CONSTRAINT house_depreciation_standards_house_type_day_eff_unique;
+
+ALTER TABLE house_depreciation_standards
+    ADD CONSTRAINT house_depreciation_standards_house_type_day_unique
+    UNIQUE (house_type, day);

internal/database/migrations/20260529144454_unify_close_house_depreciation_standard.up.sql

@@ -0,0 +1,172 @@
+-- Drop unique constraint lama (house_type, day) agar bisa support multi effective_date
+ALTER TABLE house_depreciation_standards
+    DROP CONSTRAINT house_depreciation_standards_house_type_day_unique;
+
+-- Unique baru: (house_type, day, effective_date)
+-- NULL dianggap distinct di PostgreSQL → row lama (effective_date NULL) tidak konflik dengan row baru
+ALTER TABLE house_depreciation_standards
+    ADD CONSTRAINT house_depreciation_standards_house_type_day_eff_unique
+    UNIQUE (house_type, day, effective_date);
+
+-- Tambah kolom multiplication_percentage (nilai dari baris ke-3 Excel "Depresiasi 25 week.xlsx")
+ALTER TABLE house_depreciation_standards
+    ADD COLUMN multiplication_percentage numeric(20,15) NOT NULL DEFAULT 0;
+
+-- Isi multiplication_percentage untuk semua row existing (effective_date IS NULL)
+-- Value diambil dari row 3 Excel: kolom A=day1 s/d TL=day532
+UPDATE house_depreciation_standards AS hds
+SET multiplication_percentage = v.val
+FROM (VALUES
+    (1,0.997742664),(2,0.997737557),(3,0.997732426),(4,0.997727273),(5,0.997722096),
+    (6,0.997716895),(7,0.99771167),(8,0.997706422),(9,0.997701149),(10,0.997695853),
+    (11,0.997690531),(12,0.9977),(13,0.997679814),(14,0.997674419),(15,0.998),
+    (16,0.997997998),(17,0.997993982),(18,0.99798995),(19,0.997985901),(20,0.997981837),
+    (21,0.997977755),(22,0.997635934),(23,0.997630332),(24,0.997624703),(25,0.997619048),
+    (26,0.997613365),(27,0.997607656),(28,0.997601918),(29,0.997596154),(30,0.997590361),
+    (31,0.997584541),(32,0.997578692),(33,0.997572816),(34,0.99756691),(35,0.997560976),
+    (36,0.997555012),(37,0.99754902),(38,0.997542998),(39,0.997536946),(40,0.997530864),
+    (41,0.997524752),(42,0.99751861),(43,0.997867804),(44,0.997863248),(45,0.997858672),
+    (46,0.997854077),(47,0.997849462),(48,0.997844828),(49,0.997840173),(50,0.997474747),
+    (51,0.997468354),(52,0.997461929),(53,0.997455471),(54,0.99744898),(55,0.997442455),
+    (56,0.997435897),(57,0.997429306),(58,0.99742268),(59,0.997416021),(60,0.997409326),
+    (61,0.997402597),(62,0.997395833),(63,0.997389034),(64,0.997756171),(65,0.997751124),
+    (66,0.997746056),(67,0.997740964),(68,0.997735849),(69,0.997730711),(70,0.99772555),
+    (71,0.997340426),(72,0.997333333),(73,0.997326203),(74,0.997319035),(75,0.997311828),
+    (76,0.997304582),(77,0.9972973),(78,0.99767712),(79,0.99767171),(80,0.99766628),
+    (81,0.99766082),(82,0.99765533),(83,0.99764982),(84,0.997644287),(85,0.997245179),
+    (86,0.997237569),(87,0.997229917),(88,0.997222222),(89,0.997214485),(90,0.997206704),
+    (91,0.99719888),(92,0.997191011),(93,0.997183099),(94,0.997175141),(95,0.997167139),
+    (96,0.997159091),(97,0.997150997),(98,0.997142857),(99,0.997544003),(100,0.997537957),
+    (101,0.99753188),(102,0.997525773),(103,0.997519636),(104,0.997513469),(105,0.99750727),
+    (106,0.997084548),(107,0.997076023),(108,0.997067449),(109,0.997058824),(110,0.997050147),
+    (111,0.99704142),(112,0.997032641),(113,0.99744898),(114,0.997442455),(115,0.997435897),
+    (116,0.997429306),(117,0.99742268),(118,0.997416021),(119,0.997409326),(120,0.996969697),
+    (121,0.996960486),(122,0.99695122),(123,0.996941896),(124,0.996932515),(125,0.996923077),
+    (126,0.99691358),(127,0.997346307),(128,0.997339246),(129,0.997332148),(130,0.997325011),
+    (131,0.997317836),(132,0.997310623),(133,0.997303371),(134,0.996845426),(135,0.996835443),
+    (136,0.996825397),(137,0.996815287),(138,0.996805112),(139,0.996794872),(140,0.996784566),
+    (141,0.997235023),(142,0.997227357),(143,0.997219648),(144,0.997211896),(145,0.997204101),
+    (146,0.997196262),(147,0.997188379),(148,0.996710526),(149,0.99669967),(150,0.996688742),
+    (151,0.996677741),(152,0.996666667),(153,0.996655518),(154,0.996644295),(155,0.997113997),
+    (156,0.997105644),(157,0.997097242),(158,0.997088792),(159,0.997080292),(160,0.997071742),
+    (161,0.997063142),(162,0.997054492),(163,0.99704579),(164,0.997037037),(165,0.997028232),
+    (166,0.997019374),(167,0.997010463),(168,0.997001499),(169,0.996491228),(170,0.996478873),
+    (171,0.996466431),(172,0.996453901),(173,0.996441281),(174,0.996428571),(175,0.996415771),
+    (176,0.996916752),(177,0.996907216),(178,0.996897622),(179,0.996887967),(180,0.996878252),
+    (181,0.996868476),(182,0.996858639),(183,0.996848739),(184,0.996838778),(185,0.996828753),
+    (186,0.996818664),(187,0.996808511),(188,0.996798292),(189,0.996788009),(190,0.996240602),
+    (191,0.996226415),(192,0.996212121),(193,0.996197719),(194,0.996183206),(195,0.996168582),
+    (196,0.996153846),(197,0.996690568),(198,0.996679579),(199,0.996668517),(200,0.996657382),
+    (201,0.996646171),(202,0.996634885),(203,0.996623523),(204,0.996612084),(205,0.996600567),
+    (206,0.996588971),(207,0.996577296),(208,0.996565541),(209,0.996553705),(210,0.996541787),
+    (211,0.996529786),(212,0.996517702),(213,0.996505533),(214,0.996493279),(215,0.996480938),
+    (216,0.996468511),(217,0.996455995),(218,0.996443391),(219,0.996430696),(220,0.99641791),
+    (221,0.996405033),(222,0.996392063),(223,0.996378998),(224,0.996365839),(225,0.995744681),
+    (226,0.995726496),(227,0.995708155),(228,0.995689655),(229,0.995670996),(230,0.995652174),
+    (231,0.995633188),(232,0.996240602),(233,0.996226415),(234,0.996212121),(235,0.996197719),
+    (236,0.996183206),(237,0.996168582),(238,0.996153846),(239,0.9961389960),(240,0.996124031),
+    (241,0.996108949),(242,0.99609375),(243,0.996078431),(244,0.996062992),(245,0.996047431),
+    (246,0.996031746),(247,0.996015936),(248,0.996),(249,0.995983936),(250,0.995967742),
+    (251,0.995951417),(252,0.995934959),(253,0.995918367),(254,0.995901639),(255,0.995884774),
+    (256,0.995867769),(257,0.995850622),(258,0.995833333),(259,0.9958158999),(260,0.995798319),
+    (261,0.995780591),(262,0.995762712),(263,0.995744681),(264,0.995726496),(265,0.995708155),
+    (266,0.995689655),(267,0.995670996),(268,0.995652174),(269,0.995633188),(270,0.995614035),
+    (271,0.995594714),(272,0.995575221),(273,0.995555556),(274,0.995535714),(275,0.995515695),
+    (276,0.995495495),(277,0.995475113),(278,0.995454545),(279,0.99543379),(280,0.995412844),
+    (281,0.995391705),(282,0.99537037),(283,0.995348837),(284,0.995327103),(285,0.995305164),
+    (286,0.995282919),(287,0.995260664),(288,0.996031746),(289,0.996015936),(290,0.996),
+    (291,0.995983936),(292,0.995967742),(293,0.995951417),(294,0.995934959),(295,0.995102041),
+    (296,0.995077933),(297,0.995053586),(298,0.995028998),(299,0.995004163),(300,0.994979079),
+    (301,0.994953743),(302,0.994928149),(303,0.994902294),(304,0.994876174),(305,0.994849785),
+    (306,0.994823123),(307,0.994796184),(308,0.994768963),(309,0.994741455),(310,0.994713656),
+    (311,0.994685562),(312,0.994657168),(313,0.994628469),(314,0.99459946),(315,0.994570136),
+    (316,0.994540491),(317,0.994510522),(318,0.994480221),(319,0.994449584),(320,0.994418605),
+    (321,0.994387278),(322,0.994355597),(323,0.995269631),(324,0.995247148),(325,0.995224451),
+    (326,0.995201536),(327,0.995178399),(328,0.995155039),(329,0.995131451),(330,0.994129159),
+    (331,0.994094488),(332,0.994059406),(333,0.994023904),(334,0.993987976),(335,0.993951613),
+    (336,0.993914807),(337,0.994897959),(338,0.994871795),(339,0.994845361),(340,0.994818653),
+    (341,0.994791667),(342,0.994764398),(343,0.994736842),(344,0.993650794),(345,0.993610224),
+    (346,0.993569132),(347,0.993527508),(348,0.993484342),(349,0.993442623),(350,0.99339934),
+    (351,0.993355482),(352,0.993311037),(353,0.993265993),(354,0.993220339),(355,0.993174061),
+    (356,0.993127148),(357,0.993079585),(358,0.994192799),(359,0.994158879),(360,0.994124559),
+    (361,0.994089835),(362,0.994054697),(363,0.994019139),(364,0.993983153),(365,0.992736077),
+    (366,0.992682927),(367,0.992628993),(368,0.992574257),(369,0.992518703),(370,0.992462312),
+    (371,0.992405063),(372,0.993622449),(373,0.993581515),(374,0.993540052),(375,0.993498049),
+    (376,0.993455497),(377,0.993412385),(378,0.9933687),(379,0.993324433),(380,0.99327957),
+    (381,0.9932341),(382,0.993188011),(383,0.993141289),(384,0.993093923),(385,0.993045897),
+    (386,0.991596639),(387,0.991525424),(388,0.991452991),(389,0.99137931),(390,0.991304348),
+    (391,0.99122807),(392,0.991150442),(393,0.992559524),(394,0.992503748),(395,0.99244713),
+    (396,0.99238965),(397,0.992331288),(398,0.992272025),(399,0.992211838),(400,0.992150706),
+    (401,0.992088608),(402,0.992025518),(403,0.991961415),(404,0.991896272),(405,0.991830065),
+    (406,0.991762768),(407,0.991694352),(408,0.991624791),(409,0.991554054),(410,0.991482112),
+    (411,0.991408935),(412,0.991334489),(413,0.991258741),(414,0.989417989),(415,0.989304813),
+    (416,0.989189189),(417,0.989071038),(418,0.988950276),(419,0.988826816),(420,0.988700565),
+    (421,0.99047619),(422,0.990384615),(423,0.990291262),(424,0.990196078),(425,0.99009901),
+    (426,0.99),(427,0.98989899),(428,0.989795918),(429,0.989690722),(430,0.989583333),
+    (431,0.989473684),(432,0.989361702),(433,0.989247312),(434,0.989130435),(435,0.989010989),
+    (436,0.988888889),(437,0.988764045),(438,0.988636364),(439,0.988505747),(440,0.988372093),
+    (441,0.988235294),(442,0.988095238),(443,0.987951807),(444,0.987804878),(445,0.987654321),
+    (446,0.9875),(447,0.987341772),(448,0.987179487),(449,0.987012987),(450,0.986842105),
+    (451,0.986666667),(452,0.986486486),(453,0.98630137),(454,0.986111111),(455,0.985915493),
+    (456,0.985714286),(457,0.985507246),(458,0.985294118),(459,0.985074627),(460,0.984848485),
+    (461,0.984615385),(462,0.984375),(463,0.987301587),(464,0.987138264),(465,0.986970684),
+    (466,0.98679868),(467,0.986622074),(468,0.986440678),(469,0.986254296),(470,0.982578397),
+    (471,0.982269504),(472,0.981949458),(473,0.981617647),(474,0.981273408),(475,0.980916031),
+    (476,0.980544747),(477,0.98015873),(478,0.979757085),(479,0.979338843),(480,0.978902954),
+    (481,0.978448276),(482,0.977973568),(483,0.977477477),(484,0.976958525),(485,0.976415094),
+    (486,0.975845411),(487,0.975247525),(488,0.974619289),(489,0.973958333),(490,0.973262032),
+    (491,0.978021978),(492,0.97752809),(493,0.977011494),(494,0.976470588),(495,0.975903614),
+    (496,0.975308642),(497,0.974683544),(498,0.967532468),(499,0.966442953),(500,0.965277778),
+    (501,0.964028777),(502,0.962686567),(503,0.96124031),(504,0.959677419),(505,0.966386555),
+    (506,0.965217391),(507,0.963963964),(508,0.962616822),(509,0.961165049),(510,0.95959596),
+    (511,0.957894737),(512,0.945054945),(513,0.941860465),(514,0.938271605),(515,0.934210526),
+    (516,0.929577465),(517,0.924242424),(518,0.918032787),(519,0.928571429),(520,0.923076923),
+    (521,0.916666667),(522,0.909090909),(523,0.9),(524,0.888888889),(525,0.875),
+    (526,0.857142857),(527,0.833333333),(528,0.8),(529,0.75),(530,0.666666667),
+    (531,0.5),(532,9.11e-12)
+) AS v(day_num, val)
+WHERE hds.day = v.day_num;
+
+-- Insert open_house baru dengan effective_date 2026-05-20
+-- multiplication_percentage diambil dari row existing (sudah di-UPDATE di step sebelumnya)
+INSERT INTO house_depreciation_standards
+    (house_type, day, effective_date, depreciation_percent, standard_week, name, multiplication_percentage)
+SELECT
+    'open_house'::house_type_enum,
+    day,
+    '2026-05-29'::date,
+    depreciation_percent,
+    25,
+    'Standard Open House Week 25',
+    multiplication_percentage
+FROM (
+    SELECT DISTINCT ON (day)
+        day, depreciation_percent, multiplication_percentage
+    FROM house_depreciation_standards
+    WHERE house_type = 'open_house'
+    ORDER BY day, effective_date DESC NULLS LAST
+) effective_open_house;
+
+
+-- Insert close_house baru dengan effective_date 2026-05-29
+-- multiplication_percentage diambil dari row existing (sudah di-UPDATE di step sebelumnya)
+INSERT INTO house_depreciation_standards
+    (house_type, day, effective_date, depreciation_percent, standard_week, name, multiplication_percentage)
+SELECT
+    'close_house'::house_type_enum,
+    day,
+    '2026-05-29'::date,
+    depreciation_percent,
+    25,
+    'Standard Close House Week 25',
+    multiplication_percentage
+FROM (
+    SELECT DISTINCT ON (day)
+        day, depreciation_percent, multiplication_percentage
+    FROM house_depreciation_standards
+    WHERE house_type = 'open_house'
+    ORDER BY day, effective_date DESC NULLS LAST
+) effective_close_house;
+
+-- Invalidate snapshot cache depreciation agar recompute dengan standard baru
+DELETE FROM farm_depreciation_snapshots;

internal/database/migrations/20260529144531_recalculate_economic_cutoff_25_weeks.down.sql

@@ -0,0 +1,22 @@
+-- Rollback: balik ke rule lama (19 minggu = 133 hari)
+
+BEGIN;
+
+UPDATE laying_transfers lt
+SET economic_cutoff_date = sub.cutoff_date,
+    updated_at = NOW()
+FROM (
+    SELECT
+        lt2.id AS transfer_id,
+        (MIN(pc.chick_in_date)::date + INTERVAL '133 days')::date AS cutoff_date
+    FROM laying_transfers lt2
+    JOIN project_chickins pc ON pc.project_flock_kandang_id = lt2.source_project_flock_kandang_id
+    WHERE lt2.deleted_at IS NULL
+      AND lt2.source_project_flock_kandang_id IS NOT NULL
+      AND pc.deleted_at IS NULL
+    GROUP BY lt2.id
+) sub
+WHERE lt.id = sub.transfer_id
+  AND lt.deleted_at IS NULL;
+
+COMMIT;

internal/database/migrations/20260529144531_recalculate_economic_cutoff_25_weeks.up.sql

@@ -0,0 +1,24 @@
+-- Recalculate laying_transfers.economic_cutoff_date dari rule 19 minggu (lama) ke 25 minggu (baru,
+-- sejalan dengan depreciation_start_age_day = 175). Semua transfer historis yang punya
+-- source_project_flock_kandang_id akan di-update agar economic_cutoff_date = source.chick_in_date + 175 hari.
+
+BEGIN;
+
+UPDATE laying_transfers lt
+SET economic_cutoff_date = sub.cutoff_date,
+    updated_at = NOW()
+FROM (
+    SELECT
+        lt2.id AS transfer_id,
+        (MIN(pc.chick_in_date)::date + INTERVAL '175 days')::date AS cutoff_date
+    FROM laying_transfers lt2
+    JOIN project_chickins pc ON pc.project_flock_kandang_id = lt2.source_project_flock_kandang_id
+    WHERE lt2.deleted_at IS NULL
+      AND lt2.source_project_flock_kandang_id IS NOT NULL
+      AND pc.deleted_at IS NULL
+    GROUP BY lt2.id
+) sub
+WHERE lt.id = sub.transfer_id
+  AND lt.deleted_at IS NULL;
+
+COMMIT;

internal/database/migrations/20260529144559_update_farm_depreciation_manual_inputs_pfk_10_11.down.sql

@@ -0,0 +1,14 @@
+-- Rollback total_cost ke nilai sebelum migration
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 562618200.000,
+    updated_at = NOW()
+WHERE project_flock_id = 10;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 598552406.000,
+    updated_at = NOW()
+WHERE project_flock_id = 11;
+
+-- Snapshot lama tidak bisa di-restore — biarkan kosong, recompute otomatis
+-- saat user request endpoint depresiasi
+TRUNCATE TABLE farm_depreciation_snapshots;

internal/database/migrations/20260529144559_update_farm_depreciation_manual_inputs_pfk_10_11.up.sql

@@ -0,0 +1,21 @@
+-- Update total_cost farm_depreciation_manual_inputs untuk PFK 10 & 11
+-- per permintaan user (cutover 28 Feb 2026)
+--
+-- PFK 10 (Flock Jamali 003)    : 562.618.200,000   -> 1.900.157.533,55
+-- PFK 11 (Flock Tamansari 001) : 598.552.406,000   -> 2.521.797.832,14
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost   = 1900157533.55,
+    cutover_date = DATE '2026-02-28',
+    updated_at   = NOW()
+WHERE project_flock_id = 10;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost   = 2521797832.14,
+    cutover_date = DATE '2026-02-28',
+    updated_at   = NOW()
+WHERE project_flock_id = 11;
+
+-- Pengaman: pastikan snapshot di-recompute dengan total_cost baru
+-- saat user request /api/reports/expense/depreciation
+TRUNCATE TABLE farm_depreciation_snapshots;

internal/entities/expense.go

@@ -18,6 +18,7 @@ type Expense struct {
 	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"`
+	GrandTotal              float64        `gorm:"column:grand_total;type:numeric(15,3);not null;default:0"`
 	CreatedBy               uint64         `gorm:""`
 	CreatedAt               time.Time      `gorm:"autoCreateTime"`
 	UpdatedAt               time.Time      `gorm:"autoUpdateTime"`

internal/entities/marketing.go

@@ -15,6 +15,7 @@ type Marketing struct {
 	SalesPersonId uint           `gorm:"not null"`
 	Notes         string         `gorm:"type:text"`
 	MarketingType string         `gorm:"type:varchar(50)"`
+	GrandTotal    float64        `gorm:"column:grand_total;type:numeric(15,3);not null;default:0"`
 	CreatedBy     uint           `gorm:"not null"`
 	CreatedAt     time.Time      `gorm:"autoCreateTime"`
 	UpdatedAt     time.Time      `gorm:"autoUpdateTime"`

internal/entities/payment_allocation.go

@@ -0,0 +1,23 @@
+package entities
+
+import (
+	"time"
+)
+
+// PaymentAllocation merepresentasikan hasil FIFO matching dari 1 payment ke
+// tepat 1 sub-row anak (purchase_item / marketing_delivery_product /
+// expense_realization). DB constraint memastikan hanya satu FK yang non-null.
+type PaymentAllocation struct {
+	Id                         uint64    `gorm:"primaryKey;autoIncrement"`
+	PaymentId                  uint      `gorm:"not null;index"`
+	PurchaseItemId             *uint     `gorm:"column:purchase_item_id"`
+	MarketingDeliveryProductId *uint     `gorm:"column:marketing_delivery_product_id"`
+	ExpenseRealizationId       *uint64   `gorm:"column:expense_realization_id"`
+	Amount                     float64   `gorm:"type:numeric(15,3);not null"`
+	AllocatedAt                time.Time `gorm:"type:timestamptz;not null;default:NOW()"`
+
+	Payment                  *Payment                  `gorm:"foreignKey:PaymentId;references:Id"`
+	PurchaseItem             *PurchaseItem             `gorm:"foreignKey:PurchaseItemId;references:Id"`
+	MarketingDeliveryProduct *MarketingDeliveryProduct `gorm:"foreignKey:MarketingDeliveryProductId;references:Id"`
+	ExpenseRealization       *ExpenseRealization       `gorm:"foreignKey:ExpenseRealizationId;references:Id"`
+}

internal/entities/purchase.go

@@ -12,6 +12,7 @@ type Purchase struct {
 	SupplierId uint `gorm:"not null"`
 	CreditTerm int  `gorm:"column:credit_term;not null;default:0"`
 	DueDate    *time.Time
+	GrandTotal float64 `gorm:"column:grand_total;type:numeric(15,3);not null;default:0"`
 	Notes      *string
 	CreatedAt  time.Time  `gorm:"autoCreateTime"`
 	UpdatedAt  time.Time  `gorm:"autoUpdateTime"`

internal/modules/expenses/module.go

@@ -45,7 +45,8 @@ func (ExpenseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 		panic(fmt.Sprintf("failed to register expense approval workflow: %v", err))
 	}
 
-	expenseService := sExpense.NewExpenseService(expenseRepo, supplierRepo, nonstockRepo, approvalSvc, realizationRepo, projectFlockKandangRepo, documentSvc, validate)
+	fifoPaymentSvc := commonSvc.NewFifoPaymentService(db, utils.Log)
+	expenseService := sExpense.NewExpenseService(expenseRepo, supplierRepo, nonstockRepo, approvalSvc, realizationRepo, projectFlockKandangRepo, documentSvc, fifoPaymentSvc, validate)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	ExpenseRoutes(router, userService, expenseService)

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

@@ -54,9 +54,10 @@ type expenseService struct {
 	RealizationRepository   repository.ExpenseRealizationRepository
 	ProjectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository
 	DocumentSvc             commonSvc.DocumentService
+	FifoPaymentSvc          commonSvc.FifoPaymentService
 }
 
-func NewExpenseService(repo repository.ExpenseRepository, supplierRepo supplierRepo.SupplierRepository, nonstockRepo nonstockRepo.NonstockRepository, approvalSvc commonSvc.ApprovalService, realizationRepo repository.ExpenseRealizationRepository, projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository, documentSvc commonSvc.DocumentService, validate *validator.Validate) ExpenseService {
+func NewExpenseService(repo repository.ExpenseRepository, supplierRepo supplierRepo.SupplierRepository, nonstockRepo nonstockRepo.NonstockRepository, approvalSvc commonSvc.ApprovalService, realizationRepo repository.ExpenseRealizationRepository, projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository, documentSvc commonSvc.DocumentService, fifoPaymentSvc commonSvc.FifoPaymentService, validate *validator.Validate) ExpenseService {
 	return &expenseService{
 		Log:                     utils.Log,
 		Validate:                validate,
@@ -67,6 +68,23 @@ func NewExpenseService(repo repository.ExpenseRepository, supplierRepo supplierR
 		RealizationRepository:   realizationRepo,
 		ProjectFlockKandangRepo: projectFlockKandangRepo,
 		DocumentSvc:             documentSvc,
+		FifoPaymentSvc:          fifoPaymentSvc,
+	}
+}
+
+// reallocateAfterRealization called after expense realization changes that may
+// affect supplier debt: recompute grand_total + reallocate FIFO.
+func (s *expenseService) reallocateAfterRealization(ctx context.Context, expenseID uint, supplierID uint64) {
+	if s.FifoPaymentSvc == nil {
+		return
+	}
+	if err := s.FifoPaymentSvc.RecomputeGrandTotal(ctx, nil, commonSvc.ParentKindExpense, expenseID); err != nil {
+		s.Log.Warnf("Failed to recompute grand_total for expense %d: %+v", expenseID, err)
+	}
+	if supplierID > 0 {
+		if err := s.FifoPaymentSvc.ReallocateForParty(ctx, nil, string(utils.PaymentPartySupplier), uint(supplierID)); err != nil {
+			s.Log.Warnf("Failed to reallocate payments for supplier %d: %+v", supplierID, err)
+		}
 	}
 }
 
@@ -1078,6 +1096,9 @@ func (s *expenseService) CreateRealization(c *fiber.Ctx, expenseID uint, req *va
 	}
 	invalidateFromDate := commonSvc.MinNonZeroDateOnlyUTC(expense.TransactionDate, realizationDate, expense.RealizationDate)
 	s.invalidateDepreciationSnapshotsByExpense(c.Context(), nil, expenseID, invalidateFromDate, nil)
+
+	s.reallocateAfterRealization(c.Context(), expenseID, expense.SupplierId)
+
 	return responseDTO, nil
 }
 
@@ -1522,6 +1543,9 @@ func (s *expenseService) UpdateRealization(c *fiber.Ctx, expenseID uint, req *va
 		return nil, err
 	}
 	s.invalidateDepreciationSnapshotsByExpense(c.Context(), nil, expenseID, invalidateFromDate, nil)
+
+	s.reallocateAfterRealization(c.Context(), expenseID, expense.SupplierId)
+
 	return responseDTO, nil
 }
 

internal/modules/finance/payments/module.go

@@ -29,7 +29,9 @@ func (PaymentModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 		panic(fmt.Sprintf("failed to register payment approval workflow: %v", err))
 	}
 
-	paymentService := sPayment.NewPaymentService(paymentRepo, approvalService, validate)
+	fifoPaymentService := commonSvc.NewFifoPaymentService(db, nil)
+
+	paymentService := sPayment.NewPaymentService(paymentRepo, approvalService, fifoPaymentService, validate)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	PaymentRoutes(router, userService, paymentService)

internal/modules/finance/payments/services/payment.service.go

@@ -32,12 +32,14 @@ type paymentService struct {
 	Validate         *validator.Validate
 	Repository       repository.PaymentRepository
 	ApprovalSvc      commonSvc.ApprovalService
+	FifoPaymentSvc   commonSvc.FifoPaymentService
 	approvalWorkflow approvalutils.ApprovalWorkflowKey
 }
 
 func NewPaymentService(
 	repo repository.PaymentRepository,
 	approvalSvc commonSvc.ApprovalService,
+	fifoPaymentSvc commonSvc.FifoPaymentService,
 	validate *validator.Validate,
 ) PaymentService {
 	return &paymentService{
@@ -45,6 +47,7 @@ func NewPaymentService(
 		Validate:         validate,
 		Repository:       repo,
 		ApprovalSvc:      approvalSvc,
+		FifoPaymentSvc:   fifoPaymentSvc,
 		approvalWorkflow: utils.ApprovalWorkflowPayment,
 	}
 }
@@ -159,6 +162,12 @@ func (s *paymentService) CreateOne(c *fiber.Ctx, req *validation.Create) (*entit
 			}
 		}
 
+		if s.FifoPaymentSvc != nil {
+			if err := s.FifoPaymentSvc.ReallocateForParty(c.Context(), dbTransaction, createBody.PartyType, createBody.PartyId); err != nil {
+				return err
+			}
+		}
+
 		return nil
 	})
 	if err != nil {
@@ -251,7 +260,46 @@ func (s paymentService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
 		return s.GetOne(c, id)
 	}
 
-	if err := s.Repository.PatchOne(c.Context(), id, updateBody, nil); err != nil {
+	// Snapshot party lama untuk reallocate kalau party baru berbeda.
+	existing, err := s.Repository.GetByID(c.Context(), id, nil)
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, fiber.NewError(fiber.StatusNotFound, "Payment not found")
+	}
+	if err != nil {
+		s.Log.Errorf("Failed get payment for update: %+v", err)
+		return nil, err
+	}
+	oldPartyType := existing.PartyType
+	oldPartyID := existing.PartyId
+
+	newPartyType := oldPartyType
+	newPartyID := oldPartyID
+	if v, ok := updateBody["party_type"].(string); ok {
+		newPartyType = v
+	}
+	if v, ok := updateBody["party_id"].(uint); ok {
+		newPartyID = v
+	}
+
+	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
+		paymentRepoTx := repository.NewPaymentRepository(tx)
+		if err := paymentRepoTx.PatchOne(c.Context(), id, updateBody, nil); err != nil {
+			return err
+		}
+
+		if s.FifoPaymentSvc != nil {
+			if err := s.FifoPaymentSvc.ReallocateForParty(c.Context(), tx, newPartyType, newPartyID); err != nil {
+				return err
+			}
+			if oldPartyType != newPartyType || oldPartyID != newPartyID {
+				if err := s.FifoPaymentSvc.ReallocateForParty(c.Context(), tx, oldPartyType, oldPartyID); err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	})
+	if err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, fiber.NewError(fiber.StatusNotFound, "Payment not found")
 		}

internal/modules/finance/transactions/module.go

@@ -35,7 +35,8 @@ func (TransactionModule) RegisterRoutes(router fiber.Router, db *gorm.DB, valida
 		panic(fmt.Sprintf("failed to register injection approval workflow: %v", err))
 	}
 
-	transactionService := sTransaction.NewTransactionService(transactionRepo, approvalService, validate)
+	fifoPaymentService := commonSvc.NewFifoPaymentService(db, utils.Log)
+	transactionService := sTransaction.NewTransactionService(transactionRepo, approvalService, fifoPaymentService, validate)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	TransactionRoutes(router, userService, transactionService)

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

@@ -30,19 +30,22 @@ type transactionService struct {
 	Validate          *validator.Validate
 	Repository        repository.TransactionRepository
 	ApprovalSvc       commonSvc.ApprovalService
+	FifoPaymentSvc    commonSvc.FifoPaymentService
 	approvalWorkflows map[string]approvalutils.ApprovalWorkflowKey
 }
 
 func NewTransactionService(
 	repo repository.TransactionRepository,
 	approvalSvc commonSvc.ApprovalService,
+	fifoPaymentSvc commonSvc.FifoPaymentService,
 	validate *validator.Validate,
 ) TransactionService {
 	return &transactionService{
-		Log:         utils.Log,
-		Validate:    validate,
-		Repository:  repo,
-		ApprovalSvc: approvalSvc,
+		Log:            utils.Log,
+		Validate:       validate,
+		Repository:     repo,
+		ApprovalSvc:    approvalSvc,
+		FifoPaymentSvc: fifoPaymentSvc,
 		approvalWorkflows: map[string]approvalutils.ApprovalWorkflowKey{
 			string(utils.TransactionTypeSaldoAwal): utils.ApprovalWorkflowInitial,
 			string(utils.TransactionTypeInjection): utils.ApprovalWorkflowInjection,
@@ -182,6 +185,19 @@ func (s transactionService) GetOne(c *fiber.Ctx, id uint) (*entity.Payment, erro
 }
 
 func (s transactionService) DeleteOne(c *fiber.Ctx, id uint) error {
+	// Snapshot party SEBELUM delete supaya bisa re-FIFO setelah trigger DB
+	// (`trg_soft_delete_fk_payments`) CASCADE hard-DELETE allocations.
+	existing, err := s.Repository.GetByID(c.Context(), id, nil)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return fiber.NewError(fiber.StatusNotFound, "Transaction not found")
+		}
+		s.Log.Errorf("Failed to load transaction before delete: %+v", err)
+		return err
+	}
+	partyType := existing.PartyType
+	partyID := existing.PartyId
+
 	if err := s.Repository.DeleteOne(c.Context(), id); err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return fiber.NewError(fiber.StatusNotFound, "Transaction not found")
@@ -189,6 +205,14 @@ func (s transactionService) DeleteOne(c *fiber.Ctx, id uint) error {
 		s.Log.Errorf("Failed to delete transaction: %+v", err)
 		return err
 	}
+
+	// Re-FIFO setelah delete agar payment lain yang masih punya unallocated nominal
+	// otomatis reflow ke MDP/purchase_item/expense_realization yang kekurangan paid.
+	if s.FifoPaymentSvc != nil && partyID > 0 {
+		if err := s.FifoPaymentSvc.ReallocateForParty(c.Context(), nil, partyType, partyID); err != nil {
+			s.Log.Warnf("Failed to reallocate payments after delete (party=%s id=%d): %+v", partyType, partyID, err)
+		}
+	}
 	return nil
 }
 

internal/modules/inventory/transfers/module.go

@@ -65,6 +65,7 @@ func (TransferModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		expenseRealizationRepo,
 		projectFlockKandangRepo,
 		documentSvc,
+		commonSvc.NewFifoPaymentService(db, utils.Log),
 		validate,
 	)
 

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

@@ -75,9 +75,18 @@ func setMarketingExportColumns(file *excelize.File, sheet string) error {
 		"B": 14,
 		"C": 18,
 		"D": 20,
-		"E": 18,
-		"F": 60,
-		"G": 24,
+		"E": 14,
+		"F": 40,
+		"G": 10,
+		"H": 12,
+		"I": 12,
+		"J": 12,
+		"K": 16,
+		"L": 16,
+		"M": 18,
+		"N": 18,
+		"O": 18,
+		"P": 24,
 	}
 
 	for col, width := range columnWidths {
@@ -95,13 +104,22 @@ func setMarketingExportColumns(file *excelize.File, sheet string) error {
 
 func setMarketingExportHeaders(file *excelize.File, sheet string) error {
 	headers := []string{
-		"No. Order",
-		"Tanggal",
-		"Status",
-		"Customer",
-		"Grand Total",
-		"Products",
-		"Notes",
+		"No. Order",    // A
+		"Tanggal",      // B
+		"Status",       // C
+		"Customer",     // D
+		"Tipe",         // E
+		"Nama Produk",  // F
+		"Week",         // G
+		"Jumlah",       // H
+		"Satuan",       // I
+		"Qty Peti",     // J
+		"Berat Rata-rata (kg)", // K
+		"Total Berat (kg)",     // L
+		"Harga Satuan", // M
+		"Total Harga",  // N
+		"Grand Total",  // O
+		"Catatan",      // P
 	}
 
 	for i, header := range headers {
@@ -130,7 +148,7 @@ func setMarketingExportHeaders(file *excelize.File, sheet string) error {
 		return err
 	}
 
-	return file.SetCellStyle(sheet, "A1", "G1", headerStyle)
+	return file.SetCellStyle(sheet, "A1", "P1", headerStyle)
 }
 
 func setMarketingExportRows(file *excelize.File, sheet string, items []dto.MarketingListDTO) error {
@@ -138,70 +156,154 @@ func setMarketingExportRows(file *excelize.File, sheet string, items []dto.Marke
 		return nil
 	}
 
-	for i, item := range items {
-		rowNumber := i + 2
-		if err := file.SetCellValue(sheet, "A"+strconv.Itoa(rowNumber), safeMarketingExportText(item.SoNumber)); err != nil {
-			return err
+	row := 1
+	for _, item := range items {
+		soNumber := safeMarketingExportText(item.SoNumber)
+		soDate := formatMarketingExportDate(item.SoDate)
+		status := formatMarketingExportStatus(item)
+		customer := safeMarketingExportText(item.Customer.Name)
+		grandTotal := sumMarketingGrandTotal(item.SalesOrder)
+		notes := safeMarketingExportText(item.Notes)
+
+		if len(item.SalesOrder) == 0 {
+			row++
+			r := strconv.Itoa(row)
+			vals := map[string]interface{}{
+				"A": soNumber, "B": soDate, "C": status, "D": customer,
+				"E": "-", "F": "-", "G": "-", "H": "-", "I": "-", "J": "-",
+				"K": "-", "L": "-", "M": "-", "N": "-",
+				"O": grandTotal, "P": notes,
+			}
+			for col, val := range vals {
+				if err := file.SetCellValue(sheet, col+r, val); err != nil {
+					return err
+				}
+			}
+			continue
 		}
-		if err := file.SetCellValue(sheet, "B"+strconv.Itoa(rowNumber), formatMarketingExportDate(item.SoDate)); err != nil {
-			return err
-		}
-		if err := file.SetCellValue(sheet, "C"+strconv.Itoa(rowNumber), formatMarketingExportStatus(item)); err != nil {
-			return err
-		}
-		if err := file.SetCellValue(sheet, "D"+strconv.Itoa(rowNumber), safeMarketingExportText(item.Customer.Name)); err != nil {
-			return err
-		}
-		if err := file.SetCellValue(sheet, "E"+strconv.Itoa(rowNumber), sumMarketingGrandTotal(item.SalesOrder)); err != nil {
-			return err
-		}
-		if err := file.SetCellValue(sheet, "F"+strconv.Itoa(rowNumber), formatMarketingProducts(item.SalesOrder)); err != nil {
-			return err
-		}
-		if err := file.SetCellValue(sheet, "G"+strconv.Itoa(rowNumber), safeMarketingExportText(item.Notes)); err != nil {
-			return err
+
+		for _, prod := range item.SalesOrder {
+			row++
+			r := strconv.Itoa(row)
+
+			productName := "-"
+			if prod.ProductWarehouse != nil && prod.ProductWarehouse.Product != nil {
+				if n := strings.TrimSpace(prod.ProductWarehouse.Product.Name); n != "" {
+					productName = n
+				}
+			}
+
+			week := "-"
+			if prod.Week != nil {
+				week = strconv.Itoa(*prod.Week)
+			}
+
+			satuan := "-"
+			if prod.ConvertionUnit != nil && strings.TrimSpace(*prod.ConvertionUnit) != "" {
+				satuan = *prod.ConvertionUnit
+			}
+
+			if err := file.SetCellValue(sheet, "A"+r, soNumber); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "B"+r, soDate); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "C"+r, status); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "D"+r, customer); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "E"+r, safeMarketingExportText(prod.MarketingType)); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "F"+r, productName); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "G"+r, week); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "H"+r, prod.Qty); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "I"+r, satuan); err != nil {
+				return err
+			}
+			if prod.TotalPeti != nil {
+				if err := file.SetCellValue(sheet, "J"+r, *prod.TotalPeti); err != nil {
+					return err
+				}
+			} else {
+				if err := file.SetCellValue(sheet, "J"+r, "-"); err != nil {
+					return err
+				}
+			}
+			if err := file.SetCellValue(sheet, "K"+r, prod.AvgWeight); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "L"+r, prod.TotalWeight); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "M"+r, prod.UnitPrice); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "N"+r, prod.TotalPrice); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "O"+r, grandTotal); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "P"+r, notes); err != nil {
+				return err
+			}
 		}
 	}
 
-	lastRow := len(items) + 1
+	lastRow := row
+	lastRowStr := strconv.Itoa(lastRow)
+	border := []excelize.Border{
+		{Type: "left", Color: "D1D5DB", Style: 1},
+		{Type: "top", Color: "D1D5DB", Style: 1},
+		{Type: "bottom", Color: "D1D5DB", Style: 1},
+		{Type: "right", Color: "D1D5DB", Style: 1},
+	}
+
 	dataStyle, err := file.NewStyle(&excelize.Style{
-		Alignment: &excelize.Alignment{
-			Horizontal: "left",
-			Vertical:   "center",
-			WrapText:   true,
-		},
-		Border: []excelize.Border{
-			{Type: "left", Color: "D1D5DB", Style: 1},
-			{Type: "top", Color: "D1D5DB", Style: 1},
-			{Type: "bottom", Color: "D1D5DB", Style: 1},
-			{Type: "right", Color: "D1D5DB", Style: 1},
-		},
+		Alignment: &excelize.Alignment{Horizontal: "left", Vertical: "center", WrapText: true},
+		Border:    border,
 	})
 	if err != nil {
 		return err
 	}
-
-	if err := file.SetCellStyle(sheet, "A2", "G"+strconv.Itoa(lastRow), dataStyle); err != nil {
+	if err := file.SetCellStyle(sheet, "A2", "P"+lastRowStr, dataStyle); err != nil {
 		return err
 	}
 
-	moneyStyle, err := file.NewStyle(&excelize.Style{
-		Alignment: &excelize.Alignment{
-			Horizontal: "right",
-			Vertical:   "center",
-		},
-		Border: []excelize.Border{
-			{Type: "left", Color: "D1D5DB", Style: 1},
-			{Type: "top", Color: "D1D5DB", Style: 1},
-			{Type: "bottom", Color: "D1D5DB", Style: 1},
-			{Type: "right", Color: "D1D5DB", Style: 1},
-		},
+	numberStyle, err := file.NewStyle(&excelize.Style{
+		Alignment: &excelize.Alignment{Horizontal: "right", Vertical: "center"},
+		Border:    border,
 	})
 	if err != nil {
 		return err
 	}
+	if err := file.SetCellStyle(sheet, "K2", "O"+lastRowStr, numberStyle); err != nil {
+		return err
+	}
 
-	return file.SetCellStyle(sheet, "E2", "E"+strconv.Itoa(lastRow), moneyStyle)
+	centerStyle, err := file.NewStyle(&excelize.Style{
+		Alignment: &excelize.Alignment{Horizontal: "center", Vertical: "center"},
+		Border:    border,
+	})
+	if err != nil {
+		return err
+	}
+	for _, col := range []string{"G", "H", "J"} {
+		if err := file.SetCellStyle(sheet, col+"2", col+lastRowStr, centerStyle); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 func formatMarketingExportDate(value time.Time) string {
@@ -225,36 +327,6 @@ func formatMarketingExportStatus(item dto.MarketingListDTO) string {
 	return safeMarketingExportText(item.LatestApproval.StepName)
 }
 
-func formatMarketingProducts(items []dto.DeliveryMarketingProductDTO) string {
-	if len(items) == 0 {
-		return "-"
-	}
-
-	seen := make(map[string]struct{})
-	names := make([]string, 0, len(items))
-	for _, item := range items {
-		if item.ProductWarehouse == nil || item.ProductWarehouse.Product == nil {
-			continue
-		}
-
-		name := strings.TrimSpace(item.ProductWarehouse.Product.Name)
-		if name == "" {
-			continue
-		}
-
-		if _, exists := seen[name]; exists {
-			continue
-		}
-		seen[name] = struct{}{}
-		names = append(names, name)
-	}
-
-	if len(names) == 0 {
-		return "-"
-	}
-
-	return strings.Join(names, ", ")
-}
 
 func sumMarketingGrandTotal(items []dto.DeliveryMarketingProductDTO) float64 {
 	total := 0.0

internal/modules/marketing/dto/deliveryorder.dto.go

@@ -29,6 +29,7 @@ type MarketingListDTO struct {
 	SalesPerson    userDTO.UserRelationDTO         `json:"sales_person"`
 	SoDocs         string                          `json:"so_docs"`
 	SalesOrder     []DeliveryMarketingProductDTO   `json:"sales_order"`
+	DeliveryOrder  []DeliveryGroupDTO              `json:"delivery_order"`
 	CreatedUser    userDTO.UserRelationDTO         `json:"created_user"`
 	CreatedAt      time.Time                       `json:"created_at"`
 	UpdatedAt      time.Time                       `json:"updated_at"`
@@ -203,6 +204,7 @@ func ToMarketingListDTO(marketing *entity.Marketing, deliveryProducts []entity.M
 		SalesPerson:          salesPerson,
 		SoDocs:               marketing.SoDocs,
 		SalesOrder:           salesOrderProducts,
+		DeliveryOrder:        extractDeliveryGroupsFromProducts(marketing),
 		CreatedUser:          createdUser,
 		CreatedAt:            marketing.CreatedAt,
 		UpdatedAt:            marketing.UpdatedAt,
@@ -376,6 +378,23 @@ func GenerateDeliveryOrderNumber(soNumber string, deliveryDate *time.Time, wareh
 	return numberPrefix
 }
 
+func extractDeliveryGroupsFromProducts(marketing *entity.Marketing) []DeliveryGroupDTO {
+	var dps []MarketingDeliveryProductDTO
+	for _, product := range marketing.Products {
+		if product.DeliveryProduct == nil || product.DeliveryProduct.DeliveryDate == nil {
+			continue
+		}
+		dp := ToMarketingDeliveryProductDTO(*product.DeliveryProduct)
+		if product.ProductWarehouse.Id != 0 {
+			mapped := productwarehouseDTO.ToProductWarehouseNestedDTO(product.ProductWarehouse)
+			dp.ProductWarehouse = &mapped
+		}
+		dp.ConvertionUnit = product.ConvertionUnit
+		dps = append(dps, dp)
+	}
+	return groupDeliveryProducts(dps, marketing.SoNumber)
+}
+
 func collectDoNumbers(marketing *entity.Marketing) []string {
 	if marketing == nil || len(marketing.Products) == 0 {
 		return nil

internal/modules/marketing/module.go

@@ -35,6 +35,7 @@ func (MarketingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	stockLogRepo := rShared.NewStockLogRepository(db)
 
 	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
+	fifoPaymentService := commonSvc.NewFifoPaymentService(db, utils.Log)
 
 	approvalRepo := commonRepo.NewApprovalRepository(db)
 	approvalSvc := commonSvc.NewApprovalService(approvalRepo)
@@ -47,7 +48,7 @@ func (MarketingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	projectFlockKandangRepo := rProjectFlockKandang.NewProjectFlockKandangRepository(db)
 
 	salesOrdersService := service.NewSalesOrdersService(marketingRepo, customerRepo, productWarehouseRepo, userRepo, approvalSvc, fifoStockV2Service, warehouseRepo, projectFlockKandangRepo, validate)
-	deliveryOrdersService := service.NewDeliveryOrdersService(marketingRepo, marketingProductRepo, marketingDeliveryProductRepo, stockLogRepo, productWarehouseRepo, projectFlockPopulationRepo, approvalSvc, fifoStockV2Service, validate)
+	deliveryOrdersService := service.NewDeliveryOrdersService(marketingRepo, marketingProductRepo, marketingDeliveryProductRepo, stockLogRepo, productWarehouseRepo, projectFlockPopulationRepo, approvalSvc, fifoStockV2Service, fifoPaymentService, validate)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	RegisterRoutes(router, userService, salesOrdersService, deliveryOrdersService)

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

@@ -48,6 +48,7 @@ type deliveryOrdersService struct {
 	ProjectFlockPopulationRepo   rProjectFlock.ProjectFlockPopulationRepository
 	ApprovalSvc                  commonSvc.ApprovalService
 	FifoStockV2Svc               commonSvc.FifoStockV2Service
+	FifoPaymentSvc               commonSvc.FifoPaymentService
 }
 
 func NewDeliveryOrdersService(
@@ -59,6 +60,7 @@ func NewDeliveryOrdersService(
 	projectFlockPopulationRepo rProjectFlock.ProjectFlockPopulationRepository,
 	approvalSvc commonSvc.ApprovalService,
 	fifoStockV2Svc commonSvc.FifoStockV2Service,
+	fifoPaymentSvc commonSvc.FifoPaymentService,
 	validate *validator.Validate,
 ) DeliveryOrdersService {
 	return &deliveryOrdersService{
@@ -71,6 +73,22 @@ func NewDeliveryOrdersService(
 		ProjectFlockPopulationRepo:   projectFlockPopulationRepo,
 		ApprovalSvc:                  approvalSvc,
 		FifoStockV2Svc:               fifoStockV2Svc,
+		FifoPaymentSvc:               fifoPaymentSvc,
+	}
+}
+
+// reallocateAfterDelivery refresh marketing.grand_total + reallocate FIFO untuk customer.
+func (s *deliveryOrdersService) reallocateAfterDelivery(ctx context.Context, marketingID uint, customerID uint) {
+	if s.FifoPaymentSvc == nil {
+		return
+	}
+	if err := s.FifoPaymentSvc.RecomputeGrandTotal(ctx, nil, commonSvc.ParentKindMarketing, marketingID); err != nil {
+		utils.Log.Warnf("Failed to recompute grand_total for marketing %d: %+v", marketingID, err)
+	}
+	if customerID > 0 {
+		if err := s.FifoPaymentSvc.ReallocateForParty(ctx, nil, string(utils.PaymentPartyCustomer), customerID); err != nil {
+			utils.Log.Warnf("Failed to reallocate payments for customer %d: %+v", customerID, err)
+		}
 	}
 }
 
@@ -418,6 +436,7 @@ func (s *deliveryOrdersService) CreateOne(c *fiber.Ctx, req *validation.Delivery
 		return nil, fiber.NewError(fiber.StatusBadRequest, "Delivery order already exists for this marketing")
 	}
 
+	var capturedCustomerID uint
 	err = s.MarketingRepo.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
 		marketingProductRepositoryTx := marketingRepo.NewMarketingProductRepository(dbTransaction)
 		marketingDeliveryProductRepositoryTx := marketingRepo.NewMarketingDeliveryProductRepository(dbTransaction)
@@ -428,6 +447,7 @@ func (s *deliveryOrdersService) CreateOne(c *fiber.Ctx, req *validation.Delivery
 		if err != nil {
 			return fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch marketing")
 		}
+		capturedCustomerID = marketing.CustomerId
 
 		allMarketingProducts, err := marketingProductRepositoryTx.GetByMarketingID(c.Context(), req.MarketingId)
 		if err != nil {
@@ -519,6 +539,8 @@ func (s *deliveryOrdersService) CreateOne(c *fiber.Ctx, req *validation.Delivery
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to create delivery order")
 	}
 
+	s.reallocateAfterDelivery(c.Context(), req.MarketingId, capturedCustomerID)
+
 	return s.getMarketingWithDeliveries(c, req.MarketingId)
 }
 
@@ -547,6 +569,7 @@ func (s deliveryOrdersService) UpdateOne(c *fiber.Ctx, req *validation.DeliveryO
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to check approval status")
 	}
 
+	var capturedCustomerID uint
 	err = s.MarketingRepo.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
 		marketingProductRepositoryTx := marketingRepo.NewMarketingProductRepository(dbTransaction)
 		marketingDeliveryProductRepositoryTx := marketingRepo.NewMarketingDeliveryProductRepository(dbTransaction)
@@ -557,6 +580,7 @@ func (s deliveryOrdersService) UpdateOne(c *fiber.Ctx, req *validation.DeliveryO
 		if err != nil {
 			return fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch marketing")
 		}
+		capturedCustomerID = marketing.CustomerId
 
 		allMarketingProducts, err := marketingProductRepositoryTx.GetByMarketingID(c.Context(), id)
 		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
@@ -662,6 +686,8 @@ func (s deliveryOrdersService) UpdateOne(c *fiber.Ctx, req *validation.DeliveryO
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to update delivery order")
 	}
 
+	s.reallocateAfterDelivery(c.Context(), id, capturedCustomerID)
+
 	return s.getMarketingWithDeliveries(c, id)
 }
 

internal/modules/master/production-standards/services/production-standard.service.go

@@ -387,16 +387,12 @@ func (s productionStandardService) EnsureWeekAvailable(ctx context.Context, stan
 		return nil
 	}
 
-	upperCategory := strings.ToUpper(category)
-	weekBase := 1
-	if upperCategory == string(utils.ProjectFlockCategoryLaying) {
-		weekBase = config.LayingWeekStart()
-	}
-	week := ((day - 1) / 7) + weekBase
+	week := ((day - 1) / 7) + 1
 	if week <= 0 {
 		return nil
 	}
 
+	upperCategory := strings.ToUpper(category)
 	if upperCategory == string(utils.ProjectFlockCategoryLaying) {
 		detail, err := s.ProductionStandardDetailRepo.GetByStandardIDAndWeek(ctx, standardID, week)
 		if err != nil {

internal/modules/production/project_flocks/controllers/projectflock.controller.go

@@ -312,10 +312,10 @@ func (u *ProjectflockController) LookupProjectFlockKandang(c *fiber.Ctx) error {
 		mapped := warehouseDTO.ToWarehouseRelationDTO(*warehouse)
 		dtoResult.Warehouse = &mapped
 	}
-	if _, isLaying, serr := u.ProjectflockService.GetProjectFlockKandangTransferStateAtDate(c, result.Id, recordDate); serr != nil {
+	if isTransition, isLaying, serr := u.ProjectflockService.GetProjectFlockKandangTransferStateAtDate(c, result.Id, recordDate); serr != nil {
 		return serr
 	} else {
-		dtoResult.IsTransition = false
+		dtoResult.IsTransition = isTransition
 		dtoResult.IsLaying = isLaying
 	}
 	applyCutOverLayingLookupOverride(&dtoResult)
@@ -346,7 +346,7 @@ func (u *ProjectflockController) LookupProjectFlockKandang(c *fiber.Ctx) error {
 }
 
 func applyCutOverLayingLookupOverride(result *dto.ProjectFlockKandangDTO) {
-	if result == nil || result.ProjectFlock == nil || result.IsLaying || result.ChickInDate == nil {
+	if result == nil || result.ProjectFlock == nil || result.IsLaying || result.IsTransition || result.ChickInDate == nil {
 		return
 	}
 

internal/modules/production/project_flocks/services/projectflock.service.go

@@ -588,17 +588,29 @@ func (s projectflockService) GetProjectFlockKandangTransferStateAtDate(ctx *fibe
 	switch category {
 	case strings.ToUpper(string(utils.ProjectFlockCategoryGrowing)):
 		transfer, err = s.TransferLayingRepo.GetLatestApprovedBySourceKandang(ctx.Context(), projectFlockKandangID)
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return false, false, nil
+			}
+			s.Log.Errorf("Failed to resolve transfer state for project flock kandang %d: %+v", projectFlockKandangID, err)
+			return false, false, fiber.NewError(fiber.StatusInternalServerError, "Failed to resolve transfer state")
+		}
 	case strings.ToUpper(string(utils.ProjectFlockCategoryLaying)):
-		transfer, err = s.TransferLayingRepo.GetLatestApprovedByTargetKandang(ctx.Context(), projectFlockKandangID)
-	default:
-		return false, false, nil
-	}
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
+		// Multi-source: target kandang bisa menerima dari multiple transfer terpisah. Pakai
+		// EARLIEST transfer (transfer_date ASC) sebagai anchor — kandang masuk transition/laying
+		// mengikuti batch pertama yang sampai.
+		allTransfers, allErr := s.TransferLayingRepo.GetAllApprovedByTargetKandang(ctx.Context(), projectFlockKandangID)
+		if allErr != nil {
+			s.Log.Errorf("Failed to resolve transfers for project flock kandang %d: %+v", projectFlockKandangID, allErr)
+			return false, false, fiber.NewError(fiber.StatusInternalServerError, "Failed to resolve transfer state")
+		}
+		if len(allTransfers) == 0 {
 			return false, false, nil
 		}
-		s.Log.Errorf("Failed to resolve transfer state for project flock kandang %d: %+v", projectFlockKandangID, err)
-		return false, false, fiber.NewError(fiber.StatusInternalServerError, "Failed to resolve transfer state")
+		// Repository ORDER BY transfer_date ASC, id ASC → [0] = earliest
+		transfer = &allTransfers[0]
+	default:
+		return false, false, nil
 	}
 	if transfer == nil {
 		return false, false, nil

internal/modules/production/recordings/services/recording.service.go

@@ -198,10 +198,22 @@ func (s recordingService) GetAll(c *fiber.Ctx, params *validation.Query) ([]enti
 	if err != nil {
 		return nil, 0, err
 	}
-	targetTransferByPFK, err := s.TransferLayingRepo.GetLatestApprovedByTargetKandangs(c.Context(), layingPFKIDs)
+	// Multi-source support: 1 target kandang bisa menerima dari multiple transfer terpisah.
+	// Untuk state evaluation (IsTransition/IsLaying), kita pakai EARLIEST transfer sebagai anchor
+	// (sesuai dengan rule "kandang masuk fase laying mengikuti batch pertama yang sampai").
+	allTransfersByTarget, err := s.TransferLayingRepo.GetAllApprovedByTargetKandangs(c.Context(), layingPFKIDs)
 	if err != nil {
 		return nil, 0, err
 	}
+	targetTransferByPFK := make(map[uint]*entity.LayingTransfer, len(allTransfersByTarget))
+	for pfkID, list := range allTransfersByTarget {
+		if len(list) == 0 {
+			continue
+		}
+		// list sudah ORDER BY transfer_date ASC, id ASC → element [0] adalah earliest
+		earliest := list[0]
+		targetTransferByPFK[pfkID] = &earliest
+	}
 	hasTargetRecordingCache := make(map[uint]bool)
 
 	cutOverChickinAvailability := make(map[uint]bool)
@@ -1292,17 +1304,29 @@ func (s *recordingService) evaluatePopulationMutationState(ctx context.Context,
 	switch category {
 	case strings.ToUpper(string(utils.ProjectFlockCategoryGrowing)):
 		transfer, err = s.TransferLayingRepo.GetLatestApprovedBySourceKandang(ctx, recording.ProjectFlockKandangId)
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return true, false, false, false, nil, time.Time{}, nil
+			}
+			s.Log.Errorf("Failed to resolve approved transfer for recording %d: %+v", recording.Id, err)
+			return true, false, false, false, nil, time.Time{}, fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi perubahan populasi recording")
+		}
 	case strings.ToUpper(string(utils.ProjectFlockCategoryLaying)):
-		transfer, err = s.TransferLayingRepo.GetLatestApprovedByTargetKandang(ctx, recording.ProjectFlockKandangId)
-	default:
-		return true, false, false, false, nil, time.Time{}, nil
-	}
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
+		// Multi-source: target kandang bisa menerima dari multiple transfer terpisah.
+		// Pakai EARLIEST transfer (transfer_date ASC) sebagai anchor untuk state evaluation —
+		// kandang dianggap masuk transition/laying berdasarkan batch pertama yang masuk.
+		allTransfers, allErr := s.TransferLayingRepo.GetAllApprovedByTargetKandang(ctx, recording.ProjectFlockKandangId)
+		if allErr != nil {
+			s.Log.Errorf("Failed to resolve approved transfers for recording %d: %+v", recording.Id, allErr)
+			return true, false, false, false, nil, time.Time{}, fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi perubahan populasi recording")
+		}
+		if len(allTransfers) == 0 {
 			return true, false, false, false, nil, time.Time{}, nil
 		}
-		s.Log.Errorf("Failed to resolve approved transfer for recording %d: %+v", recording.Id, err)
-		return true, false, false, false, nil, time.Time{}, fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi perubahan populasi recording")
+		// Repository sudah ORDER BY transfer_date ASC, id ASC → element [0] adalah earliest.
+		transfer = &allTransfers[0]
+	default:
+		return true, false, false, false, nil, time.Time{}, nil
 	}
 	if transfer == nil {
 		return true, false, false, false, nil, time.Time{}, nil

internal/modules/production/transfer_layings/repositories/laying_transfer.repository.go

@@ -19,6 +19,11 @@ type TransferLayingRepository interface {
 	GetLatestApprovedByTargetKandang(ctx context.Context, targetProjectFlockKandangID uint) (*entity.LayingTransfer, error)
 	GetLatestApprovedBySourceKandangs(ctx context.Context, pfkIDs []uint) (map[uint]*entity.LayingTransfer, error)
 	GetLatestApprovedByTargetKandangs(ctx context.Context, pfkIDs []uint) (map[uint]*entity.LayingTransfer, error)
+	// GetAllApprovedByTargetKandang return semua approved transfer yang menuju ke target kandang itu.
+	// Dipakai untuk multi-source case di mana 1 target kandang bisa menerima dari multiple transfer
+	// terpisah (tiap transfer = 1 source). Order: transfer_date ASC, id ASC (kronologis).
+	GetAllApprovedByTargetKandang(ctx context.Context, targetProjectFlockKandangID uint) ([]entity.LayingTransfer, error)
+	GetAllApprovedByTargetKandangs(ctx context.Context, pfkIDs []uint) (map[uint][]entity.LayingTransfer, error)
 
 	// Tambah method baru untuk query dengan filter lengkap
 	GetAllWithFilters(ctx context.Context, offset int, limit int, params *GetAllFilterParams) ([]entity.LayingTransfer, int64, error)
@@ -362,3 +367,89 @@ func (r *TransferLayingRepositoryImpl) GetLatestApprovedByTargetKandangs(ctx con
 	}
 	return result, nil
 }
+
+// GetAllApprovedByTargetKandang return SEMUA approved transfer ke target kandang itu (bukan hanya yang
+// terbaru). Dipakai untuk skenario multi-source di mana 1 target kandang menerima dari multiple transfer
+// terpisah, sehingga depresiasi/HPP/recording state perlu aggregate dari semua transfer.
+func (r *TransferLayingRepositoryImpl) GetAllApprovedByTargetKandang(ctx context.Context, targetProjectFlockKandangID uint) ([]entity.LayingTransfer, error) {
+	if targetProjectFlockKandangID == 0 {
+		return nil, nil
+	}
+
+	var transfers []entity.LayingTransfer
+	err := r.db.WithContext(ctx).
+		Model(&entity.LayingTransfer{}).
+		Joins("JOIN laying_transfer_targets ltt ON ltt.laying_transfer_id = laying_transfers.id AND ltt.deleted_at IS NULL").
+		Where("ltt.target_project_flock_kandang_id = ?", targetProjectFlockKandangID).
+		Where("laying_transfers.deleted_at IS NULL").
+		Where(`(
+			SELECT a.action
+			FROM approvals a
+			WHERE a.approvable_type = ?
+			  AND a.approvable_id = laying_transfers.id
+			ORDER BY a.id DESC
+			LIMIT 1
+		) = ?`, string(utils.ApprovalWorkflowTransferToLaying), entity.ApprovalActionApproved).
+		Order("laying_transfers.transfer_date ASC, laying_transfers.id ASC").
+		Distinct("laying_transfers.*").
+		Find(&transfers).Error
+	if err != nil {
+		return nil, err
+	}
+	return transfers, nil
+}
+
+// GetAllApprovedByTargetKandangs batch version: return map dari target_pfk_id ke list of approved transfers.
+// Order per target: transfer_date ASC, id ASC.
+func (r *TransferLayingRepositoryImpl) GetAllApprovedByTargetKandangs(ctx context.Context, pfkIDs []uint) (map[uint][]entity.LayingTransfer, error) {
+	result := make(map[uint][]entity.LayingTransfer)
+	if len(pfkIDs) == 0 {
+		return result, nil
+	}
+
+	type targetTransferRow struct {
+		TargetPFKID uint `gorm:"column:target_pfk_id"`
+		TransferID  uint `gorm:"column:transfer_id"`
+	}
+
+	var rows []targetTransferRow
+	err := r.db.WithContext(ctx).Raw(`
+		SELECT ltt.target_project_flock_kandang_id AS target_pfk_id, ltt.laying_transfer_id AS transfer_id
+		FROM laying_transfer_targets ltt
+		JOIN laying_transfers t ON t.id = ltt.laying_transfer_id AND t.deleted_at IS NULL
+		WHERE ltt.target_project_flock_kandang_id IN ?
+		  AND ltt.deleted_at IS NULL
+		  AND (
+		      SELECT a.action FROM approvals a
+		      WHERE a.approvable_type = ? AND a.approvable_id = t.id
+		      ORDER BY a.id DESC LIMIT 1
+		  ) = ?
+		ORDER BY t.transfer_date ASC, t.id ASC
+	`,
+		pfkIDs, string(utils.ApprovalWorkflowTransferToLaying), string(entity.ApprovalActionApproved),
+	).Scan(&rows).Error
+	if err != nil {
+		return nil, err
+	}
+	if len(rows) == 0 {
+		return result, nil
+	}
+
+	transferIDs := make([]uint, 0, len(rows))
+	targetsByTransfer := make(map[uint][]uint, len(rows))
+	for _, row := range rows {
+		transferIDs = append(transferIDs, row.TransferID)
+		targetsByTransfer[row.TransferID] = append(targetsByTransfer[row.TransferID], row.TargetPFKID)
+	}
+
+	var transfers []entity.LayingTransfer
+	if err := r.db.WithContext(ctx).Where("id IN ? AND deleted_at IS NULL", transferIDs).Order("transfer_date ASC, id ASC").Find(&transfers).Error; err != nil {
+		return nil, err
+	}
+	for i := range transfers {
+		for _, targetID := range targetsByTransfer[transfers[i].Id] {
+			result[targetID] = append(result[targetID], transfers[i])
+		}
+	}
+	return result, nil
+}

internal/modules/production/transfer_layings/services/transfer_laying.service.go

@@ -1617,6 +1617,13 @@ func (s *transferLayingService) validateKandangOwnership(
 	return nil
 }
 
+// validateTargetSourceLineage memvalidasi bahwa source kandang yang sama TIDAK boleh ditransfer 2x ke
+// target kandang yang sama (anti-duplicate pair). Aturan lama "satu target hanya boleh punya satu
+// source" sudah dihapus — sekarang 1 target boleh menerima dari multiple source kandang via transfer
+// terpisah (multi-source via N-call approach).
+//
+// Yang ditolak: kalau ada approved transfer lain (id != excludeTransferID) yang punya pair
+// (source = sourceProjectFlockKandangID, target ∈ targetKandangIDs) yang sama.
 func (s *transferLayingService) validateTargetSourceLineage(
 	ctx context.Context,
 	sourceProjectFlockKandangID uint,
@@ -1637,7 +1644,7 @@ func (s *transferLayingService) validateTargetSourceLineage(
 		}
 		seen[targetKandangID] = struct{}{}
 
-		existingTransfer, err := s.Repository.GetLatestApprovedByTargetKandang(ctx, targetKandangID)
+		existingTransfers, err := s.Repository.GetAllApprovedByTargetKandang(ctx, targetKandangID)
 		if err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
 				continue
@@ -1645,47 +1652,49 @@ func (s *transferLayingService) validateTargetSourceLineage(
 			s.Log.Errorf("Failed to validate transfer lineage for target kandang %d: %+v", targetKandangID, err)
 			return fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi relasi sumber transfer ke laying")
 		}
-		if existingTransfer == nil {
-			continue
-		}
-		if excludeTransferID != 0 && existingTransfer.Id == excludeTransferID {
-			continue
-		}
 
-		existingSourceID := uint(0)
-		if existingTransfer.SourceProjectFlockKandangId != nil && *existingTransfer.SourceProjectFlockKandangId != 0 {
-			existingSourceID = *existingTransfer.SourceProjectFlockKandangId
-		}
-		if existingSourceID == 0 && s.LayingTransferSourceRepo != nil {
-			sources, sourceErr := s.LayingTransferSourceRepo.GetByLayingTransferId(ctx, existingTransfer.Id)
-			if sourceErr != nil {
-				s.Log.Errorf("Failed to resolve transfer sources for lineage validation transfer=%d: %+v", existingTransfer.Id, sourceErr)
-				return fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi relasi sumber transfer ke laying")
+		for i := range existingTransfers {
+			existingTransfer := &existingTransfers[i]
+			if excludeTransferID != 0 && existingTransfer.Id == excludeTransferID {
+				continue
 			}
-			for _, source := range sources {
-				if source.SourceProjectFlockKandangId != 0 {
-					existingSourceID = source.SourceProjectFlockKandangId
-					break
+
+			// Source di header (single source of truth per migration 20260307130342).
+			existingSourceID := uint(0)
+			if existingTransfer.SourceProjectFlockKandangId != nil && *existingTransfer.SourceProjectFlockKandangId != 0 {
+				existingSourceID = *existingTransfer.SourceProjectFlockKandangId
+			}
+
+			// Fallback ke laying_transfer_sources untuk transfer yang belum punya source di header
+			// (historis pre-migration 20260307130342).
+			if existingSourceID == 0 && s.LayingTransferSourceRepo != nil {
+				sources, sourceErr := s.LayingTransferSourceRepo.GetByLayingTransferId(ctx, existingTransfer.Id)
+				if sourceErr != nil {
+					s.Log.Errorf("Failed to resolve transfer sources for lineage validation transfer=%d: %+v", existingTransfer.Id, sourceErr)
+					return fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi relasi sumber transfer ke laying")
+				}
+				for _, source := range sources {
+					if source.SourceProjectFlockKandangId == sourceProjectFlockKandangID {
+						existingSourceID = source.SourceProjectFlockKandangId
+						break
+					}
 				}
 			}
-		}
-		if existingSourceID == 0 {
-			continue
-		}
-		if existingSourceID == sourceProjectFlockKandangID {
-			continue
-		}
 
-		return fiber.NewError(
-			fiber.StatusBadRequest,
-			fmt.Sprintf(
-				"Kandang tujuan %d sudah memiliki lineage sumber kandang %d dari transfer %s. Tidak boleh ganti ke sumber kandang %d.",
-				targetKandangID,
-				existingSourceID,
-				existingTransfer.TransferNumber,
-				sourceProjectFlockKandangID,
-			),
-		)
+			if existingSourceID != sourceProjectFlockKandangID {
+				continue
+			}
+
+			return fiber.NewError(
+				fiber.StatusBadRequest,
+				fmt.Sprintf(
+					"Source kandang %d sudah pernah ditransfer ke target kandang %d via transfer %s. Tidak boleh duplikat (source, target) pair yang sama.",
+					sourceProjectFlockKandangID,
+					targetKandangID,
+					existingTransfer.TransferNumber,
+				),
+			)
+		}
 	}
 
 	return nil

internal/modules/purchases/controllers/purchase.export.go

@@ -435,6 +435,21 @@ func formatPurchaseExportEntityStatus(purchase *entity.Purchase) string {
 	return safePurchaseExportText(purchase.LatestApproval.StepName)
 }
 
+var purchaseIndonesianMonths = map[time.Month]string{
+	time.January:   "Jan",
+	time.February:  "Feb",
+	time.March:     "Mar",
+	time.April:     "Apr",
+	time.May:       "Mei",
+	time.June:      "Jun",
+	time.July:      "Jul",
+	time.August:    "Ags",
+	time.September: "Sep",
+	time.October:   "Okt",
+	time.November:  "Nov",
+	time.December:  "Des",
+}
+
 func formatPurchaseExportDate(value *time.Time) string {
 	if value == nil || value.IsZero() {
 		return "-"
@@ -446,7 +461,8 @@ func formatPurchaseExportDate(value *time.Time) string {
 		t = t.In(location)
 	}
 
-	return t.Format("02-01-2006")
+	month := purchaseIndonesianMonths[t.Month()]
+	return fmt.Sprintf("%d-%s-%02d", t.Day(), month, t.Year()%100)
 }
 
 func safePurchaseExportPointerText(value *string) string {

internal/modules/purchases/module.go

@@ -61,6 +61,7 @@ func (PurchaseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		expenseRealizationRepo,
 		projectFlockKandangRepository,
 		documentSvc,
+		commonSvc.NewFifoPaymentService(db, utils.Log),
 		validate,
 	)
 	expenseBridge := service.NewExpenseBridge(
@@ -72,6 +73,7 @@ func (PurchaseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	)
 
 	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
+	fifoPaymentService := commonSvc.NewFifoPaymentService(db, utils.Log)
 
 	purchaseService := service.NewPurchaseService(
 		validate,
@@ -84,6 +86,7 @@ func (PurchaseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		approvalService,
 		expenseBridge,
 		fifoStockV2Service,
+		fifoPaymentService,
 		documentSvc,
 	)
 

internal/modules/purchases/repositories/purchase.repository.go

@@ -24,7 +24,6 @@ type PurchaseRepository interface {
 	UpdateReceivingDetails(ctx context.Context, purchaseID uint, updates []PurchaseReceivingUpdate) error
 	DeleteItems(ctx context.Context, purchaseID uint, itemIDs []uint) error
 	NextPrNumber(ctx context.Context, tx *gorm.DB) (string, error)
-	NextPoNumber(ctx context.Context, tx *gorm.DB) (string, error)
 	BackfillProjectFlockKandang(ctx context.Context, purchaseID uint) error
 	SoftDeleteByProjectFlockKandangIDs(ctx context.Context, projectFlockKandangIDs []uint) error
 	GetItemsByProjectFlockID(ctx context.Context, projectFlockID uint) ([]entity.PurchaseItem, error)
@@ -369,9 +368,8 @@ func (r *PurchaseRepositoryImpl) NextPrNumber(ctx context.Context, tx *gorm.DB)
 	return r.generateSequentialNumber(ctx, tx, "pr_number", utils.PurchasePRNumberPrefix, utils.PurchaseNumberPadding)
 }
 
-func (r *PurchaseRepositoryImpl) NextPoNumber(ctx context.Context, tx *gorm.DB) (string, error) {
-	return r.generateSequentialNumber(ctx, tx, "po_number", utils.PurchasePONumberPrefix, utils.PurchaseNumberPadding)
-}
+// NOTE: NextPoNumber dihapus per migration 20260529143940 — po_number sekarang
+// di-derive dari pr_number (swap prefix) via derivePoFromPr di purchase.service.go.
 
 func (r *PurchaseRepositoryImpl) generateSequentialNumber(ctx context.Context, tx *gorm.DB, column, prefix string, padding int) (string, error) {
 	db := tx

internal/modules/purchases/services/purchase.service.go

@@ -64,6 +64,7 @@ type purchaseService struct {
 	ApprovalSvc             commonSvc.ApprovalService
 	ExpenseBridge           PurchaseExpenseBridge
 	FifoStockV2Svc          commonSvc.FifoStockV2Service
+	FifoPaymentSvc          commonSvc.FifoPaymentService
 	DocumentSvc             commonSvc.DocumentService
 	approvalWorkflow        approvalutils.ApprovalWorkflowKey
 }
@@ -91,6 +92,7 @@ func NewPurchaseService(
 	approvalSvc commonSvc.ApprovalService,
 	expenseBridge PurchaseExpenseBridge,
 	fifoStockV2Svc commonSvc.FifoStockV2Service,
+	fifoPaymentSvc commonSvc.FifoPaymentService,
 	documentSvc commonSvc.DocumentService,
 ) PurchaseService {
 	return &purchaseService{
@@ -105,6 +107,7 @@ func NewPurchaseService(
 		ApprovalSvc:             approvalSvc,
 		ExpenseBridge:           expenseBridge,
 		FifoStockV2Svc:          fifoStockV2Svc,
+		FifoPaymentSvc:          fifoPaymentSvc,
 		DocumentSvc:             documentSvc,
 		approvalWorkflow:        utils.ApprovalWorkflowPurchase,
 	}
@@ -264,6 +267,14 @@ func (s *purchaseService) GetAll(c *fiber.Ctx, params *validation.Query) ([]enti
 
 		sortBy := strings.TrimSpace(params.SortBy)
 		sortOrder := strings.ToUpper(strings.TrimSpace(params.SortOrder))
+
+		if sortBy == "" && (filterBy == "po_date" || filterBy == "due_date" || filterBy == "received_date" || filterBy == "created_at") {
+			sortBy = filterBy
+			if sortOrder == "" {
+				sortOrder = "ASC"
+			}
+		}
+
 		if sortOrder == "" {
 			sortOrder = "DESC"
 		}
@@ -768,8 +779,7 @@ func (s *purchaseService) ApproveManagerPurchase(c *fiber.Ctx, id uint, req *val
 	transactionErr := s.PurchaseRepo.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
 		updateData := map[string]any{}
 		if !hasExistingPO {
-			repoTx := rPurchase.NewPurchaseRepository(tx)
-			code, err := repoTx.NextPoNumber(c.Context(), tx)
+			code, err := derivePoFromPr(purchase.PrNumber)
 			if err != nil {
 				return err
 			}
@@ -1398,6 +1408,16 @@ func (s *purchaseService) ReceiveProducts(c *fiber.Ctx, id uint, req *validation
 		return nil, err
 	}
 
+	// Refresh purchase.grand_total + reallocate payment FIFO untuk supplier (new debt baru emerges).
+	if s.FifoPaymentSvc != nil && receivingAction == entity.ApprovalActionApproved {
+		if err := s.FifoPaymentSvc.RecomputeGrandTotal(c.Context(), nil, commonSvc.ParentKindPurchase, purchase.Id); err != nil {
+			s.Log.Warnf("Failed to recompute grand_total for purchase %d: %+v", purchase.Id, err)
+		}
+		if err := s.FifoPaymentSvc.ReallocateForParty(c.Context(), nil, string(utils.PaymentPartySupplier), uint(purchase.SupplierId)); err != nil {
+			s.Log.Warnf("Failed to reallocate payments for supplier %d: %+v", purchase.SupplierId, err)
+		}
+	}
+
 	return updated, nil
 }
 
@@ -2240,6 +2260,11 @@ func (s *purchaseService) attachLatestApprovals(ctx context.Context, items []ent
 }
 
 func parsePurchaseDateRangeForQuery(fromStr, toStr, fieldName string) (*time.Time, *time.Time, error) {
+	jakartaLoc, err := time.LoadLocation("Asia/Jakarta")
+	if err != nil {
+		jakartaLoc = time.FixedZone("WIB", 7*60*60)
+	}
+
 	var fromPtr *time.Time
 	var toPtr *time.Time
 
@@ -2248,7 +2273,8 @@ func parsePurchaseDateRangeForQuery(fromStr, toStr, fieldName string) (*time.Tim
 		if err != nil {
 			return nil, nil, errors.New(fieldName + "_from must use format YYYY-MM-DD")
 		}
-		fromPtr = &parsed
+		t := time.Date(parsed.Year(), parsed.Month(), parsed.Day(), 0, 0, 0, 0, jakartaLoc)
+		fromPtr = &t
 	}
 
 	if strings.TrimSpace(toStr) != "" {
@@ -2256,7 +2282,8 @@ func parsePurchaseDateRangeForQuery(fromStr, toStr, fieldName string) (*time.Tim
 		if err != nil {
 			return nil, nil, errors.New(fieldName + "_to must use format YYYY-MM-DD")
 		}
-		nextDay := parsed.AddDate(0, 0, 1)
+		t := time.Date(parsed.Year(), parsed.Month(), parsed.Day(), 0, 0, 0, 0, jakartaLoc)
+		nextDay := t.AddDate(0, 0, 1)
 		toPtr = &nextDay
 	}
 
@@ -2485,6 +2512,18 @@ func parseApprovalActionInput(raw string) (entity.ApprovalAction, error) {
 	}
 }
 
+// derivePoFromPr menghasilkan po_number dari pr_number dengan swap prefix.
+// Contoh: "PR-LTI-0050" -> "PO-LTI-0050". Mengembalikan error kalau pr_number
+// tidak diawali prefix standar — caller harus memastikan PR sudah valid.
+func derivePoFromPr(prNumber string) (string, error) {
+	trimmed := strings.TrimSpace(prNumber)
+	if !strings.HasPrefix(trimmed, utils.PurchasePRNumberPrefix) {
+		return "", fmt.Errorf("invalid pr_number %q: missing prefix %q", trimmed, utils.PurchasePRNumberPrefix)
+	}
+	suffix := strings.TrimPrefix(trimmed, utils.PurchasePRNumberPrefix)
+	return utils.PurchasePONumberPrefix + suffix, nil
+}
+
 func (s *purchaseService) rejectAndReload(
 	c *fiber.Ctx,
 	step approvalutils.ApprovalStep,

internal/modules/repports/controllers/repport.balance_monitoring.export.go

@@ -0,0 +1,286 @@
+package controller
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/xuri/excelize/v2"
+	"gitlab.com/mbugroup/lti-api.git/internal/modules/repports/dto"
+)
+
+func isBalanceMonitoringExcelExportRequest(c *fiber.Ctx) bool {
+	return strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel")
+}
+
+func exportBalanceMonitoringExcel(c *fiber.Ctx, items []dto.BalanceMonitoringRowDTO, totals dto.BalanceMonitoringTotalsDTO) error {
+	content, err := buildBalanceMonitoringWorkbook(items, totals)
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
+	}
+
+	filename := fmt.Sprintf("laporan-balance-monitoring-%s.xlsx", time.Now().Format("2006-01-02-1504"))
+	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(content)
+}
+
+func buildBalanceMonitoringWorkbook(items []dto.BalanceMonitoringRowDTO, totals dto.BalanceMonitoringTotalsDTO) ([]byte, error) {
+	file := excelize.NewFile()
+	defer file.Close()
+
+	const sheet = "Balance Monitoring"
+	defaultSheet := file.GetSheetName(file.GetActiveSheetIndex())
+	if defaultSheet != sheet {
+		if err := file.SetSheetName(defaultSheet, sheet); err != nil {
+			return nil, err
+		}
+	}
+
+	if err := setBalanceMonitoringColumns(file, sheet); err != nil {
+		return nil, err
+	}
+	if err := setBalanceMonitoringHeaders(file, sheet); err != nil {
+		return nil, err
+	}
+	if err := writeBalanceMonitoringRows(file, sheet, items, totals); err != nil {
+		return nil, err
+	}
+	if err := file.SetPanes(sheet, &excelize.Panes{
+		Freeze:      true,
+		YSplit:      2,
+		TopLeftCell: "A3",
+		ActivePane:  "bottomLeft",
+	}); err != nil {
+		return nil, err
+	}
+
+	buf, err := file.WriteToBuffer()
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+var bmColumnWidths = map[string]float64{
+	"A": 5,
+	"B": 28,
+	"C": 18,
+	"D": 12,
+	"E": 12,
+	"F": 20,
+	"G": 12,
+	"H": 12,
+	"I": 20,
+	"J": 20,
+	"K": 18,
+	"L": 12,
+	"M": 16,
+	"N": 20,
+}
+
+func setBalanceMonitoringColumns(file *excelize.File, sheet string) error {
+	for col, width := range bmColumnWidths {
+		if err := file.SetColWidth(sheet, col, col, width); err != nil {
+			return err
+		}
+	}
+	if err := file.SetRowHeight(sheet, 1, 24); err != nil {
+		return err
+	}
+	return file.SetRowHeight(sheet, 2, 24)
+}
+
+func setBalanceMonitoringHeaders(file *excelize.File, sheet string) error {
+	borderStyle := []excelize.Border{
+		{Type: "left", Color: "000000", Style: 1},
+		{Type: "top", Color: "000000", Style: 1},
+		{Type: "bottom", Color: "000000", Style: 1},
+		{Type: "right", Color: "000000", Style: 1},
+	}
+	headerStyle, err := file.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Color: "FFFFFF", Family: "Arial", Size: 10},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"4472C4"}},
+		Alignment: &excelize.Alignment{
+			Horizontal: "center",
+			Vertical:   "center",
+			WrapText:   true,
+		},
+		Border: borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	// Single-column headers: merge rows 1 and 2 vertically
+	singleColHeaders := map[string]string{
+		"A": "No",
+		"B": "Customer",
+		"C": "Saldo Awal",
+		"J": "Penjualan Trading",
+		"K": "Pembayaran",
+		"L": "Aging",
+		"M": "Aging Rata-Rata",
+		"N": "Saldo Akhir",
+	}
+	for col, header := range singleColHeaders {
+		if err := file.SetCellValue(sheet, col+"1", header); err != nil {
+			return err
+		}
+		if err := file.MergeCell(sheet, col+"1", col+"2"); err != nil {
+			return err
+		}
+	}
+
+	// Group headers: merge columns horizontally in row 1
+	if err := file.SetCellValue(sheet, "D1", "Penjualan Ayam"); err != nil {
+		return err
+	}
+	if err := file.MergeCell(sheet, "D1", "F1"); err != nil {
+		return err
+	}
+	if err := file.SetCellValue(sheet, "G1", "Penjualan Telur"); err != nil {
+		return err
+	}
+	if err := file.MergeCell(sheet, "G1", "I1"); err != nil {
+		return err
+	}
+
+	// Sub-column headers in row 2
+	subHeaders := map[string]string{
+		"D": "Ekor",
+		"E": "Kg",
+		"F": "Nominal",
+		"G": "Butir",
+		"H": "Kg",
+		"I": "Nominal",
+	}
+	for col, header := range subHeaders {
+		if err := file.SetCellValue(sheet, col+"2", header); err != nil {
+			return err
+		}
+	}
+
+	return file.SetCellStyle(sheet, "A1", "N2", headerStyle)
+}
+
+func writeBalanceMonitoringRows(file *excelize.File, sheet string, items []dto.BalanceMonitoringRowDTO, totals dto.BalanceMonitoringTotalsDTO) error {
+	borderStyle := []excelize.Border{
+		{Type: "left", Color: "000000", Style: 1},
+		{Type: "top", Color: "000000", Style: 1},
+		{Type: "bottom", Color: "000000", Style: 1},
+		{Type: "right", Color: "000000", Style: 1},
+	}
+
+	dataStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Color: "000000", Family: "Arial", Size: 10},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	totalStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Bold: true, Color: "000000", Family: "Arial", Size: 10},
+		Fill:      excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"E2EFDA"}},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	redDataStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Color: "FF0000", Family: "Arial", Size: 10},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	redTotalStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Bold: true, Color: "FF0000", Family: "Arial", Size: 10},
+		Fill:      excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"E2EFDA"}},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	for i, row := range items {
+		rowNum := i + 3
+		rowStr := strconv.Itoa(rowNum)
+
+		cells := map[string]interface{}{
+			"A": i + 1,
+			"B": row.Customer.Name,
+			"C": row.SaldoAwal,
+			"D": row.PenjualanAyam.Ekor,
+			"E": row.PenjualanAyam.Kg,
+			"F": row.PenjualanAyam.Nominal,
+			"G": row.PenjualanTelur.Butir,
+			"H": row.PenjualanTelur.Kg,
+			"I": row.PenjualanTelur.Nominal,
+			"J": row.PenjualanTrading.Nominal,
+			"K": row.Pembayaran,
+			"L": fmt.Sprintf("%d hari", row.Aging),
+			"M": formatBMAging(row.AgingRataRata),
+			"N": row.SaldoAkhir,
+		}
+		for col, val := range cells {
+			if err := file.SetCellValue(sheet, col+rowStr, val); err != nil {
+				return err
+			}
+		}
+		if err := file.SetCellStyle(sheet, "A"+rowStr, "N"+rowStr, dataStyle); err != nil {
+			return err
+		}
+		if row.SaldoAkhir < 0 {
+			if err := file.SetCellStyle(sheet, "N"+rowStr, "N"+rowStr, redDataStyle); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Totals row
+	totalRowStr := strconv.Itoa(len(items) + 3)
+	totalCells := map[string]interface{}{
+		"A": "Total",
+		"C": totals.SaldoAwal,
+		"D": totals.PenjualanAyam.Ekor,
+		"E": totals.PenjualanAyam.Kg,
+		"F": totals.PenjualanAyam.Nominal,
+		"G": totals.PenjualanTelur.Butir,
+		"H": totals.PenjualanTelur.Kg,
+		"I": totals.PenjualanTelur.Nominal,
+		"J": totals.PenjualanTrading.Nominal,
+		"K": totals.Pembayaran,
+		"N": totals.SaldoAkhir,
+	}
+	for col, val := range totalCells {
+		if err := file.SetCellValue(sheet, col+totalRowStr, val); err != nil {
+			return err
+		}
+	}
+	if err := file.SetCellStyle(sheet, "A"+totalRowStr, "N"+totalRowStr, totalStyle); err != nil {
+		return err
+	}
+	if totals.SaldoAkhir < 0 {
+		if err := file.SetCellStyle(sheet, "N"+totalRowStr, "N"+totalRowStr, redTotalStyle); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func formatBMAging(v float64) string {
+	s := strconv.FormatFloat(v, 'f', 2, 64)
+	s = strings.ReplaceAll(s, ".", ",")
+	return s + " hari"
+}

internal/modules/repports/controllers/repport.controller.go

@@ -324,6 +324,13 @@ func (c *RepportController) GetPurchaseSupplier(ctx *fiber.Ctx) error {
 		return err
 	}
 
+	if isPurchaseSupplierExcelExportRequest(ctx) {
+		return exportPurchaseSupplierExcel(ctx, result)
+	}
+	if isPurchaseSupplierExcelAllExportRequest(ctx) {
+		return exportPurchaseSupplierExcelAll(ctx, result)
+	}
+
 	filters := map[string]interface{}{
 		"area_id":             query.AreaIDs,
 		"supplier_id":         query.SupplierIDs,
@@ -555,6 +562,10 @@ func (c *RepportController) GetBalanceMonitoring(ctx *fiber.Ctx) error {
 		return err
 	}
 
+	if isBalanceMonitoringExcelExportRequest(ctx) {
+		return exportBalanceMonitoringExcel(ctx, result, totals)
+	}
+
 	limit := query.Limit
 	if limit < 1 {
 		limit = 10

internal/modules/repports/controllers/repport.purchase_supplier.export.go

@@ -0,0 +1,415 @@
+package controller
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/xuri/excelize/v2"
+	"gitlab.com/mbugroup/lti-api.git/internal/modules/repports/dto"
+)
+
+func isPurchaseSupplierExcelExportRequest(c *fiber.Ctx) bool {
+	return strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel")
+}
+
+func isPurchaseSupplierExcelAllExportRequest(c *fiber.Ctx) bool {
+	return strings.EqualFold(strings.TrimSpace(c.Query("export")), "excel-all")
+}
+
+func exportPurchaseSupplierExcel(c *fiber.Ctx, items []dto.PurchaseSupplierDTO) error {
+	content, err := buildPurchaseSupplierWorkbook(items)
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
+	}
+
+	filename := fmt.Sprintf("laporan-pembelian-supplier-%s.xlsx", time.Now().Format("2006-01-02-1504"))
+	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(content)
+}
+
+func exportPurchaseSupplierExcelAll(c *fiber.Ctx, items []dto.PurchaseSupplierDTO) error {
+	content, err := buildPurchaseSupplierAllWorkbook(items)
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "failed to generate excel file")
+	}
+
+	filename := fmt.Sprintf("laporan-pembelian-supplier-all-%s.xlsx", time.Now().Format("2006-01-02-1504"))
+	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(content)
+}
+
+// buildPurchaseSupplierWorkbook creates a workbook with one sheet per supplier.
+func buildPurchaseSupplierWorkbook(items []dto.PurchaseSupplierDTO) ([]byte, error) {
+	file := excelize.NewFile()
+	defer file.Close()
+
+	defaultSheet := file.GetSheetName(file.GetActiveSheetIndex())
+
+	if len(items) == 0 {
+		if err := writePurchaseSupplierSheet(file, defaultSheet, dto.PurchaseSupplierDTO{}); err != nil {
+			return nil, err
+		}
+		buf, err := file.WriteToBuffer()
+		if err != nil {
+			return nil, err
+		}
+		return buf.Bytes(), nil
+	}
+
+	for idx, item := range items {
+		sheetName := sanitizePurchaseSupplierSheetName(purchaseSupplierName(item))
+		if sheetName == "" {
+			sheetName = fmt.Sprintf("Supplier %d", idx+1)
+		}
+
+		if idx == 0 {
+			if defaultSheet != sheetName {
+				if err := file.SetSheetName(defaultSheet, sheetName); err != nil {
+					return nil, err
+				}
+			}
+		} else {
+			if _, err := file.NewSheet(sheetName); err != nil {
+				return nil, err
+			}
+		}
+
+		if err := writePurchaseSupplierSheet(file, sheetName, item); err != nil {
+			return nil, err
+		}
+	}
+
+	buf, err := file.WriteToBuffer()
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+// buildPurchaseSupplierAllWorkbook creates a single-sheet workbook with all suppliers.
+func buildPurchaseSupplierAllWorkbook(items []dto.PurchaseSupplierDTO) ([]byte, error) {
+	file := excelize.NewFile()
+	defer file.Close()
+
+	const sheet = "Rekap Pembelian Supplier"
+	defaultSheet := file.GetSheetName(file.GetActiveSheetIndex())
+	if defaultSheet != sheet {
+		if err := file.SetSheetName(defaultSheet, sheet); err != nil {
+			return nil, err
+		}
+	}
+
+	if err := setPurchaseSupplierAllColumns(file, sheet); err != nil {
+		return nil, err
+	}
+	if err := setPurchaseSupplierAllHeaders(file, sheet); err != nil {
+		return nil, err
+	}
+	if err := writePurchaseSupplierAllRows(file, sheet, items); err != nil {
+		return nil, err
+	}
+	if err := file.SetPanes(sheet, &excelize.Panes{
+		Freeze:      true,
+		YSplit:      1,
+		TopLeftCell: "A2",
+		ActivePane:  "bottomLeft",
+	}); err != nil {
+		return nil, err
+	}
+
+	buf, err := file.WriteToBuffer()
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+var purchaseSupplierSheetHeaders = []string{
+	"No",
+	"Tanggal Terima",
+	"Tanggal PO",
+	"No. Referensi",
+	"Nama Produk",
+	"Tujuan",
+	"QTY",
+	"Harga Beli (Rp)",
+	"Value Harga Beli (Rp)",
+	"Transport (Rp)",
+	"Value Transport (Rp)",
+	"Jumlah (Rp)",
+	"Ekspedisi",
+	"Surat Jalan",
+}
+
+var purchaseSupplierAllSheetHeaders = append([]string{"Supplier"}, purchaseSupplierSheetHeaders...)
+
+var purchaseSupplierSheetColumnWidths = map[string]float64{
+	"A": 5,
+	"B": 14,
+	"C": 12,
+	"D": 16,
+	"E": 20,
+	"F": 20,
+	"G": 10,
+	"H": 20,
+	"I": 20,
+	"J": 22,
+	"K": 22,
+	"L": 16,
+	"M": 20,
+	"N": 20,
+}
+
+var purchaseSupplierAllSheetColumnWidths = map[string]float64{
+	"A": 24,
+	"B": 6,
+	"C": 14,
+	"D": 12,
+	"E": 16,
+	"F": 20,
+	"G": 20,
+	"H": 10,
+	"I": 20,
+	"J": 20,
+	"K": 22,
+	"L": 22,
+	"M": 16,
+	"N": 20,
+	"O": 20,
+}
+
+func writePurchaseSupplierSheet(file *excelize.File, sheet string, item dto.PurchaseSupplierDTO) error {
+	for col, width := range purchaseSupplierSheetColumnWidths {
+		if err := file.SetColWidth(sheet, col, col, width); err != nil {
+			return err
+		}
+	}
+
+	for i, h := range purchaseSupplierSheetHeaders {
+		col, _ := excelize.ColumnNumberToName(i + 1)
+		if err := file.SetCellValue(sheet, col+"1", h); err != nil {
+			return err
+		}
+	}
+
+	for i, row := range item.Rows {
+		rowNum := i + 2
+		rowStr := fmt.Sprintf("%d", rowNum)
+
+		values := purchaseSupplierRowCells(row, i+1)
+		for colIdx, val := range values {
+			col, _ := excelize.ColumnNumberToName(colIdx + 1)
+			if err := file.SetCellValue(sheet, col+rowStr, val); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Summary row
+	totalRowNum := len(item.Rows) + 2
+	totalRowStr := fmt.Sprintf("%d", totalRowNum)
+	totalCells := map[string]interface{}{
+		"A": "Total",
+		"G": item.Summary.TotalQty,
+		"H": item.Summary.TotalUnitPrice,
+		"I": item.Summary.TotalPurchaseValue,
+		"J": item.Summary.TotalTransportUnitPrice,
+		"K": item.Summary.TotalTransportValue,
+		"L": item.Summary.TotalAmount,
+	}
+	for col, val := range totalCells {
+		if err := file.SetCellValue(sheet, col+totalRowStr, val); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func setPurchaseSupplierAllColumns(file *excelize.File, sheet string) error {
+	for col, width := range purchaseSupplierAllSheetColumnWidths {
+		if err := file.SetColWidth(sheet, col, col, width); err != nil {
+			return err
+		}
+	}
+	if err := file.SetRowHeight(sheet, 1, 24); err != nil {
+		return err
+	}
+	return nil
+}
+
+func setPurchaseSupplierAllHeaders(file *excelize.File, sheet string) error {
+	headerStyle, err := file.NewStyle(&excelize.Style{
+		Font: &excelize.Font{Bold: true, Color: "FFFFFF", Family: "Arial", Size: 10},
+		Fill: excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"4472C4"}},
+		Alignment: &excelize.Alignment{
+			Horizontal: "center",
+			Vertical:   "center",
+			WrapText:   true,
+		},
+		Border: []excelize.Border{
+			{Type: "left", Color: "000000", Style: 1},
+			{Type: "top", Color: "000000", Style: 1},
+			{Type: "bottom", Color: "000000", Style: 1},
+			{Type: "right", Color: "000000", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
+	}
+
+	for i, h := range purchaseSupplierAllSheetHeaders {
+		col, _ := excelize.ColumnNumberToName(i + 1)
+		if err := file.SetCellValue(sheet, col+"1", h); err != nil {
+			return err
+		}
+	}
+
+	lastCol, _ := excelize.ColumnNumberToName(len(purchaseSupplierAllSheetHeaders))
+	return file.SetCellStyle(sheet, "A1", lastCol+"1", headerStyle)
+}
+
+func writePurchaseSupplierAllRows(file *excelize.File, sheet string, items []dto.PurchaseSupplierDTO) error {
+	borderStyle := []excelize.Border{
+		{Type: "left", Color: "000000", Style: 1},
+		{Type: "top", Color: "000000", Style: 1},
+		{Type: "bottom", Color: "000000", Style: 1},
+		{Type: "right", Color: "000000", Style: 1},
+	}
+
+	dataStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Color: "000000", Family: "Arial", Size: 10},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	totalStyle, err := file.NewStyle(&excelize.Style{
+		Font:      &excelize.Font{Bold: true, Color: "000000", Family: "Arial", Size: 10},
+		Fill:      excelize.Fill{Type: "pattern", Pattern: 1, Color: []string{"E2EFDA"}},
+		Alignment: &excelize.Alignment{Vertical: "center", WrapText: true},
+		Border:    borderStyle,
+	})
+	if err != nil {
+		return err
+	}
+
+	lastHeaderCol, _ := excelize.ColumnNumberToName(len(purchaseSupplierAllSheetHeaders))
+
+	currentRow := 2
+	for _, item := range items {
+		supplierName := purchaseSupplierName(item)
+
+		// Data rows
+		for seq, row := range item.Rows {
+			rowStr := fmt.Sprintf("%d", currentRow)
+			if err := file.SetCellValue(sheet, "A"+rowStr, supplierName); err != nil {
+				return err
+			}
+			values := purchaseSupplierRowCells(row, seq+1)
+			for colIdx, val := range values {
+				col, _ := excelize.ColumnNumberToName(colIdx + 2)
+				if err := file.SetCellValue(sheet, col+rowStr, val); err != nil {
+					return err
+				}
+			}
+			if err := file.SetCellStyle(sheet, "A"+rowStr, lastHeaderCol+rowStr, dataStyle); err != nil {
+				return err
+			}
+			currentRow++
+		}
+
+		// Summary row
+		totalRowStr := fmt.Sprintf("%d", currentRow)
+		totalCells := map[string]interface{}{
+			"A": supplierName,
+			"B": "Total",
+			"H": item.Summary.TotalQty,
+			"I": item.Summary.TotalUnitPrice,
+			"J": item.Summary.TotalPurchaseValue,
+			"K": item.Summary.TotalTransportUnitPrice,
+			"L": item.Summary.TotalTransportValue,
+			"M": item.Summary.TotalAmount,
+		}
+		for col, val := range totalCells {
+			if err := file.SetCellValue(sheet, col+totalRowStr, val); err != nil {
+				return err
+			}
+		}
+		if err := file.SetCellStyle(sheet, "A"+totalRowStr, lastHeaderCol+totalRowStr, totalStyle); err != nil {
+			return err
+		}
+		currentRow++
+
+		// Empty separator row
+		currentRow++
+	}
+
+	return nil
+}
+
+// purchaseSupplierRowCells returns cell values for one data row.
+func purchaseSupplierRowCells(row dto.PurchaseSupplierRowDTO, seq int) []interface{} {
+	productName := "-"
+	if row.Product != nil && strings.TrimSpace(row.Product.Name) != "" {
+		productName = row.Product.Name
+	}
+	warehouseName := "-"
+	if row.Warehouse != nil && strings.TrimSpace(row.Warehouse.Name) != "" {
+		warehouseName = row.Warehouse.Name
+	}
+
+	return []interface{}{
+		seq,
+		safePurchaseSupplierText(row.ReceiveDate),
+		safePurchaseSupplierText(row.PoDate),
+		safePurchaseSupplierText(row.PoNumber),
+		productName,
+		warehouseName,
+		row.Qty,
+		row.UnitPrice,
+		row.PurchaseValue,
+		row.TransportUnitPrice,
+		row.TransportValue,
+		row.TotalAmount,
+		safePurchaseSupplierText(row.Expedition),
+		safePurchaseSupplierText(row.DeliveryNumber),
+	}
+}
+
+func purchaseSupplierName(item dto.PurchaseSupplierDTO) string {
+	if item.Supplier != nil && strings.TrimSpace(item.Supplier.Name) != "" {
+		return item.Supplier.Name
+	}
+	return "Supplier"
+}
+
+func sanitizePurchaseSupplierSheetName(name string) string {
+	replacer := strings.NewReplacer(
+		":", " ", "\\", " ", "/", " ",
+		"?", " ", "*", " ", "[", " ", "]", " ",
+	)
+	sanitized := strings.TrimSpace(replacer.Replace(name))
+	if sanitized == "" {
+		return "Sheet"
+	}
+	runes := []rune(sanitized)
+	if len(runes) > 31 {
+		return string(runes[:31])
+	}
+	return sanitized
+}
+
+func safePurchaseSupplierText(s string) string {
+	t := strings.TrimSpace(s)
+	if t == "" {
+		return "-"
+	}
+	return t
+}

internal/modules/repports/dto/repportExpenseDepreciation.dto.go

@@ -16,13 +16,19 @@ type ExpenseDepreciationMetaDTO struct {
 }
 
 type ExpenseDepreciationRowDTO struct {
-	ProjectFlockID               int64   `json:"project_flock_id"`
-	FarmName                     string  `json:"farm_name"`
-	Period                       string  `json:"period"`
-	DepreciationPercentEffective float64 `json:"depreciation_percent_effective"`
-	DepreciationValue            float64 `json:"depreciation_value"`
-	PulletCostDayNTotal          float64 `json:"pullet_cost_day_n_total"`
-	Components                   any     `json:"components"`
+	ProjectFlockID                    int64   `json:"project_flock_id"`
+	FarmName                          string  `json:"farm_name"`
+	Period                            string  `json:"period"`
+	DepreciationPercentEffective      float64 `json:"depreciation_percent_effective"`
+	DepreciationValue                 float64 `json:"depreciation_value"`
+	PulletCostDayNTotal               float64 `json:"pullet_cost_day_n_total"`
+	MultiplicationPercentage          float64 `json:"multiplication_percentage"`
+	DayN                              int     `json:"day_n"`
+	ChickinDate                       string  `json:"chickin_date"`
+	TotalValuePulletAfterDepreciation float64 `json:"total_value_pullet_after_depreciation"`
+	StandardEffectiveDate             string  `json:"standard_effective_date,omitempty"`
+	TotalPopulation                   float64 `json:"total_population"`
+	Components                        any     `json:"components"`
 }
 
 type ExpenseDepreciationManualInputRowDTO struct {

internal/modules/repports/repositories/balance_monitoring.repository.go

@@ -240,22 +240,36 @@ func (r *balanceMonitoringRepositoryImpl) GetSalesTotalsBeforeDate(ctx context.C
 		return map[uint]float64{}, nil
 	}
 
-	dateColumn := resolveBalanceMonitoringDateColumn(filters.FilterBy)
-
 	type row struct {
 		CustomerID uint    `gorm:"column:customer_id"`
 		Total      float64 `gorm:"column:total"`
 	}
 	rows := make([]row, 0)
-	db := r.db.WithContext(ctx).
-		Table("marketing_delivery_products mdp").
-		Select("m.customer_id AS customer_id, COALESCE(SUM(mdp.total_price), 0) AS total").
-		Joins("INNER JOIN marketing_products mp ON mp.id = mdp.marketing_product_id").
-		Joins("INNER JOIN marketings m ON m.id = mp.marketing_id").
-		Where("m.customer_id IN ?", customerIDs).
-		Where("m.deleted_at IS NULL").
-		Where("mdp.delivery_date IS NOT NULL").
-		Where(fmt.Sprintf("DATE(%s) < ?", dateColumn), startDate)
+
+	var db *gorm.DB
+	if strings.ToLower(strings.TrimSpace(filters.FilterBy)) == "realized_at" {
+		// realized_at: gunakan data DO (mdp.total_price), filter by delivery_date < startDate
+		db = r.db.WithContext(ctx).
+			Table("marketing_delivery_products mdp").
+			Select("m.customer_id AS customer_id, COALESCE(SUM(mdp.total_price), 0) AS total").
+			Joins("INNER JOIN marketing_products mp ON mp.id = mdp.marketing_product_id").
+			Joins("INNER JOIN marketings m ON m.id = mp.marketing_id").
+			Where("m.customer_id IN ?", customerIDs).
+			Where("m.deleted_at IS NULL").
+			Where("mdp.delivery_date IS NOT NULL").
+			Where("DATE(mdp.delivery_date) < ?", startDate)
+	} else {
+		// sold_at: SO-date sebelum startDate DAN approval terbaru sudah DO — gunakan data DO (mdp.total_price)
+		db = r.db.WithContext(ctx).
+			Table("marketing_products mp").
+			Select("m.customer_id AS customer_id, COALESCE(SUM(mdp.total_price), 0) AS total").
+			Joins("INNER JOIN marketings m ON m.id = mp.marketing_id").
+			Joins("INNER JOIN marketing_delivery_products mdp ON mdp.marketing_product_id = mp.id").
+			Where("m.customer_id IN ?", customerIDs).
+			Where("m.deleted_at IS NULL").
+			Where("DATE(m.so_date) < ?", startDate).
+			Where("(SELECT step_number FROM approvals WHERE approvable_type = 'MARKETINGS' AND approvable_id = mp.marketing_id ORDER BY id DESC LIMIT 1) >= ?", uint16(utils.MarketingDeliveryOrder))
+	}
 
 	if len(filters.SalesIDs) > 0 {
 		db = db.Where("m.sales_person_id IN ?", filters.SalesIDs)
@@ -318,28 +332,46 @@ func (r *balanceMonitoringRepositoryImpl) GetSalesByCategoryInPeriod(ctx context
 		return map[uint]BalanceMonitoringCategoryRow{}, nil
 	}
 
-	dateColumn := resolveBalanceMonitoringDateColumn(filters.FilterBy)
+	// Gunakan data DO (mdp) bukan SO (mp) agar nominal/qty/kg mencerminkan nilai aktual DO
+	const selectCols = `m.customer_id AS customer_id,
+		COALESCE(SUM(CASE WHEN m.marketing_type IN ('AYAM','AYAM_PULLET') THEN (mdp.usage_qty + mdp.pending_qty) ELSE 0 END), 0) AS ayam_qty,
+		COALESCE(SUM(CASE WHEN m.marketing_type IN ('AYAM','AYAM_PULLET') THEN mdp.total_weight  ELSE 0 END), 0) AS ayam_kg,
+		COALESCE(SUM(CASE WHEN m.marketing_type IN ('AYAM','AYAM_PULLET') THEN mdp.total_price   ELSE 0 END), 0) AS ayam_nominal,
+		COALESCE(SUM(CASE WHEN m.marketing_type = 'TELUR' THEN (mdp.usage_qty + mdp.pending_qty) ELSE 0 END), 0) AS telur_qty,
+		COALESCE(SUM(CASE WHEN m.marketing_type = 'TELUR' THEN mdp.total_weight  ELSE 0 END), 0) AS telur_kg,
+		COALESCE(SUM(CASE WHEN m.marketing_type = 'TELUR' THEN mdp.total_price   ELSE 0 END), 0) AS telur_nominal,
+		COALESCE(SUM(CASE WHEN m.marketing_type = 'TRADING' THEN (mdp.usage_qty + mdp.pending_qty) ELSE 0 END), 0) AS trading_qty,
+		COALESCE(SUM(CASE WHEN m.marketing_type = 'TRADING' THEN mdp.total_weight  ELSE 0 END), 0) AS trading_kg,
+		COALESCE(SUM(CASE WHEN m.marketing_type = 'TRADING' THEN mdp.total_price   ELSE 0 END), 0) AS trading_nominal`
 
 	rows := make([]BalanceMonitoringCategoryRow, 0)
-	db := r.db.WithContext(ctx).
-		Table("marketing_delivery_products mdp").
-		Select(`m.customer_id AS customer_id,
-			COALESCE(SUM(CASE WHEN m.marketing_type IN ('AYAM','AYAM_PULLET') THEN mdp.usage_qty    ELSE 0 END), 0) AS ayam_qty,
-			COALESCE(SUM(CASE WHEN m.marketing_type IN ('AYAM','AYAM_PULLET') THEN mdp.total_weight ELSE 0 END), 0) AS ayam_kg,
-			COALESCE(SUM(CASE WHEN m.marketing_type IN ('AYAM','AYAM_PULLET') THEN mdp.total_price  ELSE 0 END), 0) AS ayam_nominal,
-			COALESCE(SUM(CASE WHEN m.marketing_type = 'TELUR' THEN mdp.usage_qty    ELSE 0 END), 0) AS telur_qty,
-			COALESCE(SUM(CASE WHEN m.marketing_type = 'TELUR' THEN mdp.total_weight ELSE 0 END), 0) AS telur_kg,
-			COALESCE(SUM(CASE WHEN m.marketing_type = 'TELUR' THEN mdp.total_price  ELSE 0 END), 0) AS telur_nominal,
-			COALESCE(SUM(CASE WHEN m.marketing_type = 'TRADING' THEN mdp.usage_qty    ELSE 0 END), 0) AS trading_qty,
-			COALESCE(SUM(CASE WHEN m.marketing_type = 'TRADING' THEN mdp.total_weight ELSE 0 END), 0) AS trading_kg,
-			COALESCE(SUM(CASE WHEN m.marketing_type = 'TRADING' THEN mdp.total_price  ELSE 0 END), 0) AS trading_nominal`).
-		Joins("INNER JOIN marketing_products mp ON mp.id = mdp.marketing_product_id").
-		Joins("INNER JOIN marketings m ON m.id = mp.marketing_id").
-		Where("m.customer_id IN ?", customerIDs).
-		Where("m.deleted_at IS NULL").
-		Where("mdp.delivery_date IS NOT NULL").
-		Where(fmt.Sprintf("DATE(%s) >= ?", dateColumn), startDate).
-		Where(fmt.Sprintf("DATE(%s) <= ?", dateColumn), endDate)
+
+	var db *gorm.DB
+	if strings.ToLower(strings.TrimSpace(filters.FilterBy)) == "realized_at" {
+		// realized_at: FROM mdp langsung, filter by delivery_date in period — data DO
+		db = r.db.WithContext(ctx).
+			Table("marketing_delivery_products mdp").
+			Select(selectCols).
+			Joins("INNER JOIN marketing_products mp ON mp.id = mdp.marketing_product_id").
+			Joins("INNER JOIN marketings m ON m.id = mp.marketing_id").
+			Where("m.customer_id IN ?", customerIDs).
+			Where("m.deleted_at IS NULL").
+			Where("mdp.delivery_date IS NOT NULL").
+			Where("DATE(mdp.delivery_date) >= ?", startDate).
+			Where("DATE(mdp.delivery_date) <= ?", endDate)
+	} else {
+		// sold_at: SO-date dalam period DAN approval terbaru DO — JOIN mdp untuk data DO
+		db = r.db.WithContext(ctx).
+			Table("marketing_products mp").
+			Select(selectCols).
+			Joins("INNER JOIN marketings m ON m.id = mp.marketing_id").
+			Joins("INNER JOIN marketing_delivery_products mdp ON mdp.marketing_product_id = mp.id").
+			Where("m.customer_id IN ?", customerIDs).
+			Where("m.deleted_at IS NULL").
+			Where("DATE(m.so_date) >= ?", startDate).
+			Where("DATE(m.so_date) <= ?", endDate).
+			Where("(SELECT step_number FROM approvals WHERE approvable_type = 'MARKETINGS' AND approvable_id = mp.marketing_id ORDER BY id DESC LIMIT 1) >= ?", uint16(utils.MarketingDeliveryOrder))
+	}
 
 	if len(filters.SalesIDs) > 0 {
 		db = db.Where("m.sales_person_id IN ?", filters.SalesIDs)

internal/modules/repports/repositories/debt_supplier.repository.go

@@ -514,7 +514,7 @@ func (r *debtSupplierRepositoryImpl) baseExpenseSupplierIDs(ctx context.Context,
 		Table("expenses").
 		Select("DISTINCT expenses.supplier_id").
 		Joins("JOIN (?) AS la ON la.approvable_id = expenses.id", r.latestExpenseApproval(ctx)).
-		Where("la.step_number >= ?", uint16(utils.ExpenseStepFinance)).
+		Where("la.step_number >= ?", uint16(utils.ExpenseStepRealisasi)).
 		Where("(la.action IS NULL OR la.action != ?)", string(entity.ApprovalActionRejected)).
 		Where("expenses.deleted_at IS NULL")
 
@@ -623,7 +623,7 @@ func (r *debtSupplierRepositoryImpl) GetExpensesBySuppliers(ctx context.Context,
 		Model(&entity.Expense{}).
 		Joins("JOIN (?) AS la ON la.approvable_id = expenses.id", r.latestExpenseApproval(ctx)).
 		Where("expenses.supplier_id IN ?", supplierIDs).
-		Where("la.step_number >= ?", uint16(utils.ExpenseStepFinance)).
+		Where("la.step_number >= ?", uint16(utils.ExpenseStepRealisasi)).
 		Where("(la.action IS NULL OR la.action != ?)", string(entity.ApprovalActionRejected)).
 		Where("expenses.deleted_at IS NULL")
 
@@ -692,7 +692,7 @@ func (r *debtSupplierRepositoryImpl) GetExpenseTotalsBeforeDate(ctx context.Cont
 		Joins("JOIN expense_nonstocks en ON en.expense_id = expenses.id").
 		Joins("JOIN (?) AS la ON la.approvable_id = expenses.id", r.latestExpenseApproval(ctx)).
 		Where("expenses.supplier_id IN ?", supplierIDs).
-		Where("la.step_number >= ?", uint16(utils.ExpenseStepFinance)).
+		Where("la.step_number >= ?", uint16(utils.ExpenseStepRealisasi)).
 		Where("(la.action IS NULL OR la.action != ?)", string(entity.ApprovalActionRejected)).
 		Where("expenses.deleted_at IS NULL").
 		Where("DATE(expenses.transaction_date) < ?", dateFrom).

internal/modules/repports/repositories/expense_depreciation.repository.go

@@ -37,10 +37,11 @@ type FarmDepreciationManualInputRow struct {
 	Note           *string
 }
 
-type houseDepreciationPercentRow struct {
-	HouseType           string
-	Day                 int
-	DepreciationPercent float64
+type houseMultiplicationPercentageRow struct {
+	HouseType                string
+	Day                      int
+	MultiplicationPercentage float64
+	EffectiveDate            *time.Time
 }
 
 type ExpenseDepreciationRepository interface {
@@ -48,8 +49,9 @@ type ExpenseDepreciationRepository interface {
 	GetSnapshotsByPeriodAndFarmIDs(ctx context.Context, period time.Time, farmIDs []uint) ([]entity.FarmDepreciationSnapshot, error)
 	UpsertSnapshots(ctx context.Context, rows []entity.FarmDepreciationSnapshot) error
 	DeleteSnapshotsFromDate(ctx context.Context, fromDate time.Time, farmIDs []uint) error
+	DeleteSnapshotsByFarmIDs(ctx context.Context, farmIDs []uint) error
 	GetLatestTransferInputsByFarms(ctx context.Context, period time.Time, farmIDs []uint) ([]FarmDepreciationLatestTransferRow, error)
-	GetDepreciationPercents(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, error)
+	GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, map[string]*time.Time, error)
 	GetLatestManualInputsByFarms(ctx context.Context, areaIDs, locationIDs, projectFlockIDs []int64) ([]FarmDepreciationManualInputRow, error)
 	UpsertManualInput(ctx context.Context, row *entity.FarmDepreciationManualInput) error
 	DB() *gorm.DB
@@ -159,6 +161,17 @@ func (r *expenseDepreciationRepository) DeleteSnapshotsFromDate(
 	return query.Delete(nil).Error
 }
 
+func (r *expenseDepreciationRepository) DeleteSnapshotsByFarmIDs(ctx context.Context, farmIDs []uint) error {
+	if len(farmIDs) == 0 {
+		return nil
+	}
+
+	return r.db.WithContext(ctx).
+		Table("farm_depreciation_snapshots").
+		Where("project_flock_id IN ?", farmIDs).
+		Delete(nil).Error
+}
+
 func (r *expenseDepreciationRepository) GetLatestTransferInputsByFarms(
 	ctx context.Context,
 	period time.Time,
@@ -228,35 +241,39 @@ ORDER BY ltt.target_project_flock_kandang_id, at.effective_date DESC, at.id DESC
 	return rows, nil
 }
 
-func (r *expenseDepreciationRepository) GetDepreciationPercents(
+func (r *expenseDepreciationRepository) GetMultiplicationPercentages(
 	ctx context.Context,
 	houseTypes []string,
 	maxDay int,
-) (map[string]map[int]float64, error) {
+) (map[string]map[int]float64, map[string]*time.Time, error) {
 	result := make(map[string]map[int]float64)
+	effectiveDates := make(map[string]*time.Time)
 	if len(houseTypes) == 0 || maxDay <= 0 {
-		return result, nil
+		return result, effectiveDates, nil
 	}
 
-	rows := make([]houseDepreciationPercentRow, 0)
-	if err := r.db.WithContext(ctx).
-		Table("house_depreciation_standards").
-		Select("house_type::text AS house_type, day, depreciation_percent").
-		Where("house_type::text IN ?", houseTypes).
-		Where("day <= ?", maxDay).
-		Order("house_type ASC, day ASC").
-		Scan(&rows).Error; err != nil {
-		return nil, err
+	rows := make([]houseMultiplicationPercentageRow, 0)
+	if err := r.db.WithContext(ctx).Raw(`
+		SELECT DISTINCT ON (house_type::text, day)
+			house_type::text AS house_type, day, multiplication_percentage, effective_date
+		FROM house_depreciation_standards
+		WHERE house_type::text IN ? AND day <= ?
+		ORDER BY house_type, day, effective_date DESC NULLS LAST
+	`, houseTypes, maxDay).Scan(&rows).Error; err != nil {
+		return nil, nil, err
 	}
 
 	for _, row := range rows {
 		if _, exists := result[row.HouseType]; !exists {
 			result[row.HouseType] = make(map[int]float64)
 		}
-		result[row.HouseType][row.Day] = row.DepreciationPercent
+		result[row.HouseType][row.Day] = row.MultiplicationPercentage
+		if _, tracked := effectiveDates[row.HouseType]; !tracked {
+			effectiveDates[row.HouseType] = row.EffectiveDate
+		}
 	}
 
-	return result, nil
+	return result, effectiveDates, nil
 }
 
 func (r *expenseDepreciationRepository) GetLatestManualInputsByFarms(

internal/modules/repports/services/repport.service.go

@@ -237,6 +237,9 @@ func (s *repportService) GetExpenseDepreciation(ctx *fiber.Ctx) ([]dto.ExpenseDe
 
 	snapshotByFarmID := make(map[uint]entity.FarmDepreciationSnapshot)
 	if params.ForceRecompute {
+		if err := s.ExpenseDepreciationRepo.DeleteSnapshotsByFarmIDs(ctx.Context(), farmIDs); err != nil {
+			return nil, nil, err
+		}
 		computedSnapshots, computeErr := s.computeExpenseDepreciationSnapshots(ctx.Context(), periodDate, farmIDs, farmNameByID)
 		if computeErr != nil {
 			return nil, nil, computeErr
@@ -289,24 +292,34 @@ func (s *repportService) GetExpenseDepreciation(ctx *fiber.Ctx) ([]dto.ExpenseDe
 		snapshot, exists := snapshotByFarmID[candidate.ProjectFlockID]
 		if !exists {
 			rows = append(rows, dto.ExpenseDepreciationRowDTO{
-				ProjectFlockID:               int64(candidate.ProjectFlockID),
-				FarmName:                     candidate.FarmName,
-				Period:                       params.Period,
-				DepreciationPercentEffective: 0,
-				DepreciationValue:            0,
-				PulletCostDayNTotal:          0,
-				Components:                   map[string]any{},
+				ProjectFlockID:                    int64(candidate.ProjectFlockID),
+				FarmName:                          candidate.FarmName,
+				Period:                            params.Period,
+				DepreciationPercentEffective:      0,
+				DepreciationValue:                 0,
+				PulletCostDayNTotal:               0,
+				TotalValuePulletAfterDepreciation: 0,
+				Components:                        map[string]any{},
 			})
 			continue
 		}
+		components := parseSnapshotComponents(snapshot.Components)
+		multiplicationPercentage, dayN, chickinDate, standardEffectiveDate := depreciationSnapshotInfo(components)
+		totalPopulation := depreciationTotalPopulation(components)
 		rows = append(rows, dto.ExpenseDepreciationRowDTO{
-			ProjectFlockID:               int64(snapshot.ProjectFlockId),
-			FarmName:                     candidate.FarmName,
-			Period:                       params.Period,
-			DepreciationPercentEffective: snapshot.DepreciationPercentEffective,
-			DepreciationValue:            snapshot.DepreciationValue,
-			PulletCostDayNTotal:          snapshot.PulletCostDayNTotal,
-			Components:                   parseSnapshotComponents(snapshot.Components),
+			ProjectFlockID:                    int64(snapshot.ProjectFlockId),
+			FarmName:                          candidate.FarmName,
+			Period:                            params.Period,
+			DepreciationPercentEffective:      snapshot.DepreciationPercentEffective,
+			DepreciationValue:                 snapshot.DepreciationValue,
+			PulletCostDayNTotal:               snapshot.PulletCostDayNTotal,
+			MultiplicationPercentage:          multiplicationPercentage,
+			DayN:                              dayN,
+			ChickinDate:                       chickinDate,
+			TotalValuePulletAfterDepreciation: snapshot.PulletCostDayNTotal - snapshot.DepreciationValue,
+			StandardEffectiveDate:             standardEffectiveDate,
+			TotalPopulation:                   totalPopulation,
+			Components:                        components,
 		})
 	}
 
@@ -472,28 +485,34 @@ func (s *repportService) UpsertExpenseDepreciationManualInput(ctx *fiber.Ctx, re
 }
 
 type depreciationKandangComponent struct {
-	ProjectFlockKandangID uint    `json:"project_flock_kandang_id"`
-	KandangID             uint    `json:"kandang_id"`
-	KandangName           string  `json:"kandang_name"`
-	TransferID            uint    `json:"transfer_id"`
-	TransferDate          string  `json:"transfer_date"`
-	SourceProjectFlockID  uint    `json:"source_project_flock_id"`
-	HouseType             string  `json:"house_type"`
-	DayN                  int     `json:"day_n"`
-	DepreciationPercent   float64 `json:"depreciation_percent"`
-	TransferQty           float64 `json:"transfer_qty"`
-	PulletCostDayN        float64 `json:"pullet_cost_day_n"`
-	DepreciationValue     float64 `json:"depreciation_value"`
-	DepreciationSource    string  `json:"depreciation_source,omitempty"`
-	ManualInputID         *uint   `json:"manual_input_id,omitempty"`
-	CutoverDate           string  `json:"cutover_date,omitempty"`
-	OriginDate            string  `json:"origin_date,omitempty"`
-	StartScheduleDay      *int    `json:"start_schedule_day,omitempty"`
+	ProjectFlockKandangID             uint    `json:"project_flock_kandang_id"`
+	KandangID                         uint    `json:"kandang_id"`
+	KandangName                       string  `json:"kandang_name"`
+	TransferID                        uint    `json:"transfer_id"`
+	TransferDate                      string  `json:"transfer_date"`
+	SourceProjectFlockID              uint    `json:"source_project_flock_id"`
+	HouseType                         string  `json:"house_type"`
+	DayN                              int     `json:"day_n"`
+	DepreciationPercent               float64 `json:"depreciation_percent"`
+	MultiplicationPercentage          float64 `json:"multiplication_percentage"`
+	TransferQty                       float64 `json:"transfer_qty"`
+	PulletCostDayN                    float64 `json:"pullet_cost_day_n"`
+	DepreciationValue                 float64 `json:"depreciation_value"`
+	TotalValuePulletAfterDepreciation float64 `json:"total_value_pullet_after_depreciation"`
+	DepreciationSource                string  `json:"depreciation_source,omitempty"`
+	ManualInputID                     *uint   `json:"manual_input_id,omitempty"`
+	CutoverDate                       string  `json:"cutover_date,omitempty"`
+	OriginDate                        string  `json:"origin_date,omitempty"`
+	ChickinDate                       string  `json:"chickin_date,omitempty"`
+	StartScheduleDay                  *int    `json:"start_schedule_day,omitempty"`
+	StandardEffectiveDate             string  `json:"standard_effective_date,omitempty"`
+	Population                        float64 `json:"population"`
 }
 
 type depreciationFarmComponents struct {
-	KandangCount int                            `json:"kandang_count"`
-	Kandang      []depreciationKandangComponent `json:"kandang"`
+	KandangCount    int                            `json:"kandang_count"`
+	TotalPopulation float64                        `json:"total_population"`
+	Kandang         []depreciationKandangComponent `json:"kandang"`
 }
 
 func (s *repportService) computeExpenseDepreciationSnapshots(
@@ -527,6 +546,7 @@ func (s *repportService) computeExpenseDepreciationSnapshots(
 
 		totalDepreciationValue := 0.0
 		totalPulletCostDayN := 0.0
+		totalPopulation := 0.0
 		for _, kandangID := range kandangIDs {
 			breakdown, err := s.HppV2Svc.CalculateHppBreakdown(kandangID, &periodDate)
 			if err != nil {
@@ -548,17 +568,22 @@ func (s *repportService) computeExpenseDepreciationSnapshots(
 
 				houseType := approvalService.NormalizeDepreciationHouseType(breakdown.HouseType)
 				component := depreciationKandangComponent{
-					ProjectFlockKandangID: breakdown.ProjectFlockKandangID,
-					KandangID:             breakdown.KandangID,
-					KandangName:           breakdown.KandangName,
-					SourceProjectFlockID:  hppV2DetailUint(part.Details, "source_project_flock_id"),
-					HouseType:             houseType,
-					DayN:                  hppV2DetailInt(part.Details, "schedule_day"),
-					DepreciationPercent:   hppV2DetailFloat(part.Details, "depreciation_percent"),
-					PulletCostDayN:        hppV2DetailFloat(part.Details, "pullet_cost_day_n"),
-					DepreciationValue:     part.Total,
-					DepreciationSource:    part.Code,
-					OriginDate:            hppV2DetailString(part.Details, "origin_date"),
+					ProjectFlockKandangID:             breakdown.ProjectFlockKandangID,
+					KandangID:                         breakdown.KandangID,
+					KandangName:                       breakdown.KandangName,
+					SourceProjectFlockID:              hppV2DetailUint(part.Details, "source_project_flock_id"),
+					HouseType:                         houseType,
+					DayN:                              hppV2DetailInt(part.Details, "schedule_day"),
+					DepreciationPercent:               hppV2DetailFloat(part.Details, "depreciation_percent"),
+					MultiplicationPercentage:          hppV2DetailFloat(part.Details, "multiplication_percentage"),
+					PulletCostDayN:                    hppV2DetailFloat(part.Details, "pullet_cost_day_n"),
+					DepreciationValue:                 part.Total,
+					TotalValuePulletAfterDepreciation: hppV2DetailFloat(part.Details, "total_value_pullet_after_depreciation"),
+					DepreciationSource:                part.Code,
+					OriginDate:                        hppV2DetailString(part.Details, "origin_date"),
+					ChickinDate:                       hppV2DetailString(part.Details, "origin_date"),
+					StandardEffectiveDate:             hppV2DetailString(part.Details, "standard_effective_date"),
+					Population:                        hppV2DetailFloat(part.Details, "kandang_population"),
 				}
 
 				if component.HouseType == "" {
@@ -589,11 +614,13 @@ func (s *repportService) computeExpenseDepreciationSnapshots(
 
 				totalPulletCostDayN += component.PulletCostDayN
 				totalDepreciationValue += component.DepreciationValue
+				totalPopulation += component.Population
 				components.Kandang = append(components.Kandang, component)
 			}
 		}
 
 		components.KandangCount = len(components.Kandang)
+		components.TotalPopulation = totalPopulation
 		effectivePercent := approvalService.CalculateEffectiveDepreciationPercent(totalDepreciationValue, totalPulletCostDayN)
 
 		componentsJSON, marshalErr := json.Marshal(components)
@@ -700,8 +727,11 @@ func hppV2DetailString(details map[string]any, key string) string {
 	if details == nil || key == "" {
 		return ""
 	}
-	raw, exists := details[key]
-	if !exists || raw == nil {
+	return anyString(details[key])
+}
+
+func anyString(raw any) string {
+	if raw == nil {
 		return ""
 	}
 	switch value := raw.(type) {
@@ -725,6 +755,77 @@ func parseSnapshotComponents(raw []byte) any {
 	return out
 }
 
+func depreciationSnapshotInfo(components any) (float64, int, string, string) {
+	root, ok := components.(map[string]any)
+	if !ok {
+		return 0, 0, "", ""
+	}
+	kandang, ok := root["kandang"].([]any)
+	if !ok {
+		return 0, 0, "", ""
+	}
+	for _, raw := range kandang {
+		component, ok := raw.(map[string]any)
+		if !ok {
+			continue
+		}
+		dayN := int(math.Round(anyFloat(component["day_n"])))
+		multiplicationPercentage := anyFloat(component["multiplication_percentage"])
+		chickinDate := anyString(component["chickin_date"])
+		if chickinDate == "" {
+			chickinDate = anyString(component["origin_date"])
+		}
+		if dayN > 0 || multiplicationPercentage > 0 || chickinDate != "" {
+			standardEffectiveDate := anyString(component["standard_effective_date"])
+			return multiplicationPercentage, dayN, chickinDate, standardEffectiveDate
+		}
+	}
+	return 0, 0, "", ""
+}
+
+func depreciationTotalPopulation(components any) float64 {
+	root, ok := components.(map[string]any)
+	if !ok {
+		return 0
+	}
+	return anyFloat(root["total_population"])
+}
+
+func anyFloat(raw any) float64 {
+	switch value := raw.(type) {
+	case float64:
+		return value
+	case float32:
+		return float64(value)
+	case int:
+		return float64(value)
+	case int8:
+		return float64(value)
+	case int16:
+		return float64(value)
+	case int32:
+		return float64(value)
+	case int64:
+		return float64(value)
+	case uint:
+		return float64(value)
+	case uint8:
+		return float64(value)
+	case uint16:
+		return float64(value)
+	case uint32:
+		return float64(value)
+	case uint64:
+		return float64(value)
+	case string:
+		parsed, err := strconv.ParseFloat(strings.TrimSpace(value), 64)
+		if err == nil {
+			return parsed
+		}
+	}
+	return 0
+}
+
 func valueOrEmptyString(v *string) string {
 	if v == nil {
 		return ""
@@ -750,37 +851,28 @@ func (s *repportService) GetMarketing(c *fiber.Ctx, params *validation.Marketing
 		customerGroups[customerID] = append(customerGroups[customerID], dp)
 	}
 
+	// Aging untuk setiap MDP berdasarkan payment_allocations: LUNAS pakai last_payment_date,
+	// else pakai today.
 	agingMap := make(map[int]int)
-	for customerID := range customerGroups {
-		transactions, err := s.CustomerPaymentRepo.GetCustomerPaymentTransactions(c.Context(), &customerID)
-		if err != nil {
-			continue
-		}
-
-		initialBalance, err := s.CustomerPaymentRepo.GetInitialBalanceByCustomer(c.Context(), customerID)
-		if err != nil {
-			initialBalance = 0
-		}
-
-		runningBalance := initialBalance
-		for i, tx := range transactions {
-			if tx.TransactionType == "SALES" {
-				previousBalance := runningBalance
-				runningBalance -= tx.TotalPrice
-				currentBalance := runningBalance
-
-				_, paymentDate := s.determineSalesStatusAndPaymentDate(transactions, i, previousBalance, currentBalance)
-
-				if paymentDate != nil {
-					agingDays := int(paymentDate.Sub(tx.TransDate).Hours() / 24)
-					agingMap[int(tx.TransactionID)] = agingDays
-				} else {
-					agingDays := int(time.Since(tx.TransDate).Hours() / 24)
-					agingMap[int(tx.TransactionID)] = agingDays
-				}
-			} else if tx.TransactionType == "PAYMENT" {
-				runningBalance += tx.PaymentAmount
+	allMdpIDsForAging := make([]uint, 0)
+	for _, dp := range deliveryProducts {
+		allMdpIDsForAging = append(allMdpIDsForAging, dp.Id)
+	}
+	mdpAllocSummaryForMarketing, err := s.fetchMdpAllocationSummary(c.Context(), allMdpIDsForAging)
+	if err != nil {
+		return nil, 0, err
+	}
+	for _, dp := range deliveryProducts {
+		summary := mdpAllocSummaryForMarketing[dp.Id]
+		soDate := dp.MarketingProduct.Marketing.SoDate
+		if customerPaymentStatusFromAllocation(dp.TotalPrice, summary.PaidAmount) == "LUNAS" && !summary.LastPaymentDate.IsZero() {
+			days := int(summary.LastPaymentDate.Sub(soDate).Hours() / 24)
+			if days < 0 {
+				days = 0
 			}
+			agingMap[int(dp.Id)] = days
+		} else {
+			agingMap[int(dp.Id)] = int(time.Since(soDate).Hours() / 24)
 		}
 	}
 
@@ -1169,28 +1261,39 @@ func (s *repportService) processCustomerPayment(ctx context.Context, customerID
 		return dto.CustomerPaymentReportItem{}, err
 	}
 
+	// Batch fetch payment allocation summaries untuk semua SALES rows (per MDP).
+	mdpIDs := make([]uint, 0)
+	for _, tx := range transactions {
+		if tx.TransactionType == "SALES" && tx.TransactionID > 0 {
+			mdpIDs = append(mdpIDs, uint(tx.TransactionID))
+		}
+	}
+	mdpAllocSummary, err := s.fetchMdpAllocationSummary(ctx, mdpIDs)
+	if err != nil {
+		return dto.CustomerPaymentReportItem{}, err
+	}
+
 	rows := make([]dto.CustomerPaymentReportRow, 0, len(transactions))
 	runningBalance := initialBalance
 
-	for i, tx := range transactions {
-
-		previousBalance := runningBalance
+	for _, tx := range transactions {
 
 		row := dto.ToCustomerPaymentReportRow(tx)
 
 		if tx.TransactionType == "SALES" {
 			runningBalance -= tx.TotalPrice
-			status, paymentDate := s.determineSalesStatusAndPaymentDate(transactions, i, previousBalance, runningBalance)
-			row.Status = status
+			summary := mdpAllocSummary[uint(tx.TransactionID)]
+			row.Status = customerPaymentStatusFromAllocation(tx.TotalPrice, summary.PaidAmount)
 
-			if status == "LUNAS" {
-				if paymentDate != nil {
-					days := int(paymentDate.Sub(tx.TransDate).Hours() / 24)
-					row.AgingDay = &days
-				} else {
-					days := 0
-					row.AgingDay = &days
+			if row.Status == "LUNAS" && !summary.LastPaymentDate.IsZero() {
+				days := int(summary.LastPaymentDate.Sub(tx.TransDate).Hours() / 24)
+				if days < 0 {
+					days = 0
 				}
+				row.AgingDay = &days
+			} else if row.Status == "LUNAS" {
+				zero := 0
+				row.AgingDay = &zero
 			} else {
 				days := int(time.Since(tx.TransDate).Hours() / 24)
 				row.AgingDay = &days
@@ -1262,91 +1365,19 @@ func (s *repportService) processCustomerPayment(ctx context.Context, customerID
 	return dto.ToCustomerPaymentReportItem(*customer, initialBalance, rows, summary), nil
 }
 
-func (s *repportService) determineSalesStatusAndPaymentDate(transactions []repportRepo.CustomerPaymentTransaction, currentIndex int, previousBalance, currentBalance float64) (string, *time.Time) {
-	currentSales := transactions[currentIndex]
-
-	if previousBalance >= currentSales.TotalPrice {
-		type paymentAllocation struct {
-			date     time.Time
-			amount   float64
-			consumed float64
-		}
-		allocations := []paymentAllocation{}
-		runningBalance := 0.0
-
-		for i := 0; i < currentIndex; i++ {
-			if transactions[i].TransactionType == "PAYMENT" {
-				allocations = append(allocations, paymentAllocation{
-					date:     transactions[i].TransDate,
-					amount:   transactions[i].PaymentAmount,
-					consumed: 0,
-				})
-				runningBalance += transactions[i].PaymentAmount
-			} else if transactions[i].TransactionType == "SALES" {
-				salesAmount := transactions[i].TotalPrice
-				remainingToConsume := salesAmount
-
-				for j := range allocations {
-					if remainingToConsume <= 0 {
-						break
-					}
-					available := allocations[j].amount - allocations[j].consumed
-					if available > 0 {
-						consume := available
-						if consume > remainingToConsume {
-							consume = remainingToConsume
-						}
-						allocations[j].consumed += consume
-						remainingToConsume -= consume
-					}
-				}
-				runningBalance -= salesAmount
-			}
-		}
-
-		amountNeeded := currentSales.TotalPrice
-		for _, alloc := range allocations {
-			available := alloc.amount - alloc.consumed
-			if available > 0 {
-				if amountNeeded <= available {
-					return "LUNAS", &alloc.date
-				} else {
-					amountNeeded -= available
-				}
-			}
-		}
-
-		if len(allocations) > 0 {
-			return "LUNAS", &allocations[0].date
-		}
-		return "LUNAS", nil
+// customerPaymentStatusFromAllocation menentukan status per-MDP berdasarkan
+// SUM(payment_allocations.amount) vs MDP total_price.
+func customerPaymentStatusFromAllocation(totalPrice, paidAmount float64) string {
+	if totalPrice <= fifoAllocationEpsilon {
+		return "LUNAS"
 	}
-
-	hasPartialPaymentFromBalance := previousBalance > 0 && previousBalance < currentSales.TotalPrice
-
-	futureBalance := currentBalance
-	hasPayment := false
-	var paymentDateThatMadeItLunas *time.Time
-
-	for i := currentIndex + 1; i < len(transactions); i++ {
-		if transactions[i].TransactionType == "PAYMENT" {
-			futureBalance += transactions[i].PaymentAmount
-			hasPayment = true
-
-			if futureBalance >= 0 {
-				paymentDateThatMadeItLunas = &transactions[i].TransDate
-				return "LUNAS", paymentDateThatMadeItLunas
-			}
-		} else if transactions[i].TransactionType == "SALES" {
-			futureBalance -= transactions[i].TotalPrice
-		}
+	if paidAmount+fifoAllocationEpsilon >= totalPrice {
+		return "LUNAS"
 	}
-
-	if hasPayment || hasPartialPaymentFromBalance {
-		return "DIBAYAR SEBAGIAN", nil
+	if paidAmount > fifoAllocationEpsilon {
+		return "DIBAYAR SEBAGIAN"
 	}
-
-	return "BELUM LUNAS", nil
+	return "BELUM LUNAS"
 }
 
 func mapRecordingToProductionResultDTO(record entity.Recording) dto.ProductionResultDTO {
@@ -1861,15 +1892,34 @@ func (s *repportService) GetDebtSupplier(c *fiber.Ctx, params *validation.DebtSu
 		DeltaBalance float64
 		CountTotals  bool
 	}
-	type debtSupplierAllocation struct {
-		RowIndex  int
-		SortTime  time.Time
-		Amount    float64
-		CalcAging func(endDate time.Time) int
+
+	// Batch fetch payment allocation summaries (per purchase + per expense) untuk semua supplier.
+	// FIFO matching dilakukan saat payment di-create/update; report tinggal baca dari DB.
+	allPurchaseIDs := make([]uint, 0)
+	allExpenseIDs := make([]uint64, 0)
+	for _, sid := range supplierIDs {
+		for _, p := range purchasesBySupplier[sid] {
+			allPurchaseIDs = append(allPurchaseIDs, p.Id)
+		}
+		for _, e := range expensesBySupplier[sid] {
+			allExpenseIDs = append(allExpenseIDs, e.Id)
+		}
 	}
-	type paymentAllocation struct {
-		Date   time.Time
-		Amount float64
+	purchaseAllocSummary, err := s.fetchPurchaseAllocationSummary(c.Context(), allPurchaseIDs)
+	if err != nil {
+		return nil, 0, err
+	}
+	expenseAllocSummary, err := s.fetchExpenseAllocationSummary(c.Context(), allExpenseIDs)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	// rowRef tracks which combinedRows index belongs to which purchase/expense untuk update status di-akhir.
+	type rowRef struct {
+		Index    int
+		Kind     string // "PURCHASE" / "EXPENSE"
+		Purchase entity.Purchase
+		Expense  entity.Expense
 	}
 
 	for _, supplierID := range supplierIDs {
@@ -1884,7 +1934,7 @@ func (s *repportService) GetDebtSupplier(c *fiber.Ctx, params *validation.DebtSu
 		total := dto.DebtSupplierTotalDTO{}
 
 		combinedRows := make([]debtSupplierRowItem, 0, len(items)+len(paymentItems))
-		purchaseAllocations := make([]debtSupplierAllocation, 0, len(items))
+		rowRefs := make([]rowRef, 0, len(items)+len(expensesBySupplier[supplierID]))
 		for _, purchase := range items {
 			row := buildDebtSupplierRow(purchase, now, location)
 			sortTime := resolveDebtSupplierSortTime(purchase, params.FilterBy, location)
@@ -1896,13 +1946,7 @@ func (s *repportService) GetDebtSupplier(c *fiber.Ctx, params *validation.DebtSu
 				DeltaBalance: -row.TotalPrice,
 				CountTotals:  true,
 			})
-			capturedPurchase := purchase
-			purchaseAllocations = append(purchaseAllocations, debtSupplierAllocation{
-				RowIndex:  rowIndex,
-				SortTime:  sortTime,
-				Amount:    row.TotalPrice,
-				CalcAging: func(endDate time.Time) int { return calculateDebtSupplierAging(capturedPurchase, endDate, location) },
-			})
+			rowRefs = append(rowRefs, rowRef{Index: rowIndex, Kind: "PURCHASE", Purchase: purchase})
 		}
 
 		for _, exp := range expensesBySupplier[supplierID] {
@@ -1916,25 +1960,7 @@ func (s *repportService) GetDebtSupplier(c *fiber.Ctx, params *validation.DebtSu
 				DeltaBalance: -row.TotalPrice,
 				CountTotals:  true,
 			})
-			capturedExp := exp
-			purchaseAllocations = append(purchaseAllocations, debtSupplierAllocation{
-				RowIndex:  rowIndex,
-				SortTime:  sortTime,
-				Amount:    row.TotalPrice,
-				CalcAging: func(endDate time.Time) int { return calculateExpenseAging(capturedExp, endDate, location) },
-			})
-		}
-
-		paymentAllocations := make([]paymentAllocation, 0, len(paymentItems)+1)
-		initialAllocation := initialBalanceTotals[supplierID] + initialPaymentTotals[supplierID] - initialPurchaseTotals[supplierID]
-		paymentCarry := 0.0
-		if initialAllocation > 0 && len(purchaseAllocations) > 0 {
-			paymentAllocations = append(paymentAllocations, paymentAllocation{
-				Date:   purchaseAllocations[0].SortTime,
-				Amount: initialAllocation,
-			})
-		} else if initialAllocation < 0 {
-			paymentCarry = -initialAllocation
+			rowRefs = append(rowRefs, rowRef{Index: rowIndex, Kind: "EXPENSE", Expense: exp})
 		}
 
 		for _, payment := range paymentItems {
@@ -1947,51 +1973,29 @@ func (s *repportService) GetDebtSupplier(c *fiber.Ctx, params *validation.DebtSu
 				DeltaBalance: payment.Nominal,
 				CountTotals:  false,
 			})
-			paymentAllocations = append(paymentAllocations, paymentAllocation{
-				Date:   sortTime,
-				Amount: payment.Nominal,
-			})
 		}
 
-		if len(purchaseAllocations) > 0 && len(paymentAllocations) > 0 {
-			sort.SliceStable(purchaseAllocations, func(i, j int) bool {
-				return purchaseAllocations[i].SortTime.Before(purchaseAllocations[j].SortTime)
-			})
-			sort.SliceStable(paymentAllocations, func(i, j int) bool {
-				return paymentAllocations[i].Date.Before(paymentAllocations[j].Date)
-			})
-			remaining := make([]float64, len(purchaseAllocations))
-			for i := range purchaseAllocations {
-				remaining[i] = purchaseAllocations[i].Amount
+		// Determine Status & Aging dari payment_allocations DB.
+		for _, ref := range rowRefs {
+			rowTotal := combinedRows[ref.Index].Row.TotalPrice
+			if rowTotal <= fifoAllocationEpsilon {
+				continue
 			}
-			purchaseIndex := 0
-			for _, pay := range paymentAllocations {
-				amount := pay.Amount
-				if amount <= 0 {
-					continue
-				}
-				if paymentCarry > 0 {
-					used := math.Min(amount, paymentCarry)
-					paymentCarry -= used
-					amount -= used
-				}
-				for amount > 0 && purchaseIndex < len(remaining) {
-					if remaining[purchaseIndex] <= 0 {
-						purchaseIndex++
-						continue
-					}
-					used := math.Min(amount, remaining[purchaseIndex])
-					remaining[purchaseIndex] -= used
-					amount -= used
-					if remaining[purchaseIndex] <= 0.000001 {
-						allocation := purchaseAllocations[purchaseIndex]
-						combinedRows[allocation.RowIndex].Row.Status = "Lunas"
-						combinedRows[allocation.RowIndex].Row.Aging = allocation.CalcAging(pay.Date)
-						purchaseIndex++
-					}
-				}
-				if purchaseIndex >= len(remaining) {
-					break
+			var summary paymentAllocationSummary
+			if ref.Kind == "PURCHASE" {
+				summary = purchaseAllocSummary[ref.Purchase.Id]
+			} else {
+				summary = expenseAllocSummary[ref.Expense.Id]
+			}
+			if summary.PaidAmount+fifoAllocationEpsilon < rowTotal {
+				continue
+			}
+			combinedRows[ref.Index].Row.Status = "Lunas"
+			if !summary.LastPaymentDate.IsZero() {
+				if ref.Kind == "PURCHASE" {
+					combinedRows[ref.Index].Row.Aging = calculateDebtSupplierAging(ref.Purchase, summary.LastPaymentDate.In(location), location)
+				} else {
+					combinedRows[ref.Index].Row.Aging = calculateExpenseAging(ref.Expense, summary.LastPaymentDate.In(location), location)
 				}
 			}
 		}
@@ -2068,7 +2072,8 @@ func buildDebtSupplierRow(purchase entity.Purchase, now time.Time, loc *time.Loc
 	travelNumber := "-"
 	receivedDate := ""
 	var area *areaDTO.AreaRelationDTO
-	var warehouse *warehouseDTO.WarehouseRelationDTO
+	warehouses := []warehouseDTO.WarehouseRelationDTO{}
+	seenWarehouseIDs := map[uint]bool{}
 
 	if len(purchase.Items) > 0 {
 		firstItem := purchase.Items[0]
@@ -2076,24 +2081,22 @@ func buildDebtSupplierRow(purchase entity.Purchase, now time.Time, loc *time.Loc
 			travelNumber = *firstItem.TravelNumber
 		}
 
-		if firstItem.Warehouse != nil && firstItem.Warehouse.Id != 0 {
-			mappedWarehouse := warehouseDTO.ToWarehouseRelationDTO(*firstItem.Warehouse)
-			warehouse = &mappedWarehouse
-			if firstItem.Warehouse.Area.Id != 0 {
-				mappedArea := areaDTO.ToAreaRelationDTO(firstItem.Warehouse.Area)
-				area = &mappedArea
-			}
-		}
-
 		earliestReceived := time.Time{}
 		for _, item := range purchase.Items {
 			totalPrice += item.TotalPrice
-			if item.ReceivedDate == nil || item.ReceivedDate.IsZero() {
-				continue
+			if item.ReceivedDate != nil && !item.ReceivedDate.IsZero() {
+				received := item.ReceivedDate.In(loc)
+				if earliestReceived.IsZero() || received.Before(earliestReceived) {
+					earliestReceived = received
+				}
 			}
-			received := item.ReceivedDate.In(loc)
-			if earliestReceived.IsZero() || received.Before(earliestReceived) {
-				earliestReceived = received
+			if item.Warehouse != nil && item.Warehouse.Id != 0 && !seenWarehouseIDs[item.Warehouse.Id] {
+				seenWarehouseIDs[item.Warehouse.Id] = true
+				warehouses = append(warehouses, warehouseDTO.ToWarehouseRelationDTO(*item.Warehouse))
+				if area == nil && item.Warehouse.Area.Id != 0 {
+					mappedArea := areaDTO.ToAreaRelationDTO(item.Warehouse.Area)
+					area = &mappedArea
+				}
 			}
 		}
 		if !earliestReceived.IsZero() {
@@ -2119,6 +2122,12 @@ func buildDebtSupplierRow(purchase entity.Purchase, now time.Time, loc *time.Loc
 		poDate = purchase.PoDate.In(loc).Format("2006-01-02")
 	}
 
+	var firstWarehouse *warehouseDTO.WarehouseRelationDTO
+	if len(warehouses) > 0 {
+		w := warehouses[0]
+		firstWarehouse = &w
+	}
+
 	return dto.DebtSupplierRowDTO{
 		PrNumber:     prNumber,
 		PoNumber:     poNumber,
@@ -2126,7 +2135,7 @@ func buildDebtSupplierRow(purchase entity.Purchase, now time.Time, loc *time.Loc
 		ReceivedDate: receivedDate,
 		Aging:        aging,
 		Area:         area,
-		Warehouse:    warehouse,
+		Warehouse:    firstWarehouse,
 		DueDate:      dueDate,
 		DueStatus:    dueStatus,
 		TotalPrice:   totalPrice,
@@ -2168,6 +2177,115 @@ func buildDebtSupplierPaymentRow(payment entity.Payment, loc *time.Location) dto
 	}
 }
 
+// fifoAllocationEpsilon untuk float comparison saat membandingkan paid vs total.
+const fifoAllocationEpsilon = 0.001
+
+// paymentAllocationSummary aggregates per-document paid amount + latest payment date
+// from payment_allocations table, sebagai pengganti FIFO greedy in-memory.
+type paymentAllocationSummary struct {
+	PaidAmount      float64
+	LastPaymentDate time.Time
+}
+
+// fetchPurchaseAllocationSummary returns map[purchase_id]{paid_amount, last_payment_date}.
+// paid_amount = SUM(payment_allocations.amount) untuk semua items dalam purchase.
+// last_payment_date = MAX(payments.payment_date) untuk allocation tersebut.
+func (s *repportService) fetchPurchaseAllocationSummary(ctx context.Context, purchaseIDs []uint) (map[uint]paymentAllocationSummary, error) {
+	out := make(map[uint]paymentAllocationSummary)
+	if len(purchaseIDs) == 0 {
+		return out, nil
+	}
+	type row struct {
+		PurchaseID  uint
+		Total       float64
+		LastPayment *time.Time
+	}
+	var rows []row
+	if err := s.db.WithContext(ctx).
+		Table("payment_allocations pa").
+		Joins("JOIN purchase_items pi ON pi.id = pa.purchase_item_id").
+		Joins("JOIN payments p ON p.id = pa.payment_id").
+		Select("pi.purchase_id AS purchase_id, SUM(pa.amount) AS total, MAX(p.payment_date) AS last_payment").
+		Where("pi.purchase_id IN ?", purchaseIDs).
+		Group("pi.purchase_id").
+		Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+	for _, r := range rows {
+		summary := paymentAllocationSummary{PaidAmount: r.Total}
+		if r.LastPayment != nil {
+			summary.LastPaymentDate = *r.LastPayment
+		}
+		out[r.PurchaseID] = summary
+	}
+	return out, nil
+}
+
+// fetchExpenseAllocationSummary returns map[expense_id]{paid_amount, last_payment_date}.
+// Allocation di expense_realization_id → JOIN expense_nonstocks → expenses.id.
+func (s *repportService) fetchExpenseAllocationSummary(ctx context.Context, expenseIDs []uint64) (map[uint64]paymentAllocationSummary, error) {
+	out := make(map[uint64]paymentAllocationSummary)
+	if len(expenseIDs) == 0 {
+		return out, nil
+	}
+	type row struct {
+		ExpenseID   uint64
+		Total       float64
+		LastPayment *time.Time
+	}
+	var rows []row
+	if err := s.db.WithContext(ctx).
+		Table("payment_allocations pa").
+		Joins("JOIN expense_realizations er ON er.id = pa.expense_realization_id").
+		Joins("JOIN expense_nonstocks en ON en.id = er.expense_nonstock_id").
+		Joins("JOIN payments p ON p.id = pa.payment_id").
+		Select("en.expense_id AS expense_id, SUM(pa.amount) AS total, MAX(p.payment_date) AS last_payment").
+		Where("en.expense_id IN ?", expenseIDs).
+		Group("en.expense_id").
+		Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+	for _, r := range rows {
+		summary := paymentAllocationSummary{PaidAmount: r.Total}
+		if r.LastPayment != nil {
+			summary.LastPaymentDate = *r.LastPayment
+		}
+		out[r.ExpenseID] = summary
+	}
+	return out, nil
+}
+
+// fetchMdpAllocationSummary returns map[mdp_id]{paid_amount, last_payment_date}.
+func (s *repportService) fetchMdpAllocationSummary(ctx context.Context, mdpIDs []uint) (map[uint]paymentAllocationSummary, error) {
+	out := make(map[uint]paymentAllocationSummary)
+	if len(mdpIDs) == 0 {
+		return out, nil
+	}
+	type row struct {
+		MdpID       uint
+		Total       float64
+		LastPayment *time.Time
+	}
+	var rows []row
+	if err := s.db.WithContext(ctx).
+		Table("payment_allocations pa").
+		Joins("JOIN payments p ON p.id = pa.payment_id").
+		Select("pa.marketing_delivery_product_id AS mdp_id, SUM(pa.amount) AS total, MAX(p.payment_date) AS last_payment").
+		Where("pa.marketing_delivery_product_id IN ?", mdpIDs).
+		Group("pa.marketing_delivery_product_id").
+		Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+	for _, r := range rows {
+		summary := paymentAllocationSummary{PaidAmount: r.Total}
+		if r.LastPayment != nil {
+			summary.LastPaymentDate = *r.LastPayment
+		}
+		out[r.MdpID] = summary
+	}
+	return out, nil
+}
+
 func resolveDebtSupplierSortTime(purchase entity.Purchase, filterBy string, loc *time.Location) time.Time {
 	if strings.EqualFold(strings.TrimSpace(filterBy), "po_date") {
 		if purchase.PoDate != nil && !purchase.PoDate.IsZero() {
@@ -2271,10 +2389,10 @@ func buildDebtSupplierExpenseRow(exp entity.Expense, now time.Time, loc *time.Lo
 		aging = int(endDay.Sub(startDay).Hours() / 24)
 	}
 
-	totalPrice := 0.0
-	for _, ns := range exp.Nonstocks {
-		totalPrice += ns.Qty * ns.Price
-	}
+	// TotalPrice pakai expense.GrandTotal (= SUM realisasi) supaya konsisten dengan
+	// FIFO allocation yang juga pakai realisasi. Hindari pakai SUM nonstock pengajuan
+	// karena bisa beda nilai dari realisasi → mismatch dengan paid_amount → status salah.
+	totalPrice := exp.GrandTotal
 
 	var area *areaDTO.AreaRelationDTO
 	if exp.Location != nil && exp.Location.Area.Id != 0 {

internal/utils/recording/recording_helpers.go

@@ -244,8 +244,12 @@ func AttachProductionStandards(ctx context.Context, db *gorm.DB, warnOnly bool,
 		growthDetailByStd[standardID] = growthMap
 	}
 
-	// Batch-load laying transfer targets → source PFK chick_in_dates
-	// untuk menentukan actual chicken week (bukan hardcode LayingWeekStart offset)
+	// Batch-load laying transfer targets → EARLIEST source PFK chick_in_date per target.
+	// Multi-source: 1 target kandang bisa menerima dari multiple transfer terpisah. Untuk
+	// production standard week, kita pakai chick_in_date PALING AWAL (umur paling tua) sebagai
+	// anchor — agar perbandingan standar produksi tidak under-estimate umur ayam.
+	// Source diambil dari header `laying_transfers.source_project_flock_kandang_id` (single source
+	// of truth per migration 20260307130342), bukan dari `laying_transfer_sources`.
 	type transferChickIn struct {
 		TargetPFKID uint
 		ChickInDate time.Time
@@ -255,14 +259,16 @@ func AttachProductionStandards(ctx context.Context, db *gorm.DB, warnOnly bool,
 	if len(layingPFKIDs) > 0 {
 		var results []transferChickIn
 		db.Raw(`
-			SELECT ltt.target_project_flock_kandang_id AS target_pfk_id, pc.chick_in_date
+			SELECT ltt.target_project_flock_kandang_id AS target_pfk_id,
+			       MIN(pc.chick_in_date) AS chick_in_date
 			FROM laying_transfer_targets ltt
-			JOIN laying_transfer_sources lts ON lts.laying_transfer_id = ltt.laying_transfer_id
-			JOIN project_chickins pc ON pc.project_flock_kandang_id = lts.source_project_flock_kandang_id
+			JOIN laying_transfers lt ON lt.id = ltt.laying_transfer_id AND lt.deleted_at IS NULL
+			JOIN project_chickins pc ON pc.project_flock_kandang_id = lt.source_project_flock_kandang_id
 			WHERE ltt.target_project_flock_kandang_id IN ?
 			  AND ltt.deleted_at IS NULL
-			  AND lts.deleted_at IS NULL
+			  AND lt.source_project_flock_kandang_id IS NOT NULL
 			  AND pc.deleted_at IS NULL
+			GROUP BY ltt.target_project_flock_kandang_id
 		`, layingPFKIDs).Scan(&results)
 		for _, r := range results {
 			sourceChickInByTarget[r.TargetPFKID] = r.ChickInDate