adjust list marketing

Rc/01

See merge request mbugroup/lti-api!583

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

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

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

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

internal/common/service/fifo_stock_v2/population_allocation.go

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

internal/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/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,
-		"B": 14,
-		"C": 18,
-		"D": 20,
-		"E": 14,
-		"F": 40,
-		"G": 10,
-		"H": 12,
-		"I": 12,
-		"J": 12,
-		"K": 16,
-		"L": 16,
-		"M": 18,
-		"N": 18,
-		"O": 18,
-		"P": 24,
+		"A": 16, // No. Order
+		"B": 14, // Tanggal
+		"C": 18, // Status
+		"D": 20, // Customer
+		"E": 20, // Sales (new)
+		"F": 14, // Tipe
+		"G": 40, // Nama Produk
+		"H": 20, // Gudang (new)
+		"I": 10, // Week
+		"J": 12, // Jumlah
+		"K": 12, // Qty Peti
+		"L": 16, // Berat Rata-rata (kg)
+		"M": 16, // Total Berat (kg)
+		"N": 18, // Harga Satuan
+		"O": 18, // Total Harga
+		"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
-		"Tanggal",      // B
-		"Status",       // C
-		"Customer",     // D
-		"Tipe",         // E
-		"Nama Produk",  // F
-		"Week",         // G
-		"Jumlah",       // H
-		"Satuan",       // I
-		"Qty Peti",     // J
-		"Berat Rata-rata (kg)", // K
-		"Total Berat (kg)",     // L
-		"Harga Satuan", // M
-		"Total Harga",  // N
-		"Grand Total",  // O
-		"Catatan",      // P
+		"No. Order",            // A
+		"Tanggal",              // B
+		"Status",               // C
+		"Customer",             // D
+		"Sales",                // E (new)
+		"Tipe",                 // F
+		"Nama Produk",          // G
+		"Gudang",               // H (new)
+		"Week",                 // I
+		"Jumlah Butir",         // J
+		"Qty Peti",             // K
+		"Berat Rata-rata (kg)", // L
+		"Total Berat (kg)",     // M
+		"Harga Satuan",         // N
+		"Total Harga",          // O
+		"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,
-				"E": "-", "F": "-", "G": "-", "H": "-", "I": "-", "J": "-",
-				"K": "-", "L": "-", "M": "-", "N": "-",
-				"O": grandTotal, "P": notes,
+				"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 {
@@ -198,9 +346,9 @@ func setMarketingExportRows(file *excelize.File, sheet string, items []dto.Marke
 				week = strconv.Itoa(*prod.Week)
 			}
 
-			satuan := "-"
-			if prod.ConvertionUnit != nil && strings.TrimSpace(*prod.ConvertionUnit) != "" {
-				satuan = *prod.ConvertionUnit
+			gudang := "-"
+			if prod.ProductWarehouse != nil {
+				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,21 @@ func ToMarketingListDTO(marketing *entity.Marketing, deliveryProducts []entity.M
 			salesOrderProducts[i] = ToDeliveryMarketingProductDTO(product, marketing.MarketingType)
 		}
 	}
+	var grandTotalSO, grandTotalDO float64
+	for _, p := range marketing.Products {
+		grandTotalSO += p.TotalPrice
+		if p.DeliveryProduct != nil && p.DeliveryProduct.DeliveryDate != nil {
+			grandTotalDO += p.DeliveryProduct.TotalPrice
+		}
+	}
+
 	return MarketingListDTO{
 		MarketingRelationDTO: ToMarketingRelationDTO(marketing),
 		Customer:             customer,
 		SalesPerson:          salesPerson,
 		SoDocs:               marketing.SoDocs,
+		GrandTotalSO:         grandTotalSO,
+		GrandTotalDO:         grandTotalDO,
 		SalesOrder:           salesOrderProducts,
 		DeliveryOrder:        extractDeliveryGroupsFromProducts(marketing),
 		CreatedUser:          createdUser,

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

@@ -287,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)
 

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)
-	weekBase := 1
-	if upperCategory == string(utils.ProjectFlockCategoryLaying) {
-		weekBase = config.LayingWeekStart()
-	}
-	week := ((day - 1) / 7) + weekBase
+	week := ((day - 1) / 7) + 1
 	if week <= 0 {
 		return nil
 	}
 
+	upperCategory := strings.ToUpper(category)
 	if upperCategory == string(utils.ProjectFlockCategoryLaying) {
 		detail, err := s.ProductionStandardDetailRepo.GetByStandardIDAndWeek(ctx, standardID, week)
 		if err != nil {

internal/modules/production/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
-					locationName,                                   // B
-					safeExportText(item.ProjectFlock.FlockName),    // C
-					kandangName,                                    // D
-					item.ProjectFlock.Period,                        // E
+					i + 1,                                             // A
+					locationName,                                      // B
+					safeExportText(item.ProjectFlock.FlockName),       // C
+					kandangName,                                       // D
+					item.ProjectFlock.Period,                          // E
 					formatCategoryLabel(item.ProjectFlock.ProjectFlockCategory), // F
-					formatAgeLabel(item),                             // G
-					formatDateIndonesian(item.RecordDatetime),        // H
-					formatNumberID(item.ProjectFlock.TotalChickQty, 0, false), // I
-					formatNumberID(item.FcrValue, 2, true),          // J
-					formatNumberID(fcrStd, 2, true),                 // K
-					formatNumberID(item.FeedIntake, 2, true),         // L
-					formatNumberID(feedIntakeStd, 2, true),           // M
-					formatPercentID(item.CumDepletionRate, 2),        // N
-					formatPercentID(maxDepletionStd, 2),              // O
-					formatNumberID(item.TotalDepletionQty, 2, true),  // P
-					formatNumberID(item.EggMass, 2, true),            // Q
-					formatNumberID(eggMassStd, 2, true),              // R
-					formatNumberID(item.EggWeight, 2, true),          // S
-					formatNumberID(eggWeightStd, 2, true),            // T
-					formatPercentID(item.HenDay, 2),                  // U
-					formatPercentID(henDayStd, 2),                    // V
-					formatPercentID(item.HenHouse, 2),                // W
-					formatPercentID(henHouseStd, 2),                  // X
-					formatApprovalStatus(item),                       // Y
+					formatAgeLabel(item),                               // G
+					formatDateIndonesian(item.RecordDatetime),          // H
+					item.ProjectFlock.TotalChickQty,                   // I
+					item.FcrValue,                                     // J
+					fcrStd,                                            // K
+					item.FeedIntake,                                   // L
+					feedIntakeStd,                                     // M
+					item.CumDepletionRate,                             // N
+					maxDepletionStd,                                   // O
+					item.TotalDepletionQty,                            // P
+					item.EggMass,                                      // Q
+					eggMassStd,                                        // R
+					item.EggWeight,                                    // S
+					eggWeightStd,                                      // T
+					item.HenDay,                                       // U
+					henDayStd,                                         // V
+					item.HenHouse,                                     // W
+					henHouseStd,                                       // X
+					formatApprovalStatus(item),                        // Y
 					safeExportText(pointerString(item.Approval.Notes)), // Z
-					createdBy,                                        // AA
-					formatDateIndonesian(item.CreatedAt),             // AB
-					s.name,                                           // AC
-					s.input,                                          // AD
+					createdBy,                                         // AA
+					formatDateIndonesian(item.CreatedAt),              // AB
+					s.name,                                            // AC
+					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"`
-	CreatedAt   time.Time                 `json:"created_at"`
-	UpdatedAt   time.Time                 `json:"updated_at"`
-	Kandang     *RecordingKandangDTO      `json:"kandang,omitempty"`
-	Location    *RecordingLocationDTO     `json:"location,omitempty"`
-	FeedUsage   []RecordingFeedUsageDTO   `json:"feed_usage,omitempty"`
+	CreatedUser        *userDTO.UserRelationDTO          `json:"created_user,omitempty"`
+	CreatedAt          time.Time                         `json:"created_at"`
+	UpdatedAt          time.Time                         `json:"updated_at"`
+	Kandang            *RecordingKandangDTO              `json:"kandang,omitempty"`
+	Location           *RecordingLocationDTO             `json:"location,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 {
@@ -259,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

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

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

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

@@ -779,8 +779,7 @@ func (s *purchaseService) ApproveManagerPurchase(c *fiber.Ctx, id uint, req *val
 	transactionErr := s.PurchaseRepo.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
 		updateData := map[string]any{}
 		if !hasExistingPO {
-			repoTx := rPurchase.NewPurchaseRepository(tx)
-			code, err := repoTx.NextPoNumber(c.Context(), tx)
+			code, err := derivePoFromPr(purchase.PrNumber)
 			if err != nil {
 				return err
 			}
@@ -2513,6 +2512,18 @@ func parseApprovalActionInput(raw string) (entity.ApprovalAction, error) {
 	}
 }
 
+// derivePoFromPr menghasilkan po_number dari pr_number dengan swap prefix.
+// Contoh: "PR-LTI-0050" -> "PO-LTI-0050". Mengembalikan error kalau pr_number
+// tidak diawali prefix standar — caller harus memastikan PR sudah valid.
+func derivePoFromPr(prNumber string) (string, error) {
+	trimmed := strings.TrimSpace(prNumber)
+	if !strings.HasPrefix(trimmed, utils.PurchasePRNumberPrefix) {
+		return "", fmt.Errorf("invalid pr_number %q: missing prefix %q", trimmed, utils.PurchasePRNumberPrefix)
+	}
+	suffix := strings.TrimPrefix(trimmed, utils.PurchasePRNumberPrefix)
+	return utils.PurchasePONumberPrefix + suffix, nil
+}
+
 func (s *purchaseService) rejectAndReload(
 	c *fiber.Ctx,
 	step approvalutils.ApprovalStep,

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

@@ -457,6 +457,29 @@ func (c *RepportController) GetHppPerKandang(ctx *fiber.Ctx) error {
 	return ctx.Status(fiber.StatusOK).JSON(resp)
 }
 
+func (c *RepportController) GetHppPerFarm(ctx *fiber.Ctx) error {
+	data, meta, err := c.RepportService.GetHppPerFarm(ctx)
+	if err != nil {
+		return err
+	}
+
+	resp := struct {
+		Code    int                        `json:"code"`
+		Status  string                     `json:"status"`
+		Message string                     `json:"message"`
+		Meta    dto.HppPerFarmMetaDTO      `json:"meta"`
+		Data    dto.HppPerFarmResponseData `json:"data"`
+	}{
+		Code:    fiber.StatusOK,
+		Status:  "success",
+		Message: "Get HPP per farm successfully",
+		Meta:    *meta,
+		Data:    *data,
+	}
+
+	return ctx.Status(fiber.StatusOK).JSON(resp)
+}
+
 func (c *RepportController) GetCustomerPayment(ctx *fiber.Ctx) error {
 	var customerIDs []uint
 	if customerIDsStr := ctx.Query("customer_ids"); customerIDsStr != "" {

internal/modules/repports/dto/repportHppPerFarm.dto.go

@@ -0,0 +1,79 @@
+package dto
+
+type HppPerFarmFiltersDTO struct {
+	AreaID     string `json:"area_id"`
+	LocationID string `json:"location_id"`
+	StartDate  string `json:"start_date"`
+	EndDate    string `json:"end_date"`
+}
+
+type HppPerFarmMetaDTO struct {
+	Page         int                  `json:"page"`
+	Limit        int                  `json:"limit"`
+	TotalPages   int64                `json:"total_pages"`
+	TotalResults int64                `json:"total_results"`
+	Filters      HppPerFarmFiltersDTO `json:"filters"`
+}
+
+type HppPerFarmResponseData struct {
+	StartDate string               `json:"start_date"`
+	EndDate   string               `json:"end_date"`
+	Rows      []HppPerFarmRowDTO   `json:"rows"`
+	Summary   HppPerFarmSummaryDTO `json:"summary"`
+}
+
+// HppPerFarmRowDTO is one farm (location) row, aggregating all LAYING project
+// flocks within the same location over the selected date range.
+type HppPerFarmRowDTO struct {
+	Location HppPerKandangLocationDTO `json:"location"`
+	// total_cost_rp = depreciation + pakan + ovk + bop (+ other production cost).
+	// DOC/pullet is NOT included here (it is expensed through depreciation);
+	// average_doc_price_rp is provided for information only.
+	TotalCostRp          float64 `json:"total_cost_rp"`
+	FeedCostRp           float64 `json:"feed_cost_rp"`
+	OvkCostRp            float64 `json:"ovk_cost_rp"`
+	BopCostRp            float64 `json:"bop_cost_rp"`
+	DepreciationRp       float64 `json:"depreciation_rp"`
+	OtherCostRp          float64 `json:"other_cost_rp"`
+	EggWeightRecordingKg float64 `json:"egg_weight_recording_kg"`
+	EggWeightDoKg        float64 `json:"egg_weight_do_kg"`
+	HppPerKgProduction   float64 `json:"hpp_per_kg_production"`
+	HppPerKgSales        float64 `json:"hpp_per_kg_sales"`
+	AverageDocPriceRp    int64   `json:"average_doc_price_rp"`
+
+	Flocks []HppPerFarmFlockDTO `json:"flocks"`
+}
+
+// HppPerFarmFlockDTO is the per-project-flock breakdown inside a farm row.
+type HppPerFarmFlockDTO struct {
+	ProjectFlockID       int64   `json:"project_flock_id"`
+	FlockName            string  `json:"flock_name"`
+	TotalCostRp          float64 `json:"total_cost_rp"`
+	FeedCostRp           float64 `json:"feed_cost_rp"`
+	OvkCostRp            float64 `json:"ovk_cost_rp"`
+	BopCostRp            float64 `json:"bop_cost_rp"`
+	DepreciationRp       float64 `json:"depreciation_rp"`
+	OtherCostRp          float64 `json:"other_cost_rp"`
+	EggWeightRecordingKg float64 `json:"egg_weight_recording_kg"`
+	EggWeightDoKg        float64 `json:"egg_weight_do_kg"`
+	HppPerKgProduction   float64 `json:"hpp_per_kg_production"`
+	HppPerKgSales        float64 `json:"hpp_per_kg_sales"`
+	AverageDocPriceRp    int64   `json:"average_doc_price_rp"`
+}
+
+type HppPerFarmSummaryDTO struct {
+	TotalCostRp               float64 `json:"total_cost_rp"`
+	TotalEggWeightRecordingKg float64 `json:"total_egg_weight_recording_kg"`
+	TotalEggWeightDoKg        float64 `json:"total_egg_weight_do_kg"`
+	AverageHppPerKgProduction float64 `json:"average_hpp_per_kg_production"`
+	AverageHppPerKgSales      float64 `json:"average_hpp_per_kg_sales"`
+}
+
+func NewHppPerFarmFiltersDTO(area, location, startDate, endDate string) HppPerFarmFiltersDTO {
+	return HppPerFarmFiltersDTO{
+		AreaID:     area,
+		LocationID: location,
+		StartDate:  startDate,
+		EndDate:    endDate,
+	}
+}

internal/modules/repports/module.go

@@ -37,6 +37,7 @@ func (RepportModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 	purchaseSupplierRepository := repportRepo.NewPurchaseSupplierRepository(db)
 	debtSupplierRepository := repportRepo.NewDebtSupplierRepository(db)
 	hppPerKandangRepository := repportRepo.NewHppPerKandangRepository(db)
+	hppPerFarmRepository := repportRepo.NewHppPerFarmRepository(db)
 	expenseDepreciationRepository := repportRepo.NewExpenseDepreciationRepository(db)
 	productionResultRepository := repportRepo.NewProductionResultRepository(db)
 	customerPaymentRepository := repportRepo.NewCustomerPaymentRepository(db)
@@ -65,6 +66,7 @@ func (RepportModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 		purchaseSupplierRepository,
 		debtSupplierRepository,
 		hppPerKandangRepository,
+		hppPerFarmRepository,
 		productionResultRepository,
 		customerPaymentRepository,
 		balanceMonitoringRepository,

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

@@ -0,0 +1,233 @@
+package repositories
+
+import (
+	"context"
+	"time"
+
+	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
+	"gorm.io/gorm"
+)
+
+// HppPerFarmFlockMetaRow describes a LAYING project flock and the farm
+// (location) it belongs to. Farm identity is project_flocks.location_id.
+type HppPerFarmFlockMetaRow struct {
+	ProjectFlockID uint
+	FlockName      string
+	LocationID     uint
+	LocationName   string
+	AreaID         uint
+}
+
+// HppPerFarmDocRow holds the DOC/pullet acquisition cost trace per flock.
+// Used only as an informational field (average_doc_price_rp); it is NOT part
+// of total_cost because the pullet cost is expensed through depreciation.
+type HppPerFarmDocRow struct {
+	ProjectFlockID uint
+	DocCost        float64
+	DocQty         float64
+}
+
+type HppPerFarmRepository interface {
+	GetCandidateFlocks(ctx context.Context, start time.Time, areaIDs, locationIDs []int64) ([]HppPerFarmFlockMetaRow, error)
+	SumRecordingEggWeightByFlock(ctx context.Context, start, endExclusive time.Time, projectFlockIDs []uint) (map[uint]float64, error)
+	SumMarketingDoTelurWeightByFlock(ctx context.Context, start, endExclusive time.Time, projectFlockIDs []uint) (map[uint]float64, error)
+	GetDocCostByFlock(ctx context.Context, projectFlockIDs []uint) (map[uint]HppPerFarmDocRow, error)
+	DB() *gorm.DB
+}
+
+type hppPerFarmRepository struct {
+	db *gorm.DB
+}
+
+func NewHppPerFarmRepository(db *gorm.DB) HppPerFarmRepository {
+	return &hppPerFarmRepository{db: db}
+}
+
+func (r *hppPerFarmRepository) DB() *gorm.DB {
+	return r.db
+}
+
+// GetCandidateFlocks returns the LAYING project flocks (with their farm/location
+// metadata) that are still active on or after the range start, scoped by area
+// and location. Mirrors ExpenseDepreciationRepository.GetCandidateFarms but adds
+// location info so flocks can be grouped per farm.
+func (r *hppPerFarmRepository) GetCandidateFlocks(ctx context.Context, start time.Time, areaIDs, locationIDs []int64) ([]HppPerFarmFlockMetaRow, error) {
+	rows := make([]HppPerFarmFlockMetaRow, 0)
+
+	query := r.db.WithContext(ctx).
+		Table("project_flocks AS pf").
+		Select(`
+			DISTINCT pf.id AS project_flock_id,
+			pf.flock_name AS flock_name,
+			pf.location_id AS location_id,
+			loc.name AS location_name,
+			pf.area_id AS area_id`).
+		Joins("JOIN project_flock_kandangs AS pfk ON pfk.project_flock_id = pf.id").
+		Joins("JOIN locations AS loc ON loc.id = pf.location_id").
+		Where("pf.deleted_at IS NULL").
+		Where("pf.category = ?", utils.ProjectFlockCategoryLaying).
+		Where("(pfk.closed_at IS NULL OR DATE(pfk.closed_at) >= DATE(?))", start)
+
+	if len(areaIDs) > 0 {
+		query = query.Where("pf.area_id IN ?", areaIDs)
+	}
+	if len(locationIDs) > 0 {
+		query = query.Where("pf.location_id IN ?", locationIDs)
+	}
+
+	if err := query.Order("pf.location_id ASC, pf.id ASC").Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+
+	return rows, nil
+}
+
+// SumRecordingEggWeightByFlock sums recording_eggs.weight (kg) per project flock
+// for non-rejected recordings whose record_datetime falls inside [start, endExclusive).
+func (r *hppPerFarmRepository) SumRecordingEggWeightByFlock(ctx context.Context, start, endExclusive time.Time, projectFlockIDs []uint) (map[uint]float64, error) {
+	result := make(map[uint]float64)
+	if len(projectFlockIDs) == 0 {
+		return result, nil
+	}
+
+	latestApproval := r.db.WithContext(ctx).
+		Table("approvals AS a").
+		Select("a.approvable_id, a.action").
+		Joins(`
+			JOIN (
+				SELECT approvable_id, MAX(action_at) AS latest_action_at
+				FROM approvals
+				WHERE approvable_type = ?
+				GROUP BY approvable_id
+			) AS la ON la.approvable_id = a.approvable_id AND la.latest_action_at = a.action_at`,
+			string(utils.ApprovalWorkflowRecording),
+		)
+
+	type eggRow struct {
+		ProjectFlockID uint
+		Weight         float64
+	}
+	rows := make([]eggRow, 0)
+
+	query := r.db.WithContext(ctx).
+		Table("recordings AS r").
+		Select(`
+			pfk.project_flock_id AS project_flock_id,
+			COALESCE(SUM(re.weight), 0) AS weight`).
+		Joins("JOIN project_flock_kandangs AS pfk ON pfk.id = r.project_flock_kandangs_id").
+		Joins("LEFT JOIN (?) AS la ON la.approvable_id = r.id", latestApproval).
+		Joins("JOIN recording_eggs AS re ON re.recording_id = r.id").
+		Where("pfk.project_flock_id IN ?", projectFlockIDs).
+		Where("r.record_datetime >= ? AND r.record_datetime < ?", start, endExclusive).
+		Where("r.deleted_at IS NULL").
+		Where("(la.action IS NULL OR la.action != ?)", string(entity.ApprovalActionRejected)).
+		Group("pfk.project_flock_id")
+
+	if err := query.Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+
+	for _, row := range rows {
+		result[row.ProjectFlockID] = row.Weight
+	}
+	return result, nil
+}
+
+// SumMarketingDoTelurWeightByFlock sums delivered TELUR weight (marketing_delivery_products.total_weight)
+// per project flock, for delivery_date inside [start, endExclusive). A delivery product that is
+// attributed to multiple flocks is prorated by each flock's allocated qty share, so that
+// the farm total equals the sum of its flocks.
+func (r *hppPerFarmRepository) SumMarketingDoTelurWeightByFlock(ctx context.Context, start, endExclusive time.Time, projectFlockIDs []uint) (map[uint]float64, error) {
+	result := make(map[uint]float64)
+	if len(projectFlockIDs) == 0 {
+		return result, nil
+	}
+
+	telurFlags := []string{
+		string(utils.FlagTelur),
+		string(utils.FlagTelurUtuh),
+		string(utils.FlagTelurPecah),
+		string(utils.FlagTelurPutih),
+		string(utils.FlagTelurRetak),
+	}
+
+	// allocated qty per (marketing_delivery_product, project_flock)
+	attrByFlock := r.db.WithContext(ctx).
+		Table("(?) AS mda", commonRepo.MarketingDeliveryAttributionRowsQuery(r.db.WithContext(ctx))).
+		Select(`
+			mda.marketing_delivery_product_id AS mdp_id,
+			mda.project_flock_id AS project_flock_id,
+			SUM(mda.allocated_qty) AS flock_qty`).
+		Group("mda.marketing_delivery_product_id, mda.project_flock_id")
+
+	// prorate each delivery product's total_weight across its attributed flocks.
+	// Use EXISTS for the TELUR flag filter (not a JOIN) so a product carrying
+	// multiple egg flags does not fan out and double-count the weight share.
+	shareQuery := r.db.WithContext(ctx).
+		Table("(?) AS a", attrByFlock).
+		Select(`
+			a.project_flock_id AS project_flock_id,
+			mdp.total_weight * a.flock_qty / NULLIF(SUM(a.flock_qty) OVER (PARTITION BY a.mdp_id), 0) AS weight_share`).
+		Joins("JOIN marketing_delivery_products AS mdp ON mdp.id = a.mdp_id").
+		Joins("JOIN marketing_products AS mp ON mp.id = mdp.marketing_product_id").
+		Joins("JOIN product_warehouses AS pw ON pw.id = mp.product_warehouse_id").
+		Where("EXISTS (SELECT 1 FROM flags f WHERE f.flagable_id = pw.product_id AND f.flagable_type = ? AND f.name IN ?)", entity.FlagableTypeProduct, telurFlags).
+		Where("mdp.delivery_date >= ? AND mdp.delivery_date < ?", start, endExclusive)
+
+	type doRow struct {
+		ProjectFlockID uint
+		Weight         float64
+	}
+	rows := make([]doRow, 0)
+
+	query := r.db.WithContext(ctx).
+		Table("(?) AS s", shareQuery).
+		Select(`
+			s.project_flock_id AS project_flock_id,
+			COALESCE(SUM(s.weight_share), 0) AS weight`).
+		Where("s.project_flock_id IN ?", projectFlockIDs).
+		Group("s.project_flock_id")
+
+	if err := query.Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+
+	for _, row := range rows {
+		result[row.ProjectFlockID] = row.Weight
+	}
+	return result, nil
+}
+
+// GetDocCostByFlock returns the DOC acquisition cost (qty * purchase price) and qty
+// traced to chick-in per project flock. Informational only.
+func (r *hppPerFarmRepository) GetDocCostByFlock(ctx context.Context, projectFlockIDs []uint) (map[uint]HppPerFarmDocRow, error) {
+	result := make(map[uint]HppPerFarmDocRow)
+	if len(projectFlockIDs) == 0 {
+		return result, nil
+	}
+
+	rows := make([]HppPerFarmDocRow, 0)
+	query := r.db.WithContext(ctx).
+		Table("project_chickins AS pc").
+		Select(`
+			pfk.project_flock_id AS project_flock_id,
+			COALESCE(SUM(sa.qty * COALESCE(pi.price, 0)), 0) AS doc_cost,
+			COALESCE(SUM(sa.qty), 0) AS doc_qty`).
+		Joins("JOIN project_flock_kandangs AS pfk ON pfk.id = pc.project_flock_kandang_id").
+		Joins("LEFT JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = pc.id AND sa.stockable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?", fifo.UsableKeyProjectChickin.String(), fifo.StockableKeyPurchaseItems.String(), entity.StockAllocationStatusActive, entity.StockAllocationPurposeTraceChickin).
+		Joins("LEFT JOIN purchase_items AS pi ON pi.id = sa.stockable_id").
+		Where("pfk.project_flock_id IN ?", projectFlockIDs).
+		Group("pfk.project_flock_id")
+
+	if err := query.Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+
+	for _, row := range rows {
+		result[row.ProjectFlockID] = row
+	}
+	return result, nil
+}

internal/modules/repports/route.go

@@ -23,6 +23,7 @@ func RepportRoutes(v1 fiber.Router, u user.UserService, s repport.RepportService
 	route.Get("/purchase-supplier", m.RequirePermissions(m.P_ReportPurchaseSupplierGetAll), ctrl.GetPurchaseSupplier)
 	route.Get("/debt-supplier", m.RequirePermissions(m.P_ReportDebtSupplierGetAll), ctrl.GetDebtSupplier)
 	route.Get("/hpp-per-kandang", m.RequirePermissions(m.P_ReportHppPerKandangGetAll), ctrl.GetHppPerKandang)
+	route.Get("/hpp-per-farm", m.RequirePermissions(m.P_ReportHppPerKandangGetAll), ctrl.GetHppPerFarm)
 	route.Get("/hpp-v2-breakdown", m.RequirePermissions(m.P_ReportHppPerKandangGetAll), ctrl.GetHppV2Breakdown)
 	route.Get("/production-result/:idProjectFlockKandang", m.RequirePermissions(m.P_ReportProductionResultGetAll), ctrl.GetProductionResult)
 	route.Get("/customer-payment", m.RequirePermissions(m.P_ReportCustomerPaymentGetAll), ctrl.GetCustomerPayment)

internal/modules/repports/services/hpp_per_farm_test.go

@@ -0,0 +1,93 @@
+package service
+
+import (
+	"math"
+	"testing"
+
+	approvalService "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+)
+
+// production-scope total should sum only parts tagged production_cost (a part
+// tagged with both scopes still counts once).
+func TestHppPerFarmProductionScopeTotalPartLevelScopes(t *testing.T) {
+	comp := &approvalService.HppV2Component{
+		Code: "PAKAN",
+		Parts: []approvalService.HppV2ComponentPart{
+			{Total: 100, Scopes: []string{"production_cost"}},
+			{Total: 50, Scopes: []string{"pullet_cost"}},
+			{Total: 25, Scopes: []string{"production_cost", "pullet_cost"}},
+		},
+	}
+	if got := hppPerFarmProductionScopeTotal(comp); got != 125 {
+		t.Fatalf("expected 125, got %v", got)
+	}
+}
+
+// when parts carry no scopes, fall back to the component-level scope.
+func TestHppPerFarmProductionScopeTotalComponentLevelFallback(t *testing.T) {
+	prod := &approvalService.HppV2Component{
+		Code:   "DIRECT_PULLET_PURCHASE",
+		Scopes: []string{"production_cost"},
+		Total:  300,
+		Parts:  []approvalService.HppV2ComponentPart{{Total: 300}},
+	}
+	if got := hppPerFarmProductionScopeTotal(prod); got != 300 {
+		t.Fatalf("expected 300 component fallback, got %v", got)
+	}
+
+	// DOC/pullet is pullet-scope only -> contributes 0 to production cost,
+	// which is exactly why it must not be added to total_cost (depreciation
+	// already expenses the pullet).
+	pulletOnly := &approvalService.HppV2Component{
+		Code:   "DOC_CHICKIN",
+		Scopes: []string{"pullet_cost"},
+		Total:  999,
+		Parts:  []approvalService.HppV2ComponentPart{{Total: 999}},
+	}
+	if got := hppPerFarmProductionScopeTotal(pulletOnly); got != 0 {
+		t.Fatalf("expected 0 for pullet-only component, got %v", got)
+	}
+}
+
+func TestHppPerFarmProductionScopeTotalsByCode(t *testing.T) {
+	b := &approvalService.HppV2Breakdown{
+		Components: []approvalService.HppV2Component{
+			{Code: "PAKAN", Parts: []approvalService.HppV2ComponentPart{{Total: 100, Scopes: []string{"production_cost"}}}},
+			{Code: "OVK", Parts: []approvalService.HppV2ComponentPart{{Total: 40, Scopes: []string{"production_cost"}}}},
+			{Code: "DOC_CHICKIN", Scopes: []string{"pullet_cost"}, Total: 500, Parts: []approvalService.HppV2ComponentPart{{Total: 500}}},
+			{Code: "DEPRECIATION", Scopes: []string{"production_cost"}, Total: 30, Parts: []approvalService.HppV2ComponentPart{{Total: 30, Scopes: []string{"production_cost"}}}},
+		},
+	}
+	got := hppPerFarmProductionScopeTotalsByCode(b)
+	if got["PAKAN"] != 100 {
+		t.Fatalf("expected PAKAN 100, got %v", got["PAKAN"])
+	}
+	if got["OVK"] != 40 {
+		t.Fatalf("expected OVK 40, got %v", got["OVK"])
+	}
+	if got["DOC_CHICKIN"] != 0 {
+		t.Fatalf("expected DOC_CHICKIN production scope 0, got %v", got["DOC_CHICKIN"])
+	}
+	if got["DEPRECIATION"] != 30 {
+		t.Fatalf("expected DEPRECIATION 30, got %v", got["DEPRECIATION"])
+	}
+}
+
+func TestHppPerFarmSafeDiv(t *testing.T) {
+	cases := []struct {
+		num, den, want float64
+	}{
+		{100, 4, 25},
+		{100, 0, 0},
+		{100, -5, 0},
+		{0, 0, 0},
+	}
+	for _, c := range cases {
+		if got := hppPerFarmSafeDiv(c.num, c.den); got != c.want {
+			t.Fatalf("safeDiv(%v,%v)=%v want %v", c.num, c.den, got, c.want)
+		}
+	}
+	if got := hppPerFarmSafeDiv(math.Inf(1), 1); got != 0 {
+		t.Fatalf("expected 0 for inf numerator, got %v", got)
+	}
+}

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

@@ -49,6 +49,7 @@ type RepportService interface {
 	GetPurchaseSupplier(ctx *fiber.Ctx, params *validation.PurchaseSupplierQuery) ([]dto.PurchaseSupplierDTO, int64, error)
 	GetDebtSupplier(ctx *fiber.Ctx, params *validation.DebtSupplierQuery) ([]dto.DebtSupplierDTO, int64, error)
 	GetHppPerKandang(ctx *fiber.Ctx) (*dto.HppPerKandangResponseData, *dto.HppPerKandangMetaDTO, error)
+	GetHppPerFarm(ctx *fiber.Ctx) (*dto.HppPerFarmResponseData, *dto.HppPerFarmMetaDTO, error)
 	GetHppV2Breakdown(ctx *fiber.Ctx, params *validation.HppV2BreakdownQuery) (*approvalService.HppV2Breakdown, error)
 	GetProductionResult(ctx *fiber.Ctx, params *validation.ProductionResultQuery) ([]dto.ProductionResultDTO, int64, error)
 	GetCustomerPayment(ctx *fiber.Ctx, params *validation.CustomerPaymentQuery) ([]dto.CustomerPaymentReportItem, int64, error)
@@ -73,6 +74,7 @@ type repportService struct {
 	PurchaseSupplierRepo         repportRepo.PurchaseSupplierRepository
 	DebtSupplierRepo             repportRepo.DebtSupplierRepository
 	HppPerKandangRepo            repportRepo.HppPerKandangRepository
+	HppPerFarmRepo               repportRepo.HppPerFarmRepository
 	ProductionResultRepo         repportRepo.ProductionResultRepository
 	CustomerPaymentRepo          repportRepo.CustomerPaymentRepository
 	BalanceMonitoringRepo        repportRepo.BalanceMonitoringRepository
@@ -106,6 +108,7 @@ func NewRepportService(
 	purchaseSupplierRepo repportRepo.PurchaseSupplierRepository,
 	debtSupplierRepo repportRepo.DebtSupplierRepository,
 	hppPerKandangRepo repportRepo.HppPerKandangRepository,
+	hppPerFarmRepo repportRepo.HppPerFarmRepository,
 	productionResultRepo repportRepo.ProductionResultRepository,
 	customerPaymentRepo repportRepo.CustomerPaymentRepository,
 	balanceMonitoringRepo repportRepo.BalanceMonitoringRepository,
@@ -130,6 +133,7 @@ func NewRepportService(
 		PurchaseSupplierRepo:         purchaseSupplierRepo,
 		DebtSupplierRepo:             debtSupplierRepo,
 		HppPerKandangRepo:            hppPerKandangRepo,
+		HppPerFarmRepo:               hppPerFarmRepo,
 		ProductionResultRepo:         productionResultRepo,
 		CustomerPaymentRepo:          customerPaymentRepo,
 		BalanceMonitoringRepo:        balanceMonitoringRepo,
@@ -2945,6 +2949,490 @@ func (s *repportService) parseHppPerKandangQuery(ctx *fiber.Ctx) (*validation.Hp
 	return params, filters, nil
 }
 
+const (
+	hppPerFarmProductionScope       = "production_cost"
+	hppPerFarmComponentDepreciation = "DEPRECIATION"
+	hppPerFarmComponentPakan        = "PAKAN"
+	hppPerFarmComponentOvk          = "OVK"
+	hppPerFarmComponentBopRegular   = "BOP_REGULAR"
+	hppPerFarmComponentBopEkspedisi = "BOP_EKSPEDISI"
+	hppPerFarmMaxRangeDays          = 366
+)
+
+// GetHppPerFarm builds the HPP-per-farm report: it groups all LAYING project
+// flocks by location/farm over [start_date, end_date] and reports, per farm,
+// the total cost (pakan + ovk + bop + depreciation) and two cost-per-kg figures
+// — one against egg weight produced (recording_eggs) and one against egg weight
+// sold/delivered (marketing delivery orders). DOC/pullet cost is informational
+// only (it is expensed through depreciation, so it is NOT added to total cost).
+func (s *repportService) GetHppPerFarm(ctx *fiber.Ctx) (*dto.HppPerFarmResponseData, *dto.HppPerFarmMetaDTO, error) {
+	params, filters, err := s.parseHppPerFarmQuery(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+	if err := s.Validate.Struct(params); err != nil {
+		return nil, nil, fiber.NewError(fiber.StatusBadRequest, err.Error())
+	}
+	if s.HppPerFarmRepo == nil {
+		return nil, nil, fiber.NewError(fiber.StatusInternalServerError, "hpp per farm repository is not configured")
+	}
+
+	location, err := time.LoadLocation("Asia/Jakarta")
+	if err != nil {
+		return nil, nil, fiber.NewError(fiber.StatusInternalServerError, "failed to load timezone configuration")
+	}
+	startDate, err := time.ParseInLocation("2006-01-02", params.StartDate, location)
+	if err != nil {
+		return nil, nil, fiber.NewError(fiber.StatusBadRequest, "start_date must follow format YYYY-MM-DD")
+	}
+	endDate, err := time.ParseInLocation("2006-01-02", params.EndDate, location)
+	if err != nil {
+		return nil, nil, fiber.NewError(fiber.StatusBadRequest, "end_date must follow format YYYY-MM-DD")
+	}
+	if endDate.Before(startDate) {
+		return nil, nil, fiber.NewError(fiber.StatusBadRequest, "end_date must be greater than or equal to start_date")
+	}
+	rangeDays := int(endDate.Sub(startDate).Hours()/24) + 1
+	if rangeDays > hppPerFarmMaxRangeDays {
+		return nil, nil, fiber.NewError(fiber.StatusBadRequest, "date range must not exceed 366 days")
+	}
+
+	startOfRange := time.Date(startDate.Year(), startDate.Month(), startDate.Day(), 0, 0, 0, 0, location)
+	endBreakdownDate := time.Date(endDate.Year(), endDate.Month(), endDate.Day(), 0, 0, 0, 0, location)
+	endExclusive := endBreakdownDate.Add(24 * time.Hour)
+	startBreakdownDate := startOfRange.AddDate(0, 0, -1)
+
+	limit := params.Limit
+	if limit <= 0 {
+		limit = 10
+	}
+
+	flockRows, err := s.HppPerFarmRepo.GetCandidateFlocks(ctx.Context(), startOfRange, params.AreaIDs, params.LocationIDs)
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(flockRows) == 0 {
+		meta := &dto.HppPerFarmMetaDTO{
+			Page:         params.Page,
+			Limit:        limit,
+			TotalPages:   1,
+			TotalResults: 0,
+			Filters:      filters,
+		}
+		data := &dto.HppPerFarmResponseData{
+			StartDate: params.StartDate,
+			EndDate:   params.EndDate,
+			Rows:      []dto.HppPerFarmRowDTO{},
+			Summary:   dto.HppPerFarmSummaryDTO{},
+		}
+		return data, meta, nil
+	}
+
+	flockIDs := make([]uint, 0, len(flockRows))
+	for _, row := range flockRows {
+		flockIDs = append(flockIDs, row.ProjectFlockID)
+	}
+
+	depByFlock, err := s.sumHppPerFarmDepreciationOverRange(ctx.Context(), startOfRange, endBreakdownDate, flockIDs)
+	if err != nil {
+		return nil, nil, err
+	}
+	recWeightByFlock, err := s.HppPerFarmRepo.SumRecordingEggWeightByFlock(ctx.Context(), startOfRange, endExclusive, flockIDs)
+	if err != nil {
+		return nil, nil, err
+	}
+	doWeightByFlock, err := s.HppPerFarmRepo.SumMarketingDoTelurWeightByFlock(ctx.Context(), startOfRange, endExclusive, flockIDs)
+	if err != nil {
+		return nil, nil, err
+	}
+	docByFlock, err := s.HppPerFarmRepo.GetDocCostByFlock(ctx.Context(), flockIDs)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	type hppPerFarmAggregate struct {
+		locationID   uint
+		locationName string
+		totalCost    float64
+		feed         float64
+		ovk          float64
+		bop          float64
+		depreciation float64
+		other        float64
+		recWeight    float64
+		doWeight     float64
+		docCost      float64
+		docQty       float64
+		flocks       []dto.HppPerFarmFlockDTO
+	}
+
+	farmOrder := make([]uint, 0)
+	farms := make(map[uint]*hppPerFarmAggregate)
+
+	for _, flock := range flockRows {
+		flockID := flock.ProjectFlockID
+
+		codeTotals, err := s.hppPerFarmFlockCostRange(ctx.Context(), flockID, startBreakdownDate, endBreakdownDate)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		feed := codeTotals[hppPerFarmComponentPakan]
+		ovk := codeTotals[hppPerFarmComponentOvk]
+		bop := codeTotals[hppPerFarmComponentBopRegular] + codeTotals[hppPerFarmComponentBopEkspedisi]
+		nonDepreciation := 0.0
+		for _, value := range codeTotals {
+			nonDepreciation += value
+		}
+		other := nonDepreciation - feed - ovk - bop
+		depreciation := depByFlock[flockID]
+		totalCost := nonDepreciation + depreciation
+
+		recWeight := recWeightByFlock[flockID]
+		doWeight := doWeightByFlock[flockID]
+
+		averageDocPrice := int64(0)
+		if doc, ok := docByFlock[flockID]; ok && doc.DocQty > 0 {
+			averageDocPrice = int64(math.Round(doc.DocCost / doc.DocQty))
+		}
+
+		flockDTO := dto.HppPerFarmFlockDTO{
+			ProjectFlockID:       int64(flockID),
+			FlockName:            flock.FlockName,
+			TotalCostRp:          totalCost,
+			FeedCostRp:           feed,
+			OvkCostRp:            ovk,
+			BopCostRp:            bop,
+			DepreciationRp:       depreciation,
+			OtherCostRp:          other,
+			EggWeightRecordingKg: recWeight,
+			EggWeightDoKg:        doWeight,
+			HppPerKgProduction:   hppPerFarmSafeDiv(totalCost, recWeight),
+			HppPerKgSales:        hppPerFarmSafeDiv(totalCost, doWeight),
+			AverageDocPriceRp:    averageDocPrice,
+		}
+
+		farm, ok := farms[flock.LocationID]
+		if !ok {
+			farm = &hppPerFarmAggregate{
+				locationID:   flock.LocationID,
+				locationName: flock.LocationName,
+				flocks:       make([]dto.HppPerFarmFlockDTO, 0, 1),
+			}
+			farms[flock.LocationID] = farm
+			farmOrder = append(farmOrder, flock.LocationID)
+		}
+		farm.flocks = append(farm.flocks, flockDTO)
+		farm.totalCost += totalCost
+		farm.feed += feed
+		farm.ovk += ovk
+		farm.bop += bop
+		farm.depreciation += depreciation
+		farm.other += other
+		farm.recWeight += recWeight
+		farm.doWeight += doWeight
+		if doc, ok := docByFlock[flockID]; ok {
+			farm.docCost += doc.DocCost
+			farm.docQty += doc.DocQty
+		}
+	}
+
+	rows := make([]dto.HppPerFarmRowDTO, 0, len(farmOrder))
+	summary := dto.HppPerFarmSummaryDTO{}
+	for _, locID := range farmOrder {
+		farm := farms[locID]
+		averageDocPrice := int64(0)
+		if farm.docQty > 0 {
+			averageDocPrice = int64(math.Round(farm.docCost / farm.docQty))
+		}
+		rows = append(rows, dto.HppPerFarmRowDTO{
+			Location:             dto.HppPerKandangLocationDTO{ID: int64(farm.locationID), Name: farm.locationName},
+			TotalCostRp:          farm.totalCost,
+			FeedCostRp:           farm.feed,
+			OvkCostRp:            farm.ovk,
+			BopCostRp:            farm.bop,
+			DepreciationRp:       farm.depreciation,
+			OtherCostRp:          farm.other,
+			EggWeightRecordingKg: farm.recWeight,
+			EggWeightDoKg:        farm.doWeight,
+			HppPerKgProduction:   hppPerFarmSafeDiv(farm.totalCost, farm.recWeight),
+			HppPerKgSales:        hppPerFarmSafeDiv(farm.totalCost, farm.doWeight),
+			AverageDocPriceRp:    averageDocPrice,
+			Flocks:               farm.flocks,
+		})
+		summary.TotalCostRp += farm.totalCost
+		summary.TotalEggWeightRecordingKg += farm.recWeight
+		summary.TotalEggWeightDoKg += farm.doWeight
+	}
+	summary.AverageHppPerKgProduction = hppPerFarmSafeDiv(summary.TotalCostRp, summary.TotalEggWeightRecordingKg)
+	summary.AverageHppPerKgSales = hppPerFarmSafeDiv(summary.TotalCostRp, summary.TotalEggWeightDoKg)
+
+	totalResults := int64(len(rows))
+	totalPages := int64(1)
+	if totalResults > 0 {
+		totalPages = int64(math.Ceil(float64(totalResults) / float64(limit)))
+	}
+
+	offset := (params.Page - 1) * limit
+	if offset < 0 {
+		offset = 0
+	}
+	if offset > len(rows) {
+		offset = len(rows)
+	}
+	end := offset + limit
+	if end > len(rows) {
+		end = len(rows)
+	}
+
+	meta := &dto.HppPerFarmMetaDTO{
+		Page:         params.Page,
+		Limit:        limit,
+		TotalPages:   totalPages,
+		TotalResults: totalResults,
+		Filters:      filters,
+	}
+	data := &dto.HppPerFarmResponseData{
+		StartDate: params.StartDate,
+		EndDate:   params.EndDate,
+		Rows:      rows[offset:end],
+		Summary:   summary,
+	}
+	return data, meta, nil
+}
+
+// hppPerFarmFlockCostRange returns the range-scoped production cost per component
+// code for a project flock, EXCLUDING depreciation (which is summed separately
+// from daily snapshots). Each non-depreciation production component is cumulative
+// up to a date in the HPP v2 engine, so the range value is the difference between
+// the cumulative breakdown at end and at the day before the range start.
+func (s *repportService) hppPerFarmFlockCostRange(ctx context.Context, projectFlockID uint, startBreakdownDate, endBreakdownDate time.Time) (map[string]float64, error) {
+	if s.HppCostRepo == nil {
+		return nil, errors.New("hpp cost repository is not configured")
+	}
+	if s.HppV2Svc == nil {
+		return nil, errors.New("hpp v2 service is not configured")
+	}
+
+	codeTotals := make(map[string]float64)
+	pfkIDs, err := s.HppCostRepo.GetProjectFlockKandangIDs(ctx, projectFlockID)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, pfkID := range pfkIDs {
+		endBreakdown, err := s.HppV2Svc.CalculateHppBreakdown(pfkID, &endBreakdownDate)
+		if err != nil {
+			return nil, err
+		}
+		startBreakdown, err := s.HppV2Svc.CalculateHppBreakdown(pfkID, &startBreakdownDate)
+		if err != nil {
+			return nil, err
+		}
+
+		endMap := hppPerFarmProductionScopeTotalsByCode(endBreakdown)
+		startMap := hppPerFarmProductionScopeTotalsByCode(startBreakdown)
+
+		seen := make(map[string]bool, len(endMap)+len(startMap))
+		for code := range endMap {
+			seen[code] = true
+		}
+		for code := range startMap {
+			seen[code] = true
+		}
+		for code := range seen {
+			if code == hppPerFarmComponentDepreciation {
+				continue
+			}
+			codeTotals[code] += endMap[code] - startMap[code]
+		}
+	}
+
+	return codeTotals, nil
+}
+
+// sumHppPerFarmDepreciationOverRange sums the daily depreciation_value from
+// farm_depreciation_snapshots across [startDate, endDate] per project flock,
+// computing (and persisting) any missing daily snapshot on demand — same lazy
+// compute path the single-day depreciation report uses.
+func (s *repportService) sumHppPerFarmDepreciationOverRange(ctx context.Context, startDate, endDate time.Time, projectFlockIDs []uint) (map[uint]float64, error) {
+	acc := make(map[uint]float64, len(projectFlockIDs))
+	if len(projectFlockIDs) == 0 {
+		return acc, nil
+	}
+	if s.ExpenseDepreciationRepo == nil {
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "expense depreciation repository is not configured")
+	}
+
+	for day := startDate; !day.After(endDate); day = day.AddDate(0, 0, 1) {
+		snapshots, err := s.ExpenseDepreciationRepo.GetSnapshotsByPeriodAndFarmIDs(ctx, day, projectFlockIDs)
+		if err != nil {
+			return nil, err
+		}
+		byID := make(map[uint]entity.FarmDepreciationSnapshot, len(snapshots))
+		for _, snapshot := range snapshots {
+			byID[snapshot.ProjectFlockId] = snapshot
+		}
+
+		missing := make([]uint, 0)
+		for _, id := range projectFlockIDs {
+			if _, ok := byID[id]; !ok {
+				missing = append(missing, id)
+			}
+		}
+		if len(missing) > 0 {
+			computed, err := s.computeExpenseDepreciationSnapshots(ctx, day, missing, nil)
+			if err != nil {
+				return nil, err
+			}
+			if len(computed) > 0 {
+				if err := s.ExpenseDepreciationRepo.UpsertSnapshots(ctx, computed); err != nil {
+					return nil, err
+				}
+				for _, snapshot := range computed {
+					byID[snapshot.ProjectFlockId] = snapshot
+				}
+			}
+		}
+
+		for id, snapshot := range byID {
+			acc[id] += snapshot.DepreciationValue
+		}
+	}
+
+	return acc, nil
+}
+
+func hppPerFarmProductionScopeTotalsByCode(breakdown *approvalService.HppV2Breakdown) map[string]float64 {
+	out := make(map[string]float64)
+	if breakdown == nil {
+		return out
+	}
+	for i := range breakdown.Components {
+		comp := &breakdown.Components[i]
+		out[comp.Code] += hppPerFarmProductionScopeTotal(comp)
+	}
+	return out
+}
+
+// hppPerFarmProductionScopeTotal mirrors the engine's componentScopeTotal for the
+// production_cost scope (that helper is unexported in the common service package).
+func hppPerFarmProductionScopeTotal(component *approvalService.HppV2Component) float64 {
+	if component == nil {
+		return 0
+	}
+	total := 0.0
+	hasPartScopes := false
+	for i := range component.Parts {
+		part := &component.Parts[i]
+		if len(part.Scopes) == 0 {
+			continue
+		}
+		hasPartScopes = true
+		for _, scope := range part.Scopes {
+			if scope == hppPerFarmProductionScope {
+				total += part.Total
+				break
+			}
+		}
+	}
+	if hasPartScopes {
+		return total
+	}
+	for _, scope := range component.Scopes {
+		if scope == hppPerFarmProductionScope {
+			return component.Total
+		}
+	}
+	return 0
+}
+
+func hppPerFarmSafeDiv(numerator, denominator float64) float64 {
+	if denominator <= 0 {
+		return 0
+	}
+	value := numerator / denominator
+	if math.IsNaN(value) || math.IsInf(value, 0) {
+		return 0
+	}
+	return value
+}
+
+func (s *repportService) parseHppPerFarmQuery(ctx *fiber.Ctx) (*validation.HppPerFarmQuery, dto.HppPerFarmFiltersDTO, error) {
+	page := ctx.QueryInt("page", 1)
+	if page < 1 {
+		page = 1
+	}
+	limit := ctx.QueryInt("limit", 10)
+	if limit < 1 {
+		limit = 10
+	}
+
+	rawArea := ctx.Query("area_id", "")
+	rawLocation := ctx.Query("location_id", "")
+	startDate := ctx.Query("start_date", "")
+	endDate := ctx.Query("end_date", "")
+
+	if strings.TrimSpace(startDate) == "" {
+		return nil, dto.HppPerFarmFiltersDTO{}, fiber.NewError(fiber.StatusBadRequest, "start_date is required")
+	}
+	if strings.TrimSpace(endDate) == "" {
+		return nil, dto.HppPerFarmFiltersDTO{}, fiber.NewError(fiber.StatusBadRequest, "end_date is required")
+	}
+	if strings.TrimSpace(rawLocation) == "" {
+		return nil, dto.HppPerFarmFiltersDTO{}, fiber.NewError(fiber.StatusBadRequest, "location_id is required")
+	}
+
+	areaIDs, err := parseCommaSeparatedInt64s(rawArea)
+	if err != nil {
+		return nil, dto.HppPerFarmFiltersDTO{}, fiber.NewError(fiber.StatusBadRequest, err.Error())
+	}
+	locationIDs, err := parseCommaSeparatedInt64s(rawLocation)
+	if err != nil {
+		return nil, dto.HppPerFarmFiltersDTO{}, fiber.NewError(fiber.StatusBadRequest, err.Error())
+	}
+
+	locationScope, err := m.ResolveLocationScope(ctx, s.ExpenseRealizationRepo.DB())
+	if err != nil {
+		return nil, dto.HppPerFarmFiltersDTO{}, err
+	}
+	areaScope, err := m.ResolveAreaScope(ctx, s.ExpenseRealizationRepo.DB())
+	if err != nil {
+		return nil, dto.HppPerFarmFiltersDTO{}, err
+	}
+	if locationScope.Restrict {
+		allowed := toInt64Slice(locationScope.IDs)
+		if len(allowed) == 0 {
+			locationIDs = []int64{-1}
+		} else if len(locationIDs) > 0 {
+			locationIDs = intersectInt64(locationIDs, allowed)
+		} else {
+			locationIDs = allowed
+		}
+	}
+	if areaScope.Restrict {
+		allowed := toInt64Slice(areaScope.IDs)
+		if len(allowed) == 0 {
+			areaIDs = []int64{-1}
+		} else if len(areaIDs) > 0 {
+			areaIDs = intersectInt64(areaIDs, allowed)
+		} else {
+			areaIDs = allowed
+		}
+	}
+
+	params := &validation.HppPerFarmQuery{
+		Page:        page,
+		Limit:       limit,
+		StartDate:   startDate,
+		EndDate:     endDate,
+		AreaIDs:     areaIDs,
+		LocationIDs: locationIDs,
+	}
+	filters := dto.NewHppPerFarmFiltersDTO(rawArea, rawLocation, startDate, endDate)
+	return params, filters, nil
+}
+
 func (s *repportService) parseExpenseDepreciationQuery(ctx *fiber.Ctx) (*validation.ExpenseDepreciationQuery, dto.ExpenseDepreciationFiltersDTO, error) {
 	page := ctx.QueryInt("page", 1)
 	if page < 1 {

internal/modules/repports/validations/repport.validation.go

@@ -78,6 +78,15 @@ type HppPerKandangQuery struct {
 	WeightMax      *float64 `query:"-"`
 }
 
+type HppPerFarmQuery struct {
+	Page        int     `query:"page" validate:"omitempty,min=1,gt=0"`
+	Limit       int     `query:"limit" validate:"omitempty,min=1,gt=0"`
+	StartDate   string  `query:"start_date" validate:"required,datetime=2006-01-02"`
+	EndDate     string  `query:"end_date" validate:"required,datetime=2006-01-02"`
+	AreaIDs     []int64 `query:"-"`
+	LocationIDs []int64 `query:"-"`
+}
+
 type HppV2BreakdownQuery struct {
 	ProjectFlockKandangID uint   `query:"project_flock_kandang_id" validate:"required,gt=0"`
 	Period                string `query:"period" validate:"required,datetime=2006-01-02"`