adjust response list marketing add grand total so dan do

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)
+}

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,
+	projectFlockID uint,
-	maxDay int,
+) (map[uint]float64, error) {
-) (map[string]map[int]float64, error) {
-	result := make(map[string]map[int]float64)
-	if len(houseTypes) == 0 || maxDay <= 0 {
-		return result, nil
-	}
-
 	type row struct {
-		HouseType           string
+		ProjectFlockKandangID uint    `gorm:"column:project_flock_kandang_id"`
-		Day                 int
+		TotalQty              float64 `gorm:"column:total_qty"`
-		DepreciationPercent float64
 	}
-
+	var rows []row
-	rows := make([]row, 0)
 	err := r.db.WithContext(ctx).
-		Table("house_depreciation_standards").
+		Table("project_chickins AS pc").
-		Select("house_type::text AS house_type, day, depreciation_percent").
+		Select("pc.project_flock_kandang_id, SUM(pc.usage_qty) AS total_qty").
-		Where("house_type::text IN ?", houseTypes).
+		Joins("JOIN project_flock_kandangs AS pfk ON pfk.id = pc.project_flock_kandang_id").
-		Where("day <= ?", maxDay).
+		Where("pc.deleted_at IS NULL").
-		Order("house_type ASC, day ASC").
+		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
+	depreciationStartAgeDayCloseHouse = 175
-	depreciationStartAgeDayOpenHouse  = 176
+	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())
+	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, periodDate.Location())
+	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,
+	multiplicationByHouseType map[string]map[int]float64,
-) (float64, float64, 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]
+		mult, ok := houseMult[day]
-		dep := current * (pct / 100)
+		if !ok {
+			// No standard for this day → assume no depreciation (mult=1).
+			mult = 1.0
+		}
 		if day == endDay {
 			pulletCostDayN = current
-			depreciationValue = dep
+			multiplicationPercentage = mult
-			depreciationPercent = pct
+			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 {
+	// Multi-source support: 1 target kandang bisa menerima dari MULTIPLE transfer terpisah
-		return nil, nil
+	// (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).
-	transferInput, err := s.hppRepo.GetLatestTransferInputByProjectFlockKandangID(context.Background(), projectFlockKandangId, periodDate)
+	transferInputs, err := s.hppRepo.GetAllTransferInputsByProjectFlockKandangID(context.Background(), projectFlockKandangId, periodDate)
 	if err != nil {
 		return nil, err
 	}
 
-	var part *HppV2ComponentPart
+	// Filter valid transfers (punya source flock id)
-	if transferInput != nil && transferInput.SourceProjectFlockID > 0 {
+	validTransfers := make([]commonRepo.HppV2LatestTransferInputRow, 0, len(transferInputs))
-		part, err = s.buildNormalTransferDepreciationPart(contextRow, transferInput, periodDate, totalPulletCost)
+	totalTransferQty := 0.0
-		if err != nil {
+	for _, t := range transferInputs {
-			return nil, err
+		if t.SourceProjectFlockID == 0 {
+			continue
 		}
-	} else {
+		validTransfers = append(validTransfers, t)
-		part, err = s.buildManualCutoverDepreciationPart(projectFlockKandangId, contextRow, periodDate, totalPulletCost)
+		totalTransferQty += t.TransferQty
-		if err != nil {
+	}
-			return nil, err
+
+	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,
+			"basis_total":                           totalPulletCost,
-			"pullet_cost_day_n":       pulletCostDayN,
+			"pullet_cost_day_n":                     pulletCostDayN,
-			"depreciation_percent":    depreciationPercent,
+			"multiplication_percentage":             multiplicationPercentage,
-			"schedule_day":            scheduleDay,
+			"total_value_pullet_after_depreciation": totalValueAfter,
-			"origin_date":             formatDateOnly(*originDate),
+			"depreciation_percent":                  depreciationPercent,
-			"transfer_date":           formatDateOnly(transferInput.TransferDate),
+			"schedule_day":                          scheduleDay,
-			"source_project_flock_id": transferInput.SourceProjectFlockID,
+			"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(
+	pulletCostDayN, depreciationValue, multiplicationPercentage := CalculateDepreciationFromDayRange(
-		totalPulletCost,
+		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,
+			"basis_total":                           basis,
-			"pullet_cost_day_n":     pulletCostDayN,
+			"manual_input_total":                    manualInput.TotalCost,
-			"depreciation_percent":  depreciationPercent,
+			"population_share":                      populationShare,
-			"schedule_day":          reportScheduleDay,
+			"pullet_cost_day_n":                     pulletCostDayN,
-			"start_schedule_day":    startDay,
+			"multiplication_percentage":             multiplicationPercentage,
-			"origin_date":           formatDateOnly(*originDate),
+			"total_value_pullet_after_depreciation": totalValueAfter,
-			"cutover_date":          formatDateOnly(manualInput.CutoverDate),
+			"depreciation_percent":                  depreciationPercent,
-			"manual_input_id":       manualInput.ID,
+			"schedule_day":                          reportScheduleDay,
-			"project_flock_kandang": projectFlockKandangId,
+			"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/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/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,
+		Log:            utils.Log,
-		Validate:    validate,
+		Validate:       validate,
-		Repository:  repo,
+		Repository:     repo,
-		ApprovalSvc: approvalSvc,
+		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.controller.go

@@ -72,6 +72,7 @@ func (u *DeliveryOrdersController) GetAll(c *fiber.Ctx) error {
 		MarketingId:           uint(c.QueryInt("marketing_id", 0)),
 		ProjectFlockID:        uint(c.QueryInt("project_flock_id", 0)),
 		ProjectFlockKandangID: uint(c.QueryInt("project_flock_kandang_id", 0)),
+		WarehouseID:           uint(c.QueryInt("warehouse_id", 0)),
 		SortBy:                sortBy,
 		SortOrder:             sortOrder,
 	}

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

@@ -70,23 +70,26 @@ func buildMarketingExportWorkbook(items []dto.MarketingListDTO) ([]byte, error)
 }
 
 func setMarketingExportColumns(file *excelize.File, sheet string) error {
+	// A–Q = 17 columns
+	// E = Sales (new), H = Gudang (new), Satuan (old I) removed
 	columnWidths := map[string]float64{
-		"A": 16,
+		"A": 16, // No. Order
-		"B": 14,
+		"B": 14, // Tanggal
-		"C": 18,
+		"C": 18, // Status
-		"D": 20,
+		"D": 20, // Customer
-		"E": 14,
+		"E": 20, // Sales (new)
-		"F": 40,
+		"F": 14, // Tipe
-		"G": 10,
+		"G": 40, // Nama Produk
-		"H": 12,
+		"H": 20, // Gudang (new)
-		"I": 12,
+		"I": 10, // Week
-		"J": 12,
+		"J": 12, // Jumlah
-		"K": 16,
+		"K": 12, // Qty Peti
-		"L": 16,
+		"L": 16, // Berat Rata-rata (kg)
-		"M": 18,
+		"M": 16, // Total Berat (kg)
-		"N": 18,
+		"N": 18, // Harga Satuan
-		"O": 18,
+		"O": 18, // Total Harga
-		"P": 24,
+		"P": 18, // Grand Total
+		"Q": 24, // Catatan
 	}
 
 	for col, width := range columnWidths {
@@ -104,22 +107,23 @@ func setMarketingExportColumns(file *excelize.File, sheet string) error {
 
 func setMarketingExportHeaders(file *excelize.File, sheet string) error {
 	headers := []string{
-		"No. Order",    // A
+		"No. Order",            // A
-		"Tanggal",      // B
+		"Tanggal",              // B
-		"Status",       // C
+		"Status",               // C
-		"Customer",     // D
+		"Customer",             // D
-		"Tipe",         // E
+		"Sales",                // E (new)
-		"Nama Produk",  // F
+		"Tipe",                 // F
-		"Week",         // G
+		"Nama Produk",          // G
-		"Jumlah",       // H
+		"Gudang",               // H (new)
-		"Satuan",       // I
+		"Week",                 // I
-		"Qty Peti",     // J
+		"Jumlah Butir",         // J
-		"Berat Rata-rata (kg)", // K
+		"Qty Peti",             // K
-		"Total Berat (kg)",     // L
+		"Berat Rata-rata (kg)", // L
-		"Harga Satuan", // M
+		"Total Berat (kg)",     // M
-		"Total Harga",  // N
+		"Harga Satuan",         // N
-		"Grand Total",  // O
+		"Total Harga",          // O
-		"Catatan",      // P
+		"Grand Total",          // P
+		"Catatan",              // Q
 	}
 
 	for i, header := range headers {
@@ -148,7 +152,7 @@ func setMarketingExportHeaders(file *excelize.File, sheet string) error {
 		return err
 	}
 
-	return file.SetCellStyle(sheet, "A1", "P1", headerStyle)
+	return file.SetCellStyle(sheet, "A1", "Q1", headerStyle)
 }
 
 func setMarketingExportRows(file *excelize.File, sheet string, items []dto.MarketingListDTO) error {
@@ -162,17 +166,161 @@ func setMarketingExportRows(file *excelize.File, sheet string, items []dto.Marke
 		soDate := formatMarketingExportDate(item.SoDate)
 		status := formatMarketingExportStatus(item)
 		customer := safeMarketingExportText(item.Customer.Name)
-		grandTotal := sumMarketingGrandTotal(item.SalesOrder)
 		notes := safeMarketingExportText(item.Notes)
+		salesPerson := safeMarketingExportText(item.SalesPerson.Name)
+
+		isDeliveryOrder := strings.EqualFold(strings.TrimSpace(status), "delivery order")
+
+		// ── Delivery Order branch ──────────────────────────────────────────────
+		if isDeliveryOrder {
+			grandTotal := sumDeliveryGrandTotal(item.DeliveryOrder)
+
+			if len(item.DeliveryOrder) == 0 {
+				row++
+				r := strconv.Itoa(row)
+				vals := map[string]interface{}{
+					"A": soNumber, "B": soDate, "C": status, "D": customer, "E": salesPerson,
+					"F": "-", "G": "-", "H": "-", "I": "-", "J": "-", "K": "-",
+					"L": "-", "M": "-", "N": "-", "O": "-",
+					"P": grandTotal, "Q": notes,
+				}
+				for col, val := range vals {
+					if err := file.SetCellValue(sheet, col+r, val); err != nil {
+						return err
+					}
+				}
+				continue
+			}
+
+			// Build lookup map: MarketingProductId → SO product (for Week & MarketingType)
+			soProductMap := make(map[uint]*dto.DeliveryMarketingProductDTO, len(item.SalesOrder))
+			for i := range item.SalesOrder {
+				soProductMap[item.SalesOrder[i].Id] = &item.SalesOrder[i]
+			}
+
+			for _, group := range item.DeliveryOrder {
+				doNumber := safeMarketingExportText(group.DoNumber)
+
+				doDate := "-"
+				if group.DeliveryDate != nil {
+					doDate = formatMarketingExportDate(*group.DeliveryDate)
+				}
+
+				gudang := "-"
+				if group.Warehouse != nil {
+					gudang = safeMarketingExportText(group.Warehouse.Name)
+				}
+
+				if len(group.Deliveries) == 0 {
+					row++
+					r := strconv.Itoa(row)
+					vals := map[string]interface{}{
+						"A": doNumber, "B": doDate, "C": status, "D": customer, "E": salesPerson,
+						"F": "-", "G": "-", "H": gudang, "I": "-", "J": "-", "K": "-",
+						"L": "-", "M": "-", "N": "-", "O": "-",
+						"P": grandTotal, "Q": notes,
+					}
+					for col, val := range vals {
+						if err := file.SetCellValue(sheet, col+r, val); err != nil {
+							return err
+						}
+					}
+					continue
+				}
+
+				for _, delivery := range group.Deliveries {
+					row++
+					r := strconv.Itoa(row)
+
+					productName := "-"
+					if delivery.ProductWarehouse != nil && delivery.ProductWarehouse.Product != nil {
+						if n := strings.TrimSpace(delivery.ProductWarehouse.Product.Name); n != "" {
+							productName = n
+						}
+					}
+
+					week := "-"
+					marketingType := "-"
+					if soProduct, ok := soProductMap[delivery.MarketingProductId]; ok {
+						if soProduct.Week != nil {
+							week = strconv.Itoa(*soProduct.Week)
+						}
+						marketingType = safeMarketingExportText(soProduct.MarketingType)
+					}
+
+					if err := file.SetCellValue(sheet, "A"+r, doNumber); err != nil {
+						return err
+					}
+					if err := file.SetCellValue(sheet, "B"+r, doDate); 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, salesPerson); err != nil {
+						return err
+					}
+					if err := file.SetCellValue(sheet, "F"+r, marketingType); err != nil {
+						return err
+					}
+					if err := file.SetCellValue(sheet, "G"+r, productName); err != nil {
+						return err
+					}
+					if err := file.SetCellValue(sheet, "H"+r, gudang); err != nil {
+						return err
+					}
+					if err := file.SetCellValue(sheet, "I"+r, week); err != nil {
+						return err
+					}
+					if err := file.SetCellValue(sheet, "J"+r, delivery.Qty); err != nil {
+						return err
+					}
+					if delivery.TotalPeti != nil {
+						if err := file.SetCellValue(sheet, "K"+r, *delivery.TotalPeti); err != nil {
+							return err
+						}
+					} else {
+						if err := file.SetCellValue(sheet, "K"+r, "-"); err != nil {
+							return err
+						}
+					}
+					if err := file.SetCellValue(sheet, "L"+r, delivery.AvgWeight); err != nil {
+						return err
+					}
+					if err := file.SetCellValue(sheet, "M"+r, delivery.TotalWeight); err != nil {
+						return err
+					}
+					if err := file.SetCellValue(sheet, "N"+r, delivery.UnitPrice); err != nil {
+						return err
+					}
+					if err := file.SetCellValue(sheet, "O"+r, delivery.TotalPrice); err != nil {
+						return err
+					}
+					if err := file.SetCellValue(sheet, "P"+r, grandTotal); err != nil {
+						return err
+					}
+					if err := file.SetCellValue(sheet, "Q"+r, notes); err != nil {
+						return err
+					}
+				}
+			}
+			continue
+		}
+
+		// ── Sales Order branch (all other statuses) ───────────────────────────
+		grandTotal := sumMarketingGrandTotal(item.SalesOrder)
 
 		if len(item.SalesOrder) == 0 {
 			row++
 			r := strconv.Itoa(row)
 			vals := map[string]interface{}{
-				"A": soNumber, "B": soDate, "C": status, "D": customer,
+				"A": soNumber, "B": soDate, "C": status, "D": customer, "E": salesPerson,
-				"E": "-", "F": "-", "G": "-", "H": "-", "I": "-", "J": "-",
+				"F": "-", "G": "-", "H": "-", "I": "-", "J": "-", "K": "-",
-				"K": "-", "L": "-", "M": "-", "N": "-",
+				"L": "-", "M": "-", "N": "-", "O": "-",
-				"O": grandTotal, "P": notes,
+				"P": grandTotal, "Q": notes,
 			}
 			for col, val := range vals {
 				if err := file.SetCellValue(sheet, col+r, val); err != nil {
@@ -198,9 +346,9 @@ func setMarketingExportRows(file *excelize.File, sheet string, items []dto.Marke
 				week = strconv.Itoa(*prod.Week)
 			}
 
-			satuan := "-"
+			gudang := "-"
-			if prod.ConvertionUnit != nil && strings.TrimSpace(*prod.ConvertionUnit) != "" {
+			if prod.ProductWarehouse != nil {
-				satuan = *prod.ConvertionUnit
+				gudang = safeMarketingExportText(prod.ProductWarehouse.Warehouse.Name)
 			}
 
 			if err := file.SetCellValue(sheet, "A"+r, soNumber); err != nil {
@@ -215,46 +363,49 @@ func setMarketingExportRows(file *excelize.File, sheet string, items []dto.Marke
 			if err := file.SetCellValue(sheet, "D"+r, customer); err != nil {
 				return err
 			}
-			if err := file.SetCellValue(sheet, "E"+r, safeMarketingExportText(prod.MarketingType)); err != nil {
+			if err := file.SetCellValue(sheet, "E"+r, salesPerson); err != nil {
 				return err
 			}
-			if err := file.SetCellValue(sheet, "F"+r, productName); err != nil {
+			if err := file.SetCellValue(sheet, "F"+r, safeMarketingExportText(prod.MarketingType)); err != nil {
 				return err
 			}
-			if err := file.SetCellValue(sheet, "G"+r, week); err != nil {
+			if err := file.SetCellValue(sheet, "G"+r, productName); err != nil {
 				return err
 			}
-			if err := file.SetCellValue(sheet, "H"+r, prod.Qty); err != nil {
+			if err := file.SetCellValue(sheet, "H"+r, gudang); err != nil {
 				return err
 			}
-			if err := file.SetCellValue(sheet, "I"+r, satuan); err != nil {
+			if err := file.SetCellValue(sheet, "I"+r, week); err != nil {
+				return err
+			}
+			if err := file.SetCellValue(sheet, "J"+r, prod.Qty); err != nil {
 				return err
 			}
 			if prod.TotalPeti != nil {
-				if err := file.SetCellValue(sheet, "J"+r, *prod.TotalPeti); err != nil {
+				if err := file.SetCellValue(sheet, "K"+r, *prod.TotalPeti); err != nil {
 					return err
 				}
 			} else {
-				if err := file.SetCellValue(sheet, "J"+r, "-"); err != nil {
+				if err := file.SetCellValue(sheet, "K"+r, "-"); err != nil {
 					return err
 				}
 			}
-			if err := file.SetCellValue(sheet, "K"+r, prod.AvgWeight); err != nil {
+			if err := file.SetCellValue(sheet, "L"+r, prod.AvgWeight); err != nil {
 				return err
 			}
-			if err := file.SetCellValue(sheet, "L"+r, prod.TotalWeight); err != nil {
+			if err := file.SetCellValue(sheet, "M"+r, prod.TotalWeight); err != nil {
 				return err
 			}
-			if err := file.SetCellValue(sheet, "M"+r, prod.UnitPrice); err != nil {
+			if err := file.SetCellValue(sheet, "N"+r, prod.UnitPrice); err != nil {
 				return err
 			}
-			if err := file.SetCellValue(sheet, "N"+r, prod.TotalPrice); err != nil {
+			if err := file.SetCellValue(sheet, "O"+r, prod.TotalPrice); err != nil {
 				return err
 			}
-			if err := file.SetCellValue(sheet, "O"+r, grandTotal); err != nil {
+			if err := file.SetCellValue(sheet, "P"+r, grandTotal); err != nil {
 				return err
 			}
-			if err := file.SetCellValue(sheet, "P"+r, notes); err != nil {
+			if err := file.SetCellValue(sheet, "Q"+r, notes); err != nil {
 				return err
 			}
 		}
@@ -276,7 +427,7 @@ func setMarketingExportRows(file *excelize.File, sheet string, items []dto.Marke
 	if err != nil {
 		return err
 	}
-	if err := file.SetCellStyle(sheet, "A2", "P"+lastRowStr, dataStyle); err != nil {
+	if err := file.SetCellStyle(sheet, "A2", "Q"+lastRowStr, dataStyle); err != nil {
 		return err
 	}
 
@@ -287,7 +438,7 @@ func setMarketingExportRows(file *excelize.File, sheet string, items []dto.Marke
 	if err != nil {
 		return err
 	}
-	if err := file.SetCellStyle(sheet, "K2", "O"+lastRowStr, numberStyle); err != nil {
+	if err := file.SetCellStyle(sheet, "L2", "P"+lastRowStr, numberStyle); err != nil {
 		return err
 	}
 
@@ -298,7 +449,7 @@ func setMarketingExportRows(file *excelize.File, sheet string, items []dto.Marke
 	if err != nil {
 		return err
 	}
-	for _, col := range []string{"G", "H", "J"} {
+	for _, col := range []string{"I", "J", "K"} {
 		if err := file.SetCellStyle(sheet, col+"2", col+lastRowStr, centerStyle); err != nil {
 			return err
 		}
@@ -327,16 +478,23 @@ func formatMarketingExportStatus(item dto.MarketingListDTO) string {
 	return safeMarketingExportText(item.LatestApproval.StepName)
 }
 
-
 func sumMarketingGrandTotal(items []dto.DeliveryMarketingProductDTO) float64 {
 	total := 0.0
 	for _, item := range items {
 		total += item.TotalPrice
 	}
-
 	return total
 }
 
+func sumDeliveryGrandTotal(groups []dto.DeliveryGroupDTO) float64 {
+	total := 0.0
+	for _, g := range groups {
+		for _, d := range g.Deliveries {
+			total += d.TotalPrice
+		}
+	}
+	return total
+}
 
 func safeMarketingExportText(value string) string {
 	trimmed := strings.TrimSpace(value)

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

@@ -28,6 +28,8 @@ type MarketingListDTO struct {
 	Customer       customerDTO.CustomerRelationDTO `json:"customer"`
 	SalesPerson    userDTO.UserRelationDTO         `json:"sales_person"`
 	SoDocs         string                          `json:"so_docs"`
+	GrandTotalSO   float64                         `json:"grand_total_so"`
+	GrandTotalDO   float64                         `json:"grand_total_do"`
 	SalesOrder     []DeliveryMarketingProductDTO   `json:"sales_order"`
 	DeliveryOrder  []DeliveryGroupDTO              `json:"delivery_order"`
 	CreatedUser    userDTO.UserRelationDTO         `json:"created_user"`
@@ -198,11 +200,18 @@ func ToMarketingListDTO(marketing *entity.Marketing, deliveryProducts []entity.M
 			salesOrderProducts[i] = ToDeliveryMarketingProductDTO(product, marketing.MarketingType)
 		}
 	}
+	var grandTotalSO float64
+	for _, p := range marketing.Products {
+		grandTotalSO += p.TotalPrice
+	}
+
 	return MarketingListDTO{
 		MarketingRelationDTO: ToMarketingRelationDTO(marketing),
 		Customer:             customer,
 		SalesPerson:          salesPerson,
 		SoDocs:               marketing.SoDocs,
+		GrandTotalSO:         grandTotalSO,
+		GrandTotalDO:         marketing.GrandTotal,
 		SalesOrder:           salesOrderProducts,
 		DeliveryOrder:        extractDeliveryGroupsFromProducts(marketing),
 		CreatedUser:          createdUser,

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)
+		}
 	}
 }
 
@@ -269,6 +287,16 @@ func (s deliveryOrdersService) GetAll(c *fiber.Ctx, params *validation.DeliveryO
 			db = db.Where("marketings.customer_id = ?", params.CustomerId)
 		}
 
+		if params.WarehouseID != 0 {
+			db = db.Where(`EXISTS (
+				SELECT 1
+				FROM marketing_products mp
+				JOIN product_warehouses pw ON pw.id = mp.product_warehouse_id
+				WHERE mp.marketing_id = marketings.id
+					AND pw.warehouse_id = ?
+			)`, params.WarehouseID)
+		}
+
 		db = s.applyMarketingProjectFlockFilter(c.Context(), db, params.ProjectFlockID, params.ProjectFlockKandangID)
 		db = s.applyMarketingSearchFilter(c.Context(), db, params.Search)
 
@@ -418,6 +446,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 +457,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 +549,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 +579,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 +590,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 +696,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/marketing/validations/deliveryorder.validation.go

@@ -31,6 +31,7 @@ type DeliveryOrderQuery struct {
 	MarketingId           uint   `query:"marketing_id" validate:"omitempty,gt=0"`
 	ProjectFlockID        uint   `query:"project_flock_id" validate:"omitempty,gt=0"`
 	ProjectFlockKandangID uint   `query:"project_flock_kandang_id" validate:"omitempty,gt=0"`
+	WarehouseID           uint   `query:"warehouse_id" validate:"omitempty,gt=0"`
 	SortBy                string `query:"sort_by" validate:"omitempty,oneof=so_number so_date status customer grand_total created_at"`
 	SortOrder             string `query:"sort_order" validate:"omitempty,oneof=asc desc"`
 }

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)
+	week := ((day - 1) / 7) + 1
-	weekBase := 1
-	if upperCategory == string(utils.ProjectFlockCategoryLaying) {
-		weekBase = config.LayingWeekStart()
-	}
-	week := ((day - 1) / 7) + weekBase
 	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)
+		// Multi-source: target kandang bisa menerima dari multiple transfer terpisah. Pakai
-	default:
+		// EARLIEST transfer (transfer_date ASC) sebagai anchor — kandang masuk transition/laying
-		return false, false, nil
+		// mengikuti batch pertama yang sampai.
-	}
+		allTransfers, allErr := s.TransferLayingRepo.GetAllApprovedByTargetKandang(ctx.Context(), projectFlockKandangID)
-	if err != nil {
+		if allErr != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
+			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)
+		// Repository ORDER BY transfer_date ASC, id ASC → [0] = earliest
-		return false, false, fiber.NewError(fiber.StatusInternalServerError, "Failed to resolve transfer state")
+		transfer = &allTransfers[0]
+	default:
+		return false, false, nil
 	}
 	if transfer == nil {
 		return false, false, nil

internal/modules/production/recordings/controllers/recording.controller.go

@@ -8,10 +8,12 @@ import (
 	"time"
 
 	"gitlab.com/mbugroup/lti-api.git/internal/common/exportprogress"
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	"gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/dto"
 	service "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/services"
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/validations"
 	"gitlab.com/mbugroup/lti-api.git/internal/response"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 
 	"github.com/gofiber/fiber/v2"
 )
@@ -75,6 +77,43 @@ func (u *RecordingController) GetAll(c *fiber.Ctx) error {
 	}
 
 	listDTO := dto.ToRecordingListDTOs(result)
+
+	recordingIDs := make([]uint, 0, len(result))
+	for i := range result {
+		if result[i].Id != 0 {
+			recordingIDs = append(recordingIDs, result[i].Id)
+		}
+	}
+	if len(recordingIDs) > 0 {
+		eggs, err := u.RecordingService.GetEggsWithFlagsByRecordingIDs(c.Context(), recordingIDs)
+		if err != nil {
+			return err
+		}
+		eggByRecording := make(map[uint][]entity.RecordingEgg, len(recordingIDs))
+		for _, egg := range eggs {
+			eggByRecording[egg.RecordingId] = append(eggByRecording[egg.RecordingId], egg)
+		}
+		for i := range listDTO {
+			id := listDTO[i].Id
+			if eggList, ok := eggByRecording[id]; ok {
+				breakdown := make(map[string]dto.EggExportBreakdownDTO)
+				for _, egg := range eggList {
+					flagName := eggTypeFromProductName(egg.ProductWarehouse.Product.Name)
+					if flagName == "" {
+						continue
+					}
+					entry := breakdown[flagName]
+					entry.Qty += egg.Qty
+					if egg.Weight != nil {
+						entry.Kg += *egg.Weight
+					}
+					breakdown[flagName] = entry
+				}
+				listDTO[i].EggExportBreakdown = breakdown
+			}
+		}
+	}
+
 	if strings.EqualFold(exportType, "excel") {
 		return exportRecordingListExcel(c, listDTO)
 	}
@@ -94,6 +133,33 @@ func (u *RecordingController) GetAll(c *fiber.Ctx) error {
 		})
 }
 
+// eggTypeFromProductName maps product name to egg type flag name by keyword matching.
+// Falls back to empty string if no keyword matches.
+func eggTypeFromProductName(name string) string {
+	normalized := strings.ToLower(strings.TrimSpace(name))
+	if normalized == "" {
+		return ""
+	}
+	// Ordered longest-first to prefer "papacal" over partial match of "pacal", etc.
+	keywords := []struct {
+		keyword string
+		flag    string
+	}{
+		{"papacal", string(utils.FlagTelurPapacal)},
+		{"jumbo", string(utils.FlagTelurJumbo)},
+		{"retak", string(utils.FlagTelurRetak)},
+		{"putih", string(utils.FlagTelurPutih)},
+		{"pecah", string(utils.FlagTelurPecah)},
+		{"utuh", string(utils.FlagTelurUtuh)},
+	}
+	for _, k := range keywords {
+		if strings.Contains(normalized, k.keyword) {
+			return k.flag
+		}
+	}
+	return ""
+}
+
 func (u *RecordingController) GetOne(c *fiber.Ctx) error {
 	param := c.Params("id")
 

internal/modules/production/recordings/controllers/recording.export.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/dto"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 
 	"github.com/gofiber/fiber/v2"
 	"github.com/xuri/excelize/v2"
@@ -79,6 +80,18 @@ func setRecordingExportColumns(file *excelize.File, sheet string) error {
 		"AB": 18,
 		"AC": 24,
 		"AD": 18,
+		"AE": 12,
+		"AF": 10,
+		"AG": 12,
+		"AH": 10,
+		"AI": 12,
+		"AJ": 10,
+		"AK": 12,
+		"AL": 10,
+		"AM": 12,
+		"AN": 10,
+		"AO": 12,
+		"AP": 10,
 	}
 
 	for col, width := range columnWidths {
@@ -208,6 +221,31 @@ func setRecordingExportHeaders(file *excelize.File, sheet string) error {
 		return err
 	}
 
+	eggTypes := []struct {
+		col1, col2, label string
+	}{
+		{"AE", "AF", "Telur Utuh"},
+		{"AG", "AH", "Telur Pecah"},
+		{"AI", "AJ", "Telur Putih"},
+		{"AK", "AL", "Telur Retak"},
+		{"AM", "AN", "Telur Papacal"},
+		{"AO", "AP", "Telur Jumbo"},
+	}
+	for _, et := range eggTypes {
+		if err := file.MergeCell(sheet, et.col1+"1", et.col2+"1"); err != nil {
+			return err
+		}
+		if err := file.SetCellValue(sheet, et.col1+"1", et.label); err != nil {
+			return err
+		}
+		if err := file.SetCellValue(sheet, et.col1+"2", "Butir"); err != nil {
+			return err
+		}
+		if err := file.SetCellValue(sheet, et.col2+"2", "Kg"); err != nil {
+			return err
+		}
+	}
+
 	headerStyle, err := file.NewStyle(&excelize.Style{
 		Font: &excelize.Font{
 			Bold:  true,
@@ -234,7 +272,7 @@ func setRecordingExportHeaders(file *excelize.File, sheet string) error {
 		return err
 	}
 
-	return file.SetCellStyle(sheet, "A1", "AD2", headerStyle)
+	return file.SetCellStyle(sheet, "A1", "AP2", headerStyle)
 }
 
 func setRecordingExportRows(file *excelize.File, sheet string, items []dto.RecordingListDTO) error {
@@ -245,7 +283,8 @@ func setRecordingExportRows(file *excelize.File, sheet string, items []dto.Recor
 	columns := []string{
 		"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N",
 		"O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA", "AB",
-		"AC", "AD",
+		"AC", "AD", "AE", "AF", "AG", "AH", "AI", "AJ", "AK", "AL", "AM", "AN",
+		"AO", "AP",
 	}
 
 	currentRow := 3
@@ -293,14 +332,14 @@ func setRecordingExportRows(file *excelize.File, sheet string, items []dto.Recor
 		// Expand recordings into one row per sapronak
 		type sapronakRow struct {
 			name  string
-			input string
+			input interface{} // float64 for numeric, string "-" for placeholder
 		}
 		sapronaks := make([]sapronakRow, 0)
 		if len(item.FeedUsage) > 0 {
 			for _, fu := range item.FeedUsage {
 				sapronaks = append(sapronaks, sapronakRow{
 					name:  safeExportText(fu.ProductName),
-					input: formatNumberID(fu.UsageAmount+fu.PendingQty, 2, true),
+					input: fu.UsageAmount + fu.PendingQty,
 				})
 			}
 		} else {
@@ -311,37 +350,66 @@ func setRecordingExportRows(file *excelize.File, sheet string, items []dto.Recor
 
 		for sIdx, s := range sapronaks {
 			if sIdx == 0 {
+				eggQty := func(flagName string) int {
+					if item.EggExportBreakdown != nil {
+						if bd, ok := item.EggExportBreakdown[flagName]; ok {
+							return bd.Qty
+						}
+					}
+					return 0
+				}
+				eggKg := func(flagName string) float64 {
+					if item.EggExportBreakdown != nil {
+						if bd, ok := item.EggExportBreakdown[flagName]; ok {
+							return bd.Kg
+						}
+					}
+					return 0
+				}
+
 				rowValues := []interface{}{
-					i + 1,                                          // A
+					i + 1,                                             // A
-					locationName,                                   // B
+					locationName,                                      // B
-					safeExportText(item.ProjectFlock.FlockName),    // C
+					safeExportText(item.ProjectFlock.FlockName),       // C
-					kandangName,                                    // D
+					kandangName,                                       // D
-					item.ProjectFlock.Period,                        // E
+					item.ProjectFlock.Period,                          // E
 					formatCategoryLabel(item.ProjectFlock.ProjectFlockCategory), // F
-					formatAgeLabel(item),                             // G
+					formatAgeLabel(item),                               // G
-					formatDateIndonesian(item.RecordDatetime),        // H
+					formatDateIndonesian(item.RecordDatetime),          // H
-					formatNumberID(item.ProjectFlock.TotalChickQty, 0, false), // I
+					item.ProjectFlock.TotalChickQty,                   // I
-					formatNumberID(item.FcrValue, 2, true),          // J
+					item.FcrValue,                                     // J
-					formatNumberID(fcrStd, 2, true),                 // K
+					fcrStd,                                            // K
-					formatNumberID(item.FeedIntake, 2, true),         // L
+					item.FeedIntake,                                   // L
-					formatNumberID(feedIntakeStd, 2, true),           // M
+					feedIntakeStd,                                     // M
-					formatPercentID(item.CumDepletionRate, 2),        // N
+					item.CumDepletionRate,                             // N
-					formatPercentID(maxDepletionStd, 2),              // O
+					maxDepletionStd,                                   // O
-					formatNumberID(item.TotalDepletionQty, 2, true),  // P
+					item.TotalDepletionQty,                            // P
-					formatNumberID(item.EggMass, 2, true),            // Q
+					item.EggMass,                                      // Q
-					formatNumberID(eggMassStd, 2, true),              // R
+					eggMassStd,                                        // R
-					formatNumberID(item.EggWeight, 2, true),          // S
+					item.EggWeight,                                    // S
-					formatNumberID(eggWeightStd, 2, true),            // T
+					eggWeightStd,                                      // T
-					formatPercentID(item.HenDay, 2),                  // U
+					item.HenDay,                                       // U
-					formatPercentID(henDayStd, 2),                    // V
+					henDayStd,                                         // V
-					formatPercentID(item.HenHouse, 2),                // W
+					item.HenHouse,                                     // W
-					formatPercentID(henHouseStd, 2),                  // X
+					henHouseStd,                                       // X
-					formatApprovalStatus(item),                       // Y
+					formatApprovalStatus(item),                        // Y
 					safeExportText(pointerString(item.Approval.Notes)), // Z
-					createdBy,                                        // AA
+					createdBy,                                         // AA
-					formatDateIndonesian(item.CreatedAt),             // AB
+					formatDateIndonesian(item.CreatedAt),              // AB
-					s.name,                                           // AC
+					s.name,                                            // AC
-					s.input,                                          // AD
+					s.input,                                           // AD
+					eggQty(string(utils.FlagTelurUtuh)),               // AE
+					eggKg(string(utils.FlagTelurUtuh)),                // AF
+					eggQty(string(utils.FlagTelurPecah)),              // AG
+					eggKg(string(utils.FlagTelurPecah)),               // AH
+					eggQty(string(utils.FlagTelurPutih)),              // AI
+					eggKg(string(utils.FlagTelurPutih)),               // AJ
+					eggQty(string(utils.FlagTelurRetak)),              // AK
+					eggKg(string(utils.FlagTelurRetak)),               // AL
+					eggQty(string(utils.FlagTelurPapacal)),            // AM
+					eggKg(string(utils.FlagTelurPapacal)),             // AN
+					eggQty(string(utils.FlagTelurJumbo)),              // AO
+					eggKg(string(utils.FlagTelurJumbo)),               // AP
 				}
 
 				for idx, col := range columns {
@@ -379,7 +447,7 @@ func setRecordingExportRows(file *excelize.File, sheet string, items []dto.Recor
 	if err != nil {
 		return err
 	}
-	if err := file.SetCellStyle(sheet, "A3", fmt.Sprintf("AD%d", lastRow), dataCenterStyle); err != nil {
+	if err := file.SetCellStyle(sheet, "A3", fmt.Sprintf("AP%d", lastRow), dataCenterStyle); err != nil {
 		return err
 	}
 
@@ -445,6 +513,7 @@ func setRecordingExportRows(file *excelize.File, sheet string, items []dto.Recor
 
 	mergeCols := []string{"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N",
 		"O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA", "AB",
+		"AE", "AF", "AG", "AH", "AI", "AJ", "AK", "AL", "AM", "AN", "AO", "AP",
 	}
 	for _, rng := range itemRanges {
 		if rng.end > rng.start {
@@ -454,6 +523,53 @@ func setRecordingExportRows(file *excelize.File, sheet string, items []dto.Recor
 		}
 		file.SetCellStyle(sheet, fmt.Sprintf("AC%d", rng.end), fmt.Sprintf("AC%d", rng.end), borderBottomLeftStyle)
 		file.SetCellStyle(sheet, fmt.Sprintf("AD%d", rng.end), fmt.Sprintf("AD%d", rng.end), borderBottomCenterStyle)
+		// Egg columns use center + thick bottom border
+		for _, col := range []string{"AE", "AF", "AG", "AH", "AI", "AJ", "AK", "AL", "AM", "AN", "AO", "AP"} {
+			file.SetCellStyle(sheet, fmt.Sprintf("%s%d", col, rng.end), fmt.Sprintf("%s%d", col, rng.end), borderBottomCenterStyle)
+		}
+	}
+
+	numFmtInt := "0"
+	numberIntStyle, err := file.NewStyle(&excelize.Style{
+		CustomNumFmt: &numFmtInt,
+		Alignment:    &excelize.Alignment{Horizontal: "center", Vertical: "center", WrapText: true},
+		Border:       []excelize.Border{
+			{Type: "left", Color: "E6E6E6", Style: 1},
+			{Type: "top", Color: "E6E6E6", Style: 1},
+			{Type: "bottom", Color: "E6E6E6", Style: 1},
+			{Type: "right", Color: "E6E6E6", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
+	}
+	numFmtFloat := "0.00"
+	numberFloatStyle, err := file.NewStyle(&excelize.Style{
+		CustomNumFmt: &numFmtFloat,
+		Alignment:    &excelize.Alignment{Horizontal: "center", Vertical: "center", WrapText: true},
+		Border:       []excelize.Border{
+			{Type: "left", Color: "E6E6E6", Style: 1},
+			{Type: "top", Color: "E6E6E6", Style: 1},
+			{Type: "bottom", Color: "E6E6E6", Style: 1},
+			{Type: "right", Color: "E6E6E6", Style: 1},
+		},
+	})
+	if err != nil {
+		return err
+	}
+
+	intCols := []string{"E", "I", "AE", "AG", "AI", "AK", "AM", "AO"}
+	for _, col := range intCols {
+		if err := file.SetCellStyle(sheet, col+"3", fmt.Sprintf("%s%d", col, lastRow), numberIntStyle); err != nil {
+			return err
+		}
+	}
+
+	floatCols := []string{"J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "AD", "AF", "AH", "AJ", "AL", "AN", "AP"}
+	for _, col := range floatCols {
+		if err := file.SetCellStyle(sheet, col+"3", fmt.Sprintf("%s%d", col, lastRow), numberFloatStyle); err != nil {
+			return err
+		}
 	}
 
 	return nil

internal/modules/production/recordings/dto/recording.dto.go

@@ -100,14 +100,20 @@ type RecordingFeedUsageDTO struct {
 	PendingQty  float64 `json:"pending_qty"`
 }
 
+type EggExportBreakdownDTO struct {
+	Qty int     `json:"qty"`
+	Kg  float64 `json:"kg"`
+}
+
 type RecordingListDTO struct {
 	RecordingRelationDTO
-	CreatedUser *userDTO.UserRelationDTO  `json:"created_user,omitempty"`
+	CreatedUser        *userDTO.UserRelationDTO          `json:"created_user,omitempty"`
-	CreatedAt   time.Time                 `json:"created_at"`
+	CreatedAt          time.Time                         `json:"created_at"`
-	UpdatedAt   time.Time                 `json:"updated_at"`
+	UpdatedAt          time.Time                         `json:"updated_at"`
-	Kandang     *RecordingKandangDTO      `json:"kandang,omitempty"`
+	Kandang            *RecordingKandangDTO              `json:"kandang,omitempty"`
-	Location    *RecordingLocationDTO     `json:"location,omitempty"`
+	Location           *RecordingLocationDTO             `json:"location,omitempty"`
-	FeedUsage   []RecordingFeedUsageDTO   `json:"feed_usage,omitempty"`
+	FeedUsage          []RecordingFeedUsageDTO           `json:"feed_usage,omitempty"`
+	EggExportBreakdown map[string]EggExportBreakdownDTO  `json:"egg_breakdown,omitempty"`
 }
 
 type RecordingDetailDTO struct {

internal/modules/production/recordings/repositories/recording.repository.go

@@ -51,6 +51,7 @@ type RecordingRepository interface {
 	UpdateEggTotalQty(tx *gorm.DB, eggID uint, totalQty float64) error
 	UpdateEggWeight(tx *gorm.DB, eggID uint, weight *float64) error
 	GetRecordingEggByID(ctx context.Context, id uint, modifier func(*gorm.DB) *gorm.DB) (*entity.RecordingEgg, error)
+	GetEggsWithFlagsByRecordingIDs(ctx context.Context, recordingIDs []uint) ([]entity.RecordingEgg, error)
 
 	ExistsOnDate(ctx context.Context, projectFlockKandangId uint, recordTime time.Time) (bool, error)
 
@@ -581,6 +582,22 @@ func (r *RecordingRepositoryImpl) GetRecordingEggByID(
 	return &egg, nil
 }
 
+func (r *RecordingRepositoryImpl) GetEggsWithFlagsByRecordingIDs(ctx context.Context, recordingIDs []uint) ([]entity.RecordingEgg, error) {
+	if len(recordingIDs) == 0 {
+		return nil, nil
+	}
+
+	var eggs []entity.RecordingEgg
+	err := r.DB().WithContext(ctx).
+		Preload("ProductWarehouse.Product").
+		Where("recording_eggs.recording_id IN ?", recordingIDs).
+		Find(&eggs).Error
+	if err != nil {
+		return nil, err
+	}
+	return eggs, nil
+}
+
 func (r *RecordingRepositoryImpl) ExistsOnDate(ctx context.Context, projectFlockKandangId uint, recordTime time.Time) (bool, error) {
 	if projectFlockKandangId == 0 {
 		return false, nil

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

@@ -46,6 +46,7 @@ type RecordingService interface {
 	DeleteOne(ctx *fiber.Ctx, id uint) error
 	Approval(ctx *fiber.Ctx, req *validation.Approve) ([]entity.Recording, error)
 	GetProgressRows(ctx *fiber.Ctx, query *exportprogress.Query) ([]exportprogress.Row, error)
+	GetEggsWithFlagsByRecordingIDs(ctx context.Context, recordingIDs []uint) ([]entity.RecordingEgg, error)
 }
 
 type recordingService struct {
@@ -198,10 +199,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)
@@ -247,6 +260,10 @@ func (s recordingService) GetProgressRows(c *fiber.Ctx, query *exportprogress.Qu
 	return s.Repository.GetProgressRows(c.Context(), query.StartDate, query.EndDate, scope.IDs, scope.Restrict)
 }
 
+func (s recordingService) GetEggsWithFlagsByRecordingIDs(ctx context.Context, recordingIDs []uint) ([]entity.RecordingEgg, error) {
+	return s.Repository.GetEggsWithFlagsByRecordingIDs(ctx, recordingIDs)
+}
+
 func (s recordingService) GetOne(c *fiber.Ctx, id uint) (*entity.Recording, error) {
 	if err := m.EnsureRecordingAccess(c, s.Repository.DB(), id); err != nil {
 		return nil, err
@@ -1292,17 +1309,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)
+		// Multi-source: target kandang bisa menerima dari multiple transfer terpisah.
-	default:
+		// Pakai EARLIEST transfer (transfer_date ASC) sebagai anchor untuk state evaluation —
-		return true, false, false, false, nil, time.Time{}, nil
+		// kandang dianggap masuk transition/laying berdasarkan batch pertama yang masuk.
-	}
+		allTransfers, allErr := s.TransferLayingRepo.GetAllApprovedByTargetKandang(ctx, recording.ProjectFlockKandangId)
-	if err != nil {
+		if allErr != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
+			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)
+		// Repository sudah ORDER BY transfer_date ASC, id ASC → element [0] adalah earliest.
-		return true, false, false, false, nil, time.Time{}, fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi perubahan populasi recording")
+		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)
+		for i := range existingTransfers {
-		if existingTransfer.SourceProjectFlockKandangId != nil && *existingTransfer.SourceProjectFlockKandangId != 0 {
+			existingTransfer := &existingTransfers[i]
-			existingSourceID = *existingTransfer.SourceProjectFlockKandangId
+			if excludeTransferID != 0 && existingTransfer.Id == excludeTransferID {
-		}
+				continue
-		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 != 0 {
+			// Source di header (single source of truth per migration 20260307130342).
-					existingSourceID = source.SourceProjectFlockKandangId
+			existingSourceID := uint(0)
-					break
+			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(
+			if existingSourceID != sourceProjectFlockKandangID {
-			fiber.StatusBadRequest,
+				continue
-			fmt.Sprintf(
+			}
-				"Kandang tujuan %d sudah memiliki lineage sumber kandang %d dari transfer %s. Tidak boleh ganti ke sumber kandang %d.",
+
-				targetKandangID,
+			return fiber.NewError(
-				existingSourceID,
+				fiber.StatusBadRequest,
-				existingTransfer.TransferNumber,
+				fmt.Sprintf(
-				sourceProjectFlockKandangID,
+					"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/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) {
+// NOTE: NextPoNumber dihapus per migration 20260529143940 — po_number sekarang
-	return r.generateSequentialNumber(ctx, tx, "po_number", utils.PurchasePONumberPrefix, utils.PurchaseNumberPadding)
+// 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,
 	}
@@ -776,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 := derivePoFromPr(purchase.PrNumber)
-			code, err := repoTx.NextPoNumber(c.Context(), tx)
 			if err != nil {
 				return err
 			}
@@ -1406,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
 }
 
@@ -2500,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/dto/repportExpenseDepreciation.dto.go

@@ -16,13 +16,19 @@ type ExpenseDepreciationMetaDTO struct {
 }
 
 type ExpenseDepreciationRowDTO struct {
-	ProjectFlockID               int64   `json:"project_flock_id"`
+	ProjectFlockID                    int64   `json:"project_flock_id"`
-	FarmName                     string  `json:"farm_name"`
+	FarmName                          string  `json:"farm_name"`
-	Period                       string  `json:"period"`
+	Period                            string  `json:"period"`
-	DepreciationPercentEffective float64 `json:"depreciation_percent_effective"`
+	DepreciationPercentEffective      float64 `json:"depreciation_percent_effective"`
-	DepreciationValue            float64 `json:"depreciation_value"`
+	DepreciationValue                 float64 `json:"depreciation_value"`
-	PulletCostDayNTotal          float64 `json:"pullet_cost_day_n_total"`
+	PulletCostDayNTotal               float64 `json:"pullet_cost_day_n_total"`
-	Components                   any     `json:"components"`
+	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/expense_depreciation.repository.go

@@ -37,10 +37,11 @@ type FarmDepreciationManualInputRow struct {
 	Note           *string
 }
 
-type houseDepreciationPercentRow struct {
+type houseMultiplicationPercentageRow struct {
-	HouseType           string
+	HouseType                string
-	Day                 int
+	Day                      int
-	DepreciationPercent float64
+	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)
+	rows := make([]houseMultiplicationPercentageRow, 0)
-	if err := r.db.WithContext(ctx).
+	if err := r.db.WithContext(ctx).Raw(`
-		Table("house_depreciation_standards").
+		SELECT DISTINCT ON (house_type::text, day)
-		Select("house_type::text AS house_type, day, depreciation_percent").
+			house_type::text AS house_type, day, multiplication_percentage, effective_date
-		Where("house_type::text IN ?", houseTypes).
+		FROM house_depreciation_standards
-		Where("day <= ?", maxDay).
+		WHERE house_type::text IN ? AND day <= ?
-		Order("house_type ASC, day ASC").
+		ORDER BY house_type, day, effective_date DESC NULLS LAST
-		Scan(&rows).Error; err != nil {
+	`, houseTypes, maxDay).Scan(&rows).Error; err != nil {
-		return nil, err
+		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),
+				ProjectFlockID:                    int64(candidate.ProjectFlockID),
-				FarmName:                     candidate.FarmName,
+				FarmName:                          candidate.FarmName,
-				Period:                       params.Period,
+				Period:                            params.Period,
-				DepreciationPercentEffective: 0,
+				DepreciationPercentEffective:      0,
-				DepreciationValue:            0,
+				DepreciationValue:                 0,
-				PulletCostDayNTotal:          0,
+				PulletCostDayNTotal:               0,
-				Components:                   map[string]any{},
+				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),
+			ProjectFlockID:                    int64(snapshot.ProjectFlockId),
-			FarmName:                     candidate.FarmName,
+			FarmName:                          candidate.FarmName,
-			Period:                       params.Period,
+			Period:                            params.Period,
-			DepreciationPercentEffective: snapshot.DepreciationPercentEffective,
+			DepreciationPercentEffective:      snapshot.DepreciationPercentEffective,
-			DepreciationValue:            snapshot.DepreciationValue,
+			DepreciationValue:                 snapshot.DepreciationValue,
-			PulletCostDayNTotal:          snapshot.PulletCostDayNTotal,
+			PulletCostDayNTotal:               snapshot.PulletCostDayNTotal,
-			Components:                   parseSnapshotComponents(snapshot.Components),
+			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"`
+	ProjectFlockKandangID             uint    `json:"project_flock_kandang_id"`
-	KandangID             uint    `json:"kandang_id"`
+	KandangID                         uint    `json:"kandang_id"`
-	KandangName           string  `json:"kandang_name"`
+	KandangName                       string  `json:"kandang_name"`
-	TransferID            uint    `json:"transfer_id"`
+	TransferID                        uint    `json:"transfer_id"`
-	TransferDate          string  `json:"transfer_date"`
+	TransferDate                      string  `json:"transfer_date"`
-	SourceProjectFlockID  uint    `json:"source_project_flock_id"`
+	SourceProjectFlockID              uint    `json:"source_project_flock_id"`
-	HouseType             string  `json:"house_type"`
+	HouseType                         string  `json:"house_type"`
-	DayN                  int     `json:"day_n"`
+	DayN                              int     `json:"day_n"`
-	DepreciationPercent   float64 `json:"depreciation_percent"`
+	DepreciationPercent               float64 `json:"depreciation_percent"`
-	TransferQty           float64 `json:"transfer_qty"`
+	MultiplicationPercentage          float64 `json:"multiplication_percentage"`
-	PulletCostDayN        float64 `json:"pullet_cost_day_n"`
+	TransferQty                       float64 `json:"transfer_qty"`
-	DepreciationValue     float64 `json:"depreciation_value"`
+	PulletCostDayN                    float64 `json:"pullet_cost_day_n"`
-	DepreciationSource    string  `json:"depreciation_source,omitempty"`
+	DepreciationValue                 float64 `json:"depreciation_value"`
-	ManualInputID         *uint   `json:"manual_input_id,omitempty"`
+	TotalValuePulletAfterDepreciation float64 `json:"total_value_pullet_after_depreciation"`
-	CutoverDate           string  `json:"cutover_date,omitempty"`
+	DepreciationSource                string  `json:"depreciation_source,omitempty"`
-	OriginDate            string  `json:"origin_date,omitempty"`
+	ManualInputID                     *uint   `json:"manual_input_id,omitempty"`
-	StartScheduleDay      *int    `json:"start_schedule_day,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"`
+	KandangCount    int                            `json:"kandang_count"`
-	Kandang      []depreciationKandangComponent `json:"kandang"`
+	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,
+					ProjectFlockKandangID:             breakdown.ProjectFlockKandangID,
-					KandangID:             breakdown.KandangID,
+					KandangID:                         breakdown.KandangID,
-					KandangName:           breakdown.KandangName,
+					KandangName:                       breakdown.KandangName,
-					SourceProjectFlockID:  hppV2DetailUint(part.Details, "source_project_flock_id"),
+					SourceProjectFlockID:              hppV2DetailUint(part.Details, "source_project_flock_id"),
-					HouseType:             houseType,
+					HouseType:                         houseType,
-					DayN:                  hppV2DetailInt(part.Details, "schedule_day"),
+					DayN:                              hppV2DetailInt(part.Details, "schedule_day"),
-					DepreciationPercent:   hppV2DetailFloat(part.Details, "depreciation_percent"),
+					DepreciationPercent:               hppV2DetailFloat(part.Details, "depreciation_percent"),
-					PulletCostDayN:        hppV2DetailFloat(part.Details, "pullet_cost_day_n"),
+					MultiplicationPercentage:          hppV2DetailFloat(part.Details, "multiplication_percentage"),
-					DepreciationValue:     part.Total,
+					PulletCostDayN:                    hppV2DetailFloat(part.Details, "pullet_cost_day_n"),
-					DepreciationSource:    part.Code,
+					DepreciationValue:                 part.Total,
-					OriginDate:            hppV2DetailString(part.Details, "origin_date"),
+					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]
+	return anyString(details[key])
-	if !exists || raw == nil {
+}
+
+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 {
+	allMdpIDsForAging := make([]uint, 0)
-		transactions, err := s.CustomerPaymentRepo.GetCustomerPaymentTransactions(c.Context(), &customerID)
+	for _, dp := range deliveryProducts {
-		if err != nil {
+		allMdpIDsForAging = append(allMdpIDsForAging, dp.Id)
-			continue
+	}
-		}
+	mdpAllocSummaryForMarketing, err := s.fetchMdpAllocationSummary(c.Context(), allMdpIDsForAging)
-
+	if err != nil {
-		initialBalance, err := s.CustomerPaymentRepo.GetInitialBalanceByCustomer(c.Context(), customerID)
+		return nil, 0, err
-		if err != nil {
+	}
-			initialBalance = 0
+	for _, dp := range deliveryProducts {
-		}
+		summary := mdpAllocSummaryForMarketing[dp.Id]
-
+		soDate := dp.MarketingProduct.Marketing.SoDate
-		runningBalance := initialBalance
+		if customerPaymentStatusFromAllocation(dp.TotalPrice, summary.PaidAmount) == "LUNAS" && !summary.LastPaymentDate.IsZero() {
-		for i, tx := range transactions {
+			days := int(summary.LastPaymentDate.Sub(soDate).Hours() / 24)
-			if tx.TransactionType == "SALES" {
+			if days < 0 {
-				previousBalance := runningBalance
+				days = 0
-				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
 			}
+			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 {
+	for _, tx := range transactions {
-
-		previousBalance := runningBalance
 
 		row := dto.ToCustomerPaymentReportRow(tx)
 
 		if tx.TransactionType == "SALES" {
 			runningBalance -= tx.TotalPrice
-			status, paymentDate := s.determineSalesStatusAndPaymentDate(transactions, i, previousBalance, runningBalance)
+			summary := mdpAllocSummary[uint(tx.TransactionID)]
-			row.Status = status
+			row.Status = customerPaymentStatusFromAllocation(tx.TotalPrice, summary.PaidAmount)
 
-			if status == "LUNAS" {
+			if row.Status == "LUNAS" && !summary.LastPaymentDate.IsZero() {
-				if paymentDate != nil {
+				days := int(summary.LastPaymentDate.Sub(tx.TransDate).Hours() / 24)
-					days := int(paymentDate.Sub(tx.TransDate).Hours() / 24)
+				if days < 0 {
-					row.AgingDay = &days
+					days = 0
-				} else {
-					days := 0
-					row.AgingDay = &days
 				}
+				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) {
+// customerPaymentStatusFromAllocation menentukan status per-MDP berdasarkan
-	currentSales := transactions[currentIndex]
+// SUM(payment_allocations.amount) vs MDP total_price.
-
+func customerPaymentStatusFromAllocation(totalPrice, paidAmount float64) string {
-	if previousBalance >= currentSales.TotalPrice {
+	if totalPrice <= fifoAllocationEpsilon {
-		type paymentAllocation struct {
+		return "LUNAS"
-			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
 	}
-
+	if paidAmount+fifoAllocationEpsilon >= totalPrice {
-	hasPartialPaymentFromBalance := previousBalance > 0 && previousBalance < currentSales.TotalPrice
+		return "LUNAS"
-
-	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 {
-	if hasPayment || hasPartialPaymentFromBalance {
+		return "DIBAYAR SEBAGIAN"
-		return "DIBAYAR SEBAGIAN", nil
 	}
-
+	return "BELUM LUNAS"
-	return "BELUM LUNAS", nil
 }
 
 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
+	// Batch fetch payment allocation summaries (per purchase + per expense) untuk semua supplier.
-		SortTime  time.Time
+	// FIFO matching dilakukan saat payment di-create/update; report tinggal baca dari DB.
-		Amount    float64
+	allPurchaseIDs := make([]uint, 0)
-		CalcAging func(endDate time.Time) int
+	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 {
+	purchaseAllocSummary, err := s.fetchPurchaseAllocationSummary(c.Context(), allPurchaseIDs)
-		Date   time.Time
+	if err != nil {
-		Amount float64
+		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
+			rowRefs = append(rowRefs, rowRef{Index: rowIndex, Kind: "PURCHASE", Purchase: purchase})
-			purchaseAllocations = append(purchaseAllocations, debtSupplierAllocation{
-				RowIndex:  rowIndex,
-				SortTime:  sortTime,
-				Amount:    row.TotalPrice,
-				CalcAging: func(endDate time.Time) int { return calculateDebtSupplierAging(capturedPurchase, endDate, location) },
-			})
 		}
 
 		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
+			rowRefs = append(rowRefs, rowRef{Index: rowIndex, Kind: "EXPENSE", Expense: 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
 		}
 
 		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 {
+		// Determine Status & Aging dari payment_allocations DB.
-			sort.SliceStable(purchaseAllocations, func(i, j int) bool {
+		for _, ref := range rowRefs {
-				return purchaseAllocations[i].SortTime.Before(purchaseAllocations[j].SortTime)
+			rowTotal := combinedRows[ref.Index].Row.TotalPrice
-			})
+			if rowTotal <= fifoAllocationEpsilon {
-			sort.SliceStable(paymentAllocations, func(i, j int) bool {
+				continue
-				return paymentAllocations[i].Date.Before(paymentAllocations[j].Date)
-			})
-			remaining := make([]float64, len(purchaseAllocations))
-			for i := range purchaseAllocations {
-				remaining[i] = purchaseAllocations[i].Amount
 			}
-			purchaseIndex := 0
+			var summary paymentAllocationSummary
-			for _, pay := range paymentAllocations {
+			if ref.Kind == "PURCHASE" {
-				amount := pay.Amount
+				summary = purchaseAllocSummary[ref.Purchase.Id]
-				if amount <= 0 {
+			} else {
-					continue
+				summary = expenseAllocSummary[ref.Expense.Id]
-				}
+			}
-				if paymentCarry > 0 {
+			if summary.PaidAmount+fifoAllocationEpsilon < rowTotal {
-					used := math.Min(amount, paymentCarry)
+				continue
-					paymentCarry -= used
+			}
-					amount -= used
+			combinedRows[ref.Index].Row.Status = "Lunas"
-				}
+			if !summary.LastPaymentDate.IsZero() {
-				for amount > 0 && purchaseIndex < len(remaining) {
+				if ref.Kind == "PURCHASE" {
-					if remaining[purchaseIndex] <= 0 {
+					combinedRows[ref.Index].Row.Aging = calculateDebtSupplierAging(ref.Purchase, summary.LastPaymentDate.In(location), location)
-						purchaseIndex++
+				} else {
-						continue
+					combinedRows[ref.Index].Row.Aging = calculateExpenseAging(ref.Expense, summary.LastPaymentDate.In(location), location)
-					}
-					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
 				}
 			}
 		}
@@ -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() {
+			if item.ReceivedDate != nil && !item.ReceivedDate.IsZero() {
-				continue
+				received := item.ReceivedDate.In(loc)
+				if earliestReceived.IsZero() || received.Before(earliestReceived) {
+					earliestReceived = received
+				}
 			}
-			received := item.ReceivedDate.In(loc)
+			if item.Warehouse != nil && item.Warehouse.Id != 0 && !seenWarehouseIDs[item.Warehouse.Id] {
-			if earliestReceived.IsZero() || received.Before(earliestReceived) {
+				seenWarehouseIDs[item.Warehouse.Id] = true
-				earliestReceived = received
+				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
+	// TotalPrice pakai expense.GrandTotal (= SUM realisasi) supaya konsisten dengan
-	for _, ns := range exp.Nonstocks {
+	// FIFO allocation yang juga pakai realisasi. Hindari pakai SUM nonstock pengajuan
-		totalPrice += ns.Qty * ns.Price
+	// 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
+	// Batch-load laying transfer targets → EARLIEST source PFK chick_in_date per target.
-	// untuk menentukan actual chicken week (bukan hardcode LayingWeekStart offset)
+	// 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 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 = lts.source_project_flock_kandang_id
+			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