fix calculate schedule day

cmd/seed-house-depreciation-standards/main.go

@@ -0,0 +1,638 @@
+// Command seed-house-depreciation-standards membaca kurva depresiasi per-day
+// dari file Excel, lalu meng-generate file migration {up,down}.sql yang
+// menyisipkan baris house_depreciation_standards dengan project_flock_ids
+// berisi semua flock yang memakai kurva tersebut.
+//
+// Kurva disimpan SEKALI di DB sebagai satu baris dengan
+// project_flock_ids = ARRAY[52,53,54]::bigint[]. Lookup di engine pakai
+// ? = ANY(project_flock_ids), sehingga tidak ada duplikasi baris.
+//
+// Hanya multiplication_percentage yang di-override; house_type & standard_week
+// diwarisi dari baris global (project_flock_ids IS NULL) untuk hari yang sama,
+// dan depreciation_percent diturunkan = (1 - multiplication_percentage) * 100.
+//
+// Jalankan lokal (tidak ada API yang di-hit di production):
+//
+//	go run ./cmd/seed-house-depreciation-standards \
+//	  -project-flock-ids=52,53,54 -file=curve.xlsx         # dry-run
+//	go run ./cmd/seed-house-depreciation-standards \
+//	  -project-flock-ids=52,53,54 -file=curve.xlsx -apply  # tulis migration
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/xuri/excelize/v2"
+	"gitlab.com/mbugroup/lti-api.git/internal/config"
+	"gitlab.com/mbugroup/lti-api.git/internal/database"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gorm.io/gorm"
+)
+
+const (
+	dateLayout        = "2006-01-02"
+	timestampLayout   = "20060102150405"
+	defaultMigrations = "internal/database/migrations"
+	headerDay         = "day"
+	headerMultiplier  = "multiplication_percentage"
+)
+
+type options struct {
+	ProjectFlockIDs string // comma-separated flock IDs (wajib, min 1)
+	FilePath        string
+	Sheet           string
+	EffectiveDate   string
+	HouseType       string
+	OutDir          string
+	Apply           bool
+}
+
+type curveRow struct {
+	Day    int
+	Mult   float64
+	ColRef string // Excel column letter (e.g. "B"), untuk error reporting
+}
+
+type validationIssue struct {
+	Row     int
+	Field   string
+	Message string
+}
+
+func (i validationIssue) String() string {
+	if i.Row > 0 {
+		return fmt.Sprintf("row=%d field=%s message=%s", i.Row, i.Field, i.Message)
+	}
+	return fmt.Sprintf("field=%s message=%s", i.Field, i.Message)
+}
+
+func main() {
+	var opts options
+	flag.StringVar(&opts.ProjectFlockIDs, "project-flock-ids", "", "Comma-separated LAYING project flock IDs yang memakai kurva ini (required, e.g. 52,53,54)")
+	flag.StringVar(&opts.FilePath, "file", "", "Path ke .xlsx — format horizontal: baris 'day' dan 'multiplication_percentage' (required)")
+	flag.StringVar(&opts.Sheet, "sheet", "", "Nama sheet (opsional; default: sheet pertama)")
+	flag.StringVar(&opts.EffectiveDate, "effective-date", "", "effective_date untuk baris yang di-insert (YYYY-MM-DD; default: hari ini)")
+	flag.StringVar(&opts.HouseType, "house-type", "", "Override house_type (open_house|close_house). Default: di-derive dari kandang flock")
+	flag.StringVar(&opts.OutDir, "out-dir", defaultMigrations, "Direktori output file migration")
+	flag.BoolVar(&opts.Apply, "apply", false, "Tulis file migration. Jika false: dry-run (cetak SQL ke stdout)")
+	flag.Parse()
+
+	opts.FilePath = strings.TrimSpace(opts.FilePath)
+	opts.Sheet = strings.TrimSpace(opts.Sheet)
+	opts.OutDir = strings.TrimSpace(opts.OutDir)
+
+	if strings.TrimSpace(opts.ProjectFlockIDs) == "" {
+		log.Fatal("--project-flock-ids is required")
+	}
+	flockIDs, err := parseFlockIDs(opts.ProjectFlockIDs)
+	if err != nil {
+		log.Fatalf("--project-flock-ids: %v", err)
+	}
+
+	if opts.FilePath == "" {
+		log.Fatal("--file is required")
+	}
+
+	location, err := time.LoadLocation("Asia/Jakarta")
+	if err != nil {
+		log.Fatalf("failed to load timezone Asia/Jakarta: %v", err)
+	}
+
+	effectiveDate, err := resolveEffectiveDate(opts.EffectiveDate, location)
+	if err != nil {
+		log.Fatalf("invalid --effective-date: %v", err)
+	}
+	opts.EffectiveDate = effectiveDate.Format(dateLayout)
+
+	sheetName, curve, parseIssues, err := parseCurveFile(opts.FilePath, opts.Sheet)
+	if err != nil {
+		log.Fatalf("failed reading excel: %v", err)
+	}
+
+	ctx := context.Background()
+	db := database.Connect(config.DBHost, config.DBName)
+
+	for _, id := range flockIDs {
+		if err := assertActiveLayingFlock(ctx, db, id); err != nil {
+			log.Fatalf("flock %d: %v", id, err)
+		}
+	}
+
+	houseTypes, err := resolveHouseTypesForFlocks(ctx, db, flockIDs, opts.HouseType)
+	if err != nil {
+		log.Fatalf("house_type resolution failed: %v", err)
+	}
+
+	// Days yang tidak ada di global standard cukup di-skip oleh JOIN LATERAL (inner join) —
+	// tidak perlu validasi coverage; tidak ada global row = tidak ada INSERT, bukan error.
+	issues := append([]validationIssue{}, parseIssues...)
+	sortValidationIssues(issues)
+
+	fmt.Printf("Mode: %s\n", modeLabel(opts.Apply))
+	fmt.Printf("File: %s\n", opts.FilePath)
+	fmt.Printf("Sheet: %s\n", sheetName)
+	fmt.Printf("Project flock IDs: %s\n", formatFlockIDs(flockIDs))
+	fmt.Printf("House types: %s\n", strings.Join(houseTypes, ", "))
+	fmt.Printf("Effective date: %s\n", opts.EffectiveDate)
+	fmt.Printf("Curve rows parsed: %d\n", len(curve))
+	if len(curve) > 0 {
+		minDay, maxDay := dayRange(curve)
+		fmt.Printf("Day range: %d..%d\n", minDay, maxDay)
+	}
+	fmt.Printf("Validation errors: %d\n", len(issues))
+	fmt.Println()
+
+	if len(issues) > 0 {
+		fmt.Println("Validation errors:")
+		for _, issue := range issues {
+			fmt.Printf("ERROR %s\n", issue.String())
+		}
+		os.Exit(1)
+	}
+
+	upSQL := buildUpSQL(opts, houseTypes, curve, flockIDs)
+	downSQL := buildDownSQL(opts, flockIDs)
+
+	prefix := time.Now().In(location).Format(timestampLayout)
+	suffix := formatFlockIDsForFilename(flockIDs)
+	upName := fmt.Sprintf("%s_seed_house_depreciation_flocks_%s.up.sql", prefix, suffix)
+	downName := fmt.Sprintf("%s_seed_house_depreciation_flocks_%s.down.sql", prefix, suffix)
+
+	if !opts.Apply {
+		fmt.Printf("--- %s ---\n%s\n", upName, upSQL)
+		fmt.Printf("--- %s ---\n%s\n", downName, downSQL)
+		fmt.Printf("Dry-run: would write 2 files to %s. Re-run with -apply to create them.\n", opts.OutDir)
+		return
+	}
+
+	upPath := filepath.Join(opts.OutDir, upName)
+	downPath := filepath.Join(opts.OutDir, downName)
+	if err := os.WriteFile(upPath, []byte(upSQL), 0o644); err != nil {
+		log.Fatalf("failed writing %s: %v", upPath, err)
+	}
+	if err := os.WriteFile(downPath, []byte(downSQL), 0o644); err != nil {
+		log.Fatalf("failed writing %s: %v", downPath, err)
+	}
+
+	fmt.Printf("WROTE %s\n", upPath)
+	fmt.Printf("WROTE %s\n", downPath)
+	fmt.Println("Review the SQL, commit it, then deploy runs `make migrate-up`.")
+}
+
+// --- validation helpers -------------------------------------------------------
+
+func parseFlockIDs(raw string) ([]uint, error) {
+	parts := strings.Split(raw, ",")
+	ids := make([]uint, 0, len(parts))
+	seen := make(map[uint]bool)
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p == "" {
+			continue
+		}
+		n, err := strconv.ParseUint(p, 10, 64)
+		if err != nil || n == 0 {
+			return nil, fmt.Errorf("invalid flock ID %q: must be a positive integer", p)
+		}
+		id := uint(n)
+		if seen[id] {
+			return nil, fmt.Errorf("duplicate flock ID %d", id)
+		}
+		seen[id] = true
+		ids = append(ids, id)
+	}
+	if len(ids) == 0 {
+		return nil, fmt.Errorf("at least one project flock ID required")
+	}
+	// Sort IDs so generated SQL and filename are deterministic.
+	sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
+	return ids, nil
+}
+
+func formatFlockIDs(ids []uint) string {
+	parts := make([]string, len(ids))
+	for i, id := range ids {
+		parts[i] = strconv.FormatUint(uint64(id), 10)
+	}
+	return strings.Join(parts, ", ")
+}
+
+// formatFlockIDsForFilename returns "52_53_54" for use in migration filenames.
+// Truncates to first 4 IDs if many, to keep filename reasonable.
+func formatFlockIDsForFilename(ids []uint) string {
+	display := ids
+	suffix := ""
+	if len(ids) > 4 {
+		display = ids[:4]
+		suffix = fmt.Sprintf("_and_%d_more", len(ids)-4)
+	}
+	parts := make([]string, len(display))
+	for i, id := range display {
+		parts[i] = strconv.FormatUint(uint64(id), 10)
+	}
+	return strings.Join(parts, "_") + suffix
+}
+
+// --- effective date -----------------------------------------------------------
+
+func resolveEffectiveDate(raw string, location *time.Location) (time.Time, error) {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		now := time.Now().In(location)
+		return time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, location), nil
+	}
+	parsed, err := time.ParseInLocation(dateLayout, raw, location)
+	if err != nil {
+		return time.Time{}, fmt.Errorf("must follow format YYYY-MM-DD")
+	}
+	return parsed, nil
+}
+
+// --- excel parsing -----------------------------------------------------------
+
+// parseCurveFile membaca format horizontal dari Excel:
+//
+//	Baris 1 (label "day"):                    day | 1 | 2 | 3 | ...
+//	Baris 2 (label "multiplication_percentage"):  mp  | 0.997.. | 0.997.. | ...
+//
+// Kedua baris bisa ada di urutan berapa pun, dideteksi lewat label di kolom A.
+// Kolom A adalah label; data mulai dari kolom B seterusnya.
+func parseCurveFile(filePath, requestedSheet string) (string, []curveRow, []validationIssue, error) {
+	workbook, err := excelize.OpenFile(filePath)
+	if err != nil {
+		return "", nil, nil, err
+	}
+	defer func() { _ = workbook.Close() }()
+
+	sheetName, err := resolveSheetName(workbook, requestedSheet)
+	if err != nil {
+		return "", nil, nil, err
+	}
+
+	allRows, err := workbook.GetRows(sheetName, excelize.Options{RawCellValue: true})
+	if err != nil {
+		return "", nil, nil, err
+	}
+	if len(allRows) == 0 {
+		return sheetName, nil, []validationIssue{{Field: "sheet", Message: "sheet is empty"}}, nil
+	}
+
+	var dayRow, multRow []string
+	for _, row := range allRows {
+		if len(row) == 0 {
+			continue
+		}
+		switch normalizeHeader(row[0]) {
+		case headerDay:
+			dayRow = row
+		case headerMultiplier:
+			multRow = row
+		}
+	}
+
+	issues := make([]validationIssue, 0)
+	if dayRow == nil {
+		issues = append(issues, validationIssue{Field: headerDay, Message: `baris dengan label "day" di kolom A tidak ditemukan`})
+	}
+	if multRow == nil {
+		issues = append(issues, validationIssue{Field: headerMultiplier, Message: `baris dengan label "multiplication_percentage" di kolom A tidak ditemukan`})
+	}
+	if len(issues) > 0 {
+		return sheetName, nil, issues, nil
+	}
+
+	maxCols := len(dayRow)
+	if len(multRow) > maxCols {
+		maxCols = len(multRow)
+	}
+
+	rows := make([]curveRow, 0, maxCols-1)
+	seenDays := make(map[int]string)
+
+	for colIdx := 1; colIdx < maxCols; colIdx++ {
+		dayRaw := strings.TrimSpace(cellValue(dayRow, colIdx))
+		multRaw := strings.TrimSpace(cellValue(multRow, colIdx))
+		if dayRaw == "" && multRaw == "" {
+			continue
+		}
+
+		colName, _ := excelize.ColumnNumberToName(colIdx + 1)
+
+		var colIssues []validationIssue
+		day, dayErr := parsePositiveInt(dayRaw)
+		if dayErr != nil {
+			colIssues = append(colIssues, validationIssue{
+				Field:   headerDay,
+				Message: fmt.Sprintf("col=%s: %s", colName, dayErr.Error()),
+			})
+		}
+		mult, multErr := parseMultiplication(multRaw)
+		if multErr != nil {
+			colIssues = append(colIssues, validationIssue{
+				Field:   headerMultiplier,
+				Message: fmt.Sprintf("col=%s: %s", colName, multErr.Error()),
+			})
+		}
+		if day > 0 {
+			if prevCol, exists := seenDays[day]; exists {
+				colIssues = append(colIssues, validationIssue{
+					Field:   headerDay,
+					Message: fmt.Sprintf("col=%s: duplicate day %d (already in col %s)", colName, day, prevCol),
+				})
+			} else {
+				seenDays[day] = colName
+			}
+		}
+		if len(colIssues) > 0 {
+			issues = append(issues, colIssues...)
+			continue
+		}
+		rows = append(rows, curveRow{Day: day, Mult: mult, ColRef: colName})
+	}
+
+	if len(rows) == 0 && len(issues) == 0 {
+		issues = append(issues, validationIssue{Field: "data", Message: "tidak ada kolom data setelah kolom A (label)"})
+	}
+
+	sort.Slice(rows, func(i, j int) bool { return rows[i].Day < rows[j].Day })
+	return sheetName, rows, issues, nil
+}
+
+func resolveSheetName(workbook *excelize.File, requestedSheet string) (string, error) {
+	sheets := workbook.GetSheetList()
+	if len(sheets) == 0 {
+		return "", fmt.Errorf("workbook has no sheets")
+	}
+	if strings.TrimSpace(requestedSheet) == "" {
+		return sheets[0], nil
+	}
+	for _, sheet := range sheets {
+		if strings.EqualFold(strings.TrimSpace(sheet), strings.TrimSpace(requestedSheet)) {
+			return sheet, nil
+		}
+	}
+	return "", fmt.Errorf("sheet %q not found", requestedSheet)
+}
+
+func parsePositiveInt(raw string) (int, error) {
+	if raw == "" {
+		return 0, fmt.Errorf("is required")
+	}
+	value, err := strconv.Atoi(raw)
+	if err != nil {
+		floatValue, floatErr := strconv.ParseFloat(raw, 64)
+		if floatErr != nil || floatValue != float64(int(floatValue)) {
+			return 0, fmt.Errorf("must be a positive integer")
+		}
+		value = int(floatValue)
+	}
+	if value < 1 {
+		return 0, fmt.Errorf("must be greater than or equal to 1")
+	}
+	return value, nil
+}
+
+func parseMultiplication(raw string) (float64, error) {
+	if raw == "" {
+		return 0, fmt.Errorf("is required")
+	}
+	value, err := strconv.ParseFloat(raw, 64)
+	if err != nil {
+		return 0, fmt.Errorf("must be numeric")
+	}
+	if value < 0 || value > 1 {
+		return 0, fmt.Errorf("must be between 0 and 1 (inclusive)")
+	}
+	return value, nil
+}
+
+
+// --- SQL generation ----------------------------------------------------------
+
+// buildUpSQL generates INSERT blocks for each houseType in houseTypes.
+// If flocks span multiple house_types, one INSERT block is generated per type,
+// all sharing the same project_flock_ids array.
+func buildUpSQL(opts options, houseTypes []string, curve []curveRow, flockIDs []uint) string {
+	var b strings.Builder
+
+	fmt.Fprintf(&b, "-- Kurva depresiasi khusus flock %s (house_types=%s, effective_date=%s).\n",
+		formatFlockIDs(flockIDs), strings.Join(houseTypes, ","), opts.EffectiveDate)
+	b.WriteString("-- Override hanya multiplication_percentage; house_type & standard_week diwarisi dari baris global.\n")
+	b.WriteString("-- depreciation_percent diturunkan = (1 - multiplication_percentage) * 100.\n")
+	b.WriteString("-- Lookup engine: ? = ANY(project_flock_ids) — satu baris dipakai semua flock.\n\n")
+
+	valTuples := formatValuesTuples(curve)
+	arrayLit := formatArrayLiteral(flockIDs)
+
+	for _, houseType := range houseTypes {
+		fmt.Fprintf(&b, "-- house_type: %s\n", houseType)
+		b.WriteString("INSERT INTO house_depreciation_standards\n")
+		b.WriteString("    (project_flock_ids, house_type, day, effective_date,\n")
+		b.WriteString("     multiplication_percentage, depreciation_percent, standard_week, name)\n")
+		b.WriteString("SELECT\n")
+		fmt.Fprintf(&b, "    %s, g.house_type, g.day, DATE '%s',\n", arrayLit, opts.EffectiveDate)
+		b.WriteString("    v.mult, (1 - v.mult) * 100, g.standard_week,\n")
+		fmt.Fprintf(&b, "    'Custom flocks %s (eff %s)'\n", formatFlockIDs(flockIDs), opts.EffectiveDate)
+		b.WriteString("FROM (VALUES\n")
+		b.WriteString(valTuples)
+		b.WriteString("\n) AS v(day, mult)\n")
+		b.WriteString("JOIN LATERAL (\n")
+		b.WriteString("    SELECT DISTINCT ON (day) house_type, day, standard_week\n")
+		b.WriteString("    FROM house_depreciation_standards\n")
+		b.WriteString("    WHERE project_flock_ids IS NULL\n")
+		fmt.Fprintf(&b, "      AND house_type = '%s'::house_type_enum\n", houseType)
+		b.WriteString("      AND day = v.day\n")
+		b.WriteString("    ORDER BY day, effective_date DESC NULLS LAST\n")
+		b.WriteString(") g ON TRUE;\n\n")
+	}
+
+	b.WriteString("-- Recompute snapshot depresiasi untuk semua flock yang dipetakan.\n")
+	fmt.Fprintf(&b, "DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (%s);\n", inClause(flockIDs))
+	return b.String()
+}
+
+func buildDownSQL(opts options, flockIDs []uint) string {
+	var b strings.Builder
+	b.WriteString("-- Hapus baris kurva custom dari house_depreciation_standards.\n")
+	b.WriteString("-- Exact match pada array (IDs di-sort, sama persis dengan yang di-insert).\n")
+	fmt.Fprintf(&b, "DELETE FROM house_depreciation_standards\nWHERE project_flock_ids = %s\n  AND effective_date = DATE '%s';\n\n",
+		formatArrayLiteral(flockIDs), opts.EffectiveDate)
+	b.WriteString("-- Recompute snapshot depresiasi.\n")
+	fmt.Fprintf(&b, "DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (%s);\n", inClause(flockIDs))
+	return b.String()
+}
+
+// formatArrayLiteral renders []uint{52,53,54} as ARRAY[52,53,54]::bigint[].
+func formatArrayLiteral(ids []uint) string {
+	parts := make([]string, len(ids))
+	for i, id := range ids {
+		parts[i] = strconv.FormatUint(uint64(id), 10)
+	}
+	return fmt.Sprintf("ARRAY[%s]::bigint[]", strings.Join(parts, ","))
+}
+
+// formatValuesTuples renders (day, mult) tuples 5 per line.
+// The first multiplier is cast ::numeric so PostgreSQL infers the column type correctly.
+func formatValuesTuples(curve []curveRow) string {
+	tuples := make([]string, len(curve))
+	for i, row := range curve {
+		mult := formatFloat(row.Mult)
+		if i == 0 {
+			mult += "::numeric"
+		}
+		tuples[i] = fmt.Sprintf("(%d, %s)", row.Day, mult)
+	}
+
+	var b strings.Builder
+	const perLine = 5
+	for i := 0; i < len(tuples); i += perLine {
+		end := i + perLine
+		if end > len(tuples) {
+			end = len(tuples)
+		}
+		b.WriteString("    ")
+		b.WriteString(strings.Join(tuples[i:end], ", "))
+		if end < len(tuples) {
+			b.WriteString(",\n")
+		}
+	}
+	return b.String()
+}
+
+// inClause formats []uint{52,53,54} as "52, 53, 54" for SQL IN (...).
+func inClause(ids []uint) string {
+	parts := make([]string, len(ids))
+	for i, id := range ids {
+		parts[i] = strconv.FormatUint(uint64(id), 10)
+	}
+	return strings.Join(parts, ", ")
+}
+
+func formatFloat(value float64) string {
+	return strconv.FormatFloat(value, 'g', -1, 64)
+}
+
+// --- DB helpers --------------------------------------------------------------
+
+func assertActiveLayingFlock(ctx context.Context, db *gorm.DB, projectFlockID uint) error {
+	var count int64
+	err := db.WithContext(ctx).
+		Table("project_flocks").
+		Where("id = ?", projectFlockID).
+		Where("deleted_at IS NULL").
+		Where("category = ?", string(utils.ProjectFlockCategoryLaying)).
+		Count(&count).Error
+	if err != nil {
+		return err
+	}
+	if count == 0 {
+		return fmt.Errorf("project_flock_id %d must reference an active LAYING project_flock", projectFlockID)
+	}
+	return nil
+}
+
+// resolveHouseTypesForFlocks mengembalikan SEMUA distinct house_type dari kandang
+// semua flock yang diberikan. Kalau -house-type di-pass → hanya type itu.
+// Tidak error kalau multiple (generate INSERT block per type secara otomatis).
+func resolveHouseTypesForFlocks(ctx context.Context, db *gorm.DB, flockIDs []uint, override string) ([]string, error) {
+	if strings.TrimSpace(override) != "" {
+		ht, err := normalizeHouseType(override)
+		if err != nil {
+			return nil, err
+		}
+		return []string{ht}, nil
+	}
+
+	houseTypes := make([]string, 0)
+	err := db.WithContext(ctx).Raw(`
+		SELECT DISTINCT k.house_type::text AS house_type
+		FROM project_flock_kandangs pfk
+		JOIN kandangs k ON k.id = pfk.kandang_id
+		WHERE pfk.project_flock_id IN ? AND k.house_type IS NOT NULL
+		ORDER BY house_type
+	`, flockIDs).Scan(&houseTypes).Error
+	if err != nil {
+		return nil, err
+	}
+
+	if len(houseTypes) == 0 {
+		return nil, fmt.Errorf("no kandang house_type found for any of the specified flocks; pass -house-type explicitly")
+	}
+
+	// Bisa 1 atau lebih — generate INSERT block per type.
+	return houseTypes, nil
+}
+
+func normalizeHouseType(raw string) (string, error) {
+	normalized := strings.ToLower(strings.TrimSpace(raw))
+	switch normalized {
+	case "open_house", "close_house":
+		return normalized, nil
+	default:
+		return "", fmt.Errorf("house_type %q must be open_house or close_house", raw)
+	}
+}
+
+
+// --- misc helpers ------------------------------------------------------------
+
+func dayRange(curve []curveRow) (int, int) {
+	minDay, maxDay := curve[0].Day, curve[0].Day
+	for _, row := range curve {
+		if row.Day < minDay {
+			minDay = row.Day
+		}
+		if row.Day > maxDay {
+			maxDay = row.Day
+		}
+	}
+	return minDay, maxDay
+}
+
+func sortValidationIssues(issues []validationIssue) {
+	sort.Slice(issues, func(i, j int) bool {
+		if issues[i].Row == issues[j].Row {
+			if issues[i].Field == issues[j].Field {
+				return issues[i].Message < issues[j].Message
+			}
+			return issues[i].Field < issues[j].Field
+		}
+		return issues[i].Row < issues[j].Row
+	})
+}
+
+func isRowEmpty(row []string) bool {
+	for _, cell := range row {
+		if strings.TrimSpace(cell) != "" {
+			return false
+		}
+	}
+	return true
+}
+
+func normalizeHeader(raw string) string {
+	return strings.ToLower(strings.TrimSpace(raw))
+}
+
+func cellValue(row []string, index int) string {
+	if index < 0 || index >= len(row) {
+		return ""
+	}
+	return row[index]
+}
+
+func modeLabel(apply bool) string {
+	if apply {
+		return "APPLY"
+	}
+	return "DRY-RUN"
+}

cmd/seed-house-depreciation-standards/main_test.go

@@ -0,0 +1,373 @@
+package main
+
+import (
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xuri/excelize/v2"
+)
+
+// --- helper: build horizontal-format temp xlsx --------------------------------
+
+// makeHorizXlsx creates a temp .xlsx with two horizontal rows:
+//
+//	Row 1:  "day"                     | dayValues...
+//	Row 2:  "multiplication_percentage" | multValues...
+func makeHorizXlsx(t *testing.T, dayValues, multValues []any) string {
+	t.Helper()
+	f := excelize.NewFile()
+	defer f.Close()
+
+	f.SetCellValue("Sheet1", "A1", "day")
+	f.SetCellValue("Sheet1", "A2", "multiplication_percentage")
+
+	for i, v := range dayValues {
+		colName, _ := excelize.ColumnNumberToName(i + 2)
+		switch val := v.(type) {
+		case int:
+			f.SetCellInt("Sheet1", colName+"1", val)
+		case string:
+			f.SetCellValue("Sheet1", colName+"1", val)
+		}
+	}
+	for i, v := range multValues {
+		colName, _ := excelize.ColumnNumberToName(i + 2)
+		switch val := v.(type) {
+		case float64:
+			f.SetCellFloat("Sheet1", colName+"2", val, 15, 64)
+		case string:
+			f.SetCellValue("Sheet1", colName+"2", val)
+		}
+	}
+
+	tmp, err := os.CreateTemp("", "test_curve_*.xlsx")
+	if err != nil {
+		t.Fatalf("CreateTemp: %v", err)
+	}
+	tmp.Close()
+	t.Cleanup(func() { os.Remove(tmp.Name()) })
+	if err := f.SaveAs(tmp.Name()); err != nil {
+		t.Fatalf("SaveAs: %v", err)
+	}
+	return tmp.Name()
+}
+
+// --- parseCurveFile tests -----------------------------------------------------
+
+func TestParseCurveFile_HappyPath(t *testing.T) {
+	path := makeHorizXlsx(t,
+		[]any{1, 2, 3},
+		[]any{0.997742664, 0.997737557, 0.997732426},
+	)
+	sheetName, rows, issues, err := parseCurveFile(path, "")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(issues) != 0 {
+		t.Fatalf("unexpected issues: %v", issues)
+	}
+	if sheetName != "Sheet1" {
+		t.Fatalf("wrong sheet: %s", sheetName)
+	}
+	if len(rows) != 3 {
+		t.Fatalf("want 3 rows, got %d", len(rows))
+	}
+	if rows[0].Day != 1 || rows[1].Day != 2 || rows[2].Day != 3 {
+		t.Fatalf("wrong days: %v", rows)
+	}
+	if rows[0].ColRef != "B" {
+		t.Fatalf("wrong ColRef for day 1: %s", rows[0].ColRef)
+	}
+}
+
+func TestParseCurveFile_RowOrderFlexible(t *testing.T) {
+	f := excelize.NewFile()
+	defer f.Close()
+	f.SetCellValue("Sheet1", "A1", "multiplication_percentage")
+	f.SetCellFloat("Sheet1", "B1", 0.997, 15, 64)
+	f.SetCellValue("Sheet1", "A2", "day")
+	f.SetCellInt("Sheet1", "B2", 5)
+
+	tmp, _ := os.CreateTemp("", "*.xlsx")
+	tmp.Close()
+	t.Cleanup(func() { os.Remove(tmp.Name()) })
+	f.SaveAs(tmp.Name())
+
+	_, rows, issues, err := parseCurveFile(tmp.Name(), "")
+	if err != nil || len(issues) != 0 {
+		t.Fatalf("err=%v issues=%v", err, issues)
+	}
+	if len(rows) != 1 || rows[0].Day != 5 {
+		t.Fatalf("unexpected rows: %v", rows)
+	}
+}
+
+func TestParseCurveFile_MissingDayRow(t *testing.T) {
+	f := excelize.NewFile()
+	defer f.Close()
+	f.SetCellValue("Sheet1", "A1", "multiplication_percentage")
+	f.SetCellFloat("Sheet1", "B1", 0.997, 15, 64)
+
+	tmp, _ := os.CreateTemp("", "*.xlsx")
+	tmp.Close()
+	t.Cleanup(func() { os.Remove(tmp.Name()) })
+	f.SaveAs(tmp.Name())
+
+	_, _, issues, err := parseCurveFile(tmp.Name(), "")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(issues) != 1 || issues[0].Field != headerDay {
+		t.Fatalf("expected missing-day-row issue, got %v", issues)
+	}
+}
+
+func TestParseCurveFile_DuplicateDay(t *testing.T) {
+	path := makeHorizXlsx(t,
+		[]any{1, 2, 1},
+		[]any{0.99, 0.98, 0.97},
+	)
+	_, _, issues, err := parseCurveFile(path, "")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(issues) != 1 {
+		t.Fatalf("expected 1 duplicate-day issue, got %v", issues)
+	}
+	if !strings.Contains(issues[0].Message, "duplicate day 1") {
+		t.Fatalf("wrong issue message: %s", issues[0].Message)
+	}
+	if !strings.Contains(issues[0].Message, "col=D") {
+		t.Fatalf("issue should mention col=D: %s", issues[0].Message)
+	}
+}
+
+func TestParseCurveFile_InvalidMultiplication(t *testing.T) {
+	path := makeHorizXlsx(t,
+		[]any{1, 2},
+		[]any{"bad", 1.5},
+	)
+	_, _, issues, err := parseCurveFile(path, "")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(issues) != 2 {
+		t.Fatalf("expected 2 issues, got %v", issues)
+	}
+}
+
+func TestParseCurveFile_SkipsEmptyColumns(t *testing.T) {
+	f := excelize.NewFile()
+	defer f.Close()
+	f.SetCellValue("Sheet1", "A1", "day")
+	f.SetCellInt("Sheet1", "B1", 1)
+	f.SetCellInt("Sheet1", "D1", 3)
+	f.SetCellValue("Sheet1", "A2", "multiplication_percentage")
+	f.SetCellFloat("Sheet1", "B2", 0.997, 15, 64)
+	f.SetCellFloat("Sheet1", "D2", 0.995, 15, 64)
+
+	tmp, _ := os.CreateTemp("", "*.xlsx")
+	tmp.Close()
+	t.Cleanup(func() { os.Remove(tmp.Name()) })
+	f.SaveAs(tmp.Name())
+
+	_, rows, issues, err := parseCurveFile(tmp.Name(), "")
+	if err != nil || len(issues) != 0 {
+		t.Fatalf("err=%v issues=%v", err, issues)
+	}
+	if len(rows) != 2 {
+		t.Fatalf("want 2 rows (col C skipped), got %d: %v", len(rows), rows)
+	}
+}
+
+// --- pure-function tests ------------------------------------------------------
+
+func TestParseFlockIDs(t *testing.T) {
+	t.Run("single", func(t *testing.T) {
+		ids, err := parseFlockIDs("52")
+		if err != nil || len(ids) != 1 || ids[0] != 52 {
+			t.Fatalf("got ids=%v err=%v", ids, err)
+		}
+	})
+	t.Run("multiple_sorted", func(t *testing.T) {
+		ids, err := parseFlockIDs("54,52,53")
+		if err != nil || len(ids) != 3 {
+			t.Fatalf("got ids=%v err=%v", ids, err)
+		}
+		// should be sorted
+		if ids[0] != 52 || ids[1] != 53 || ids[2] != 54 {
+			t.Fatalf("expected sorted [52,53,54], got %v", ids)
+		}
+	})
+	t.Run("duplicate", func(t *testing.T) {
+		if _, err := parseFlockIDs("52,52"); err == nil {
+			t.Fatal("expected error for duplicate")
+		}
+	})
+	t.Run("zero", func(t *testing.T) {
+		if _, err := parseFlockIDs("0"); err == nil {
+			t.Fatal("expected error for zero")
+		}
+	})
+	t.Run("empty", func(t *testing.T) {
+		if _, err := parseFlockIDs(""); err == nil {
+			t.Fatal("expected error for empty")
+		}
+	})
+}
+
+func TestFormatArrayLiteral(t *testing.T) {
+	got := formatArrayLiteral([]uint{52, 53, 54})
+	want := "ARRAY[52,53,54]::bigint[]"
+	if got != want {
+		t.Fatalf("want %q, got %q", want, got)
+	}
+}
+
+func TestFormatFlockIDsForFilename(t *testing.T) {
+	if got := formatFlockIDsForFilename([]uint{52, 53, 54}); got != "52_53_54" {
+		t.Fatalf("got %s", got)
+	}
+	// More than 4 IDs → truncate
+	many := []uint{1, 2, 3, 4, 5}
+	got := formatFlockIDsForFilename(many)
+	if !strings.Contains(got, "1_2_3_4") || !strings.Contains(got, "1_more") {
+		t.Fatalf("unexpected: %s", got)
+	}
+}
+
+func TestParsePositiveInt(t *testing.T) {
+	cases := map[string]bool{
+		"1": true, "532": true, "12.0": true,
+		"0": false, "-3": false, "1.5": false, "": false, "x": false,
+	}
+	for raw, ok := range cases {
+		_, err := parsePositiveInt(raw)
+		if ok && err != nil {
+			t.Errorf("%q: unexpected error %v", raw, err)
+		}
+		if !ok && err == nil {
+			t.Errorf("%q: expected error", raw)
+		}
+	}
+}
+
+func TestParseMultiplication(t *testing.T) {
+	cases := map[string]bool{
+		"0.997742664": true, "1": true, "9.11e-12": true, "0": true,
+		"-0.1": false, "1.0001": false, "": false, "abc": false,
+	}
+	for raw, ok := range cases {
+		_, err := parseMultiplication(raw)
+		if ok && err != nil {
+			t.Errorf("%q: unexpected error %v", raw, err)
+		}
+		if !ok && err == nil {
+			t.Errorf("%q: expected error", raw)
+		}
+	}
+}
+
+
+func TestFormatValuesTuplesFirstNumericCast(t *testing.T) {
+	out := formatValuesTuples([]curveRow{
+		{Day: 1, Mult: 0.997742664},
+		{Day: 2, Mult: 1},
+	})
+	if !strings.Contains(out, "(1, 0.997742664::numeric)") {
+		t.Fatalf("first tuple must cast ::numeric: %s", out)
+	}
+	if strings.Contains(out, "(2, 1::numeric)") {
+		t.Fatalf("only the first tuple should be cast: %s", out)
+	}
+}
+
+func TestBuildUpSQL_SingleHouseType(t *testing.T) {
+	opts := options{EffectiveDate: "2026-05-31"}
+	curve := []curveRow{{Day: 1, Mult: 0.997742664}, {Day: 2, Mult: 0.5}}
+	flockIDs := []uint{52, 53}
+	sql := buildUpSQL(opts, []string{"close_house"}, curve, flockIDs)
+
+	mustContain(t, sql, "INSERT INTO house_depreciation_standards")
+	mustContain(t, sql, "project_flock_ids")
+	mustContain(t, sql, "ARRAY[52,53]::bigint[]")
+	mustContain(t, sql, "DATE '2026-05-31'")
+	mustContain(t, sql, "v.mult, (1 - v.mult) * 100, g.standard_week")
+	mustContain(t, sql, "project_flock_ids IS NULL")
+	mustContain(t, sql, "house_type = 'close_house'::house_type_enum")
+	mustContain(t, sql, "(1, 0.997742664::numeric)")
+	mustContain(t, sql, "JOIN LATERAL")
+	mustContain(t, sql, "DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (52, 53)")
+}
+
+func TestBuildUpSQL_MultipleHouseTypes(t *testing.T) {
+	opts := options{EffectiveDate: "2026-05-31"}
+	curve := []curveRow{{Day: 1, Mult: 0.5}}
+	flockIDs := []uint{52, 53}
+	sql := buildUpSQL(opts, []string{"close_house", "open_house"}, curve, flockIDs)
+
+	// Both house_types get their own INSERT block
+	mustContain(t, sql, "house_type = 'close_house'::house_type_enum")
+	mustContain(t, sql, "house_type = 'open_house'::house_type_enum")
+	// VALUES tuple appears only once (reused by both blocks)
+	mustContain(t, sql, "(1, 0.5::numeric)")
+	// Snapshot invalidation appears once at the end
+	mustContain(t, sql, "DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (52, 53)")
+}
+
+func TestBuildDownSQL(t *testing.T) {
+	opts := options{EffectiveDate: "2026-05-31"}
+	flockIDs := []uint{52, 53}
+	sql := buildDownSQL(opts, flockIDs)
+
+	// Delete by exact array match
+	mustContain(t, sql, "DELETE FROM house_depreciation_standards")
+	mustContain(t, sql, "project_flock_ids = ARRAY[52,53]::bigint[]")
+	mustContain(t, sql, "effective_date = DATE '2026-05-31'")
+	mustContain(t, sql, "DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (52, 53)")
+}
+
+func TestResolveEffectiveDate(t *testing.T) {
+	loc := time.UTC
+	if _, err := resolveEffectiveDate("2026-05-31", loc); err != nil {
+		t.Fatalf("valid date errored: %v", err)
+	}
+	if _, err := resolveEffectiveDate("31-05-2026", loc); err == nil {
+		t.Fatalf("expected error for wrong format")
+	}
+	got, err := resolveEffectiveDate("", loc)
+	if err != nil {
+		t.Fatalf("default date errored: %v", err)
+	}
+	if got.Hour() != 0 || got.Minute() != 0 {
+		t.Fatalf("default date should be midnight, got %v", got)
+	}
+}
+
+func TestNormalizeHouseType(t *testing.T) {
+	for _, ok := range []string{"open_house", "CLOSE_HOUSE", " close_house "} {
+		if _, err := normalizeHouseType(ok); err != nil {
+			t.Errorf("%q should be valid: %v", ok, err)
+		}
+	}
+	if _, err := normalizeHouseType("barn"); err == nil {
+		t.Errorf("barn should be invalid")
+	}
+}
+
+func TestInClause(t *testing.T) {
+	if got := inClause([]uint{52, 53, 54}); got != "52, 53, 54" {
+		t.Fatalf("wrong inClause: %s", got)
+	}
+}
+
+// --- helpers ------------------------------------------------------------------
+
+func mustContain(t *testing.T, haystack, needle string) {
+	t.Helper()
+	if !strings.Contains(haystack, needle) {
+		t.Fatalf("expected to find %q in:\n%s", needle, haystack)
+	}
+}

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

@@ -112,7 +112,7 @@ type HppV2CostRepository interface {
 	GetFarmDepreciationSnapshotByProjectFlockIDAndPeriod(ctx context.Context, projectFlockID uint, periodDate time.Time) (*HppV2FarmDepreciationSnapshotRow, error)
 	GetEarliestChickInDateByProjectFlockID(ctx context.Context, projectFlockID uint) (*time.Time, error)
 	GetChickinPopulationByPFKForFarm(ctx context.Context, projectFlockID uint) (map[uint]float64, error)
-	GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, map[string]*time.Time, error)
+	GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int, projectFlockID uint) (map[string]map[int]float64, map[string]*time.Time, error)
 	ListUsageCostRowsByProductFlags(ctx context.Context, projectFlockKandangIDs []uint, flagNames []string, date *time.Time) ([]HppV2UsageCostRow, error)
 	ListAdjustmentCostRowsByProductFlags(ctx context.Context, projectFlockKandangIDs []uint, flagNames []string, date *time.Time) ([]HppV2AdjustmentCostRow, error)
 	ListExpenseRealizationRowsByProjectFlockKandangIDs(ctx context.Context, projectFlockKandangIDs []uint, date *time.Time, ekspedisi bool) ([]HppV2ExpenseCostRow, error)
@@ -466,6 +466,7 @@ func (r *HppV2RepositoryImpl) GetMultiplicationPercentages(
 	ctx context.Context,
 	houseTypes []string,
 	maxDay int,
+	projectFlockID uint,
 ) (map[string]map[int]float64, map[string]*time.Time, error) {
 	result := make(map[string]map[int]float64)
 	effectiveDates := make(map[string]*time.Time)
@@ -486,8 +487,9 @@ func (r *HppV2RepositoryImpl) GetMultiplicationPercentages(
 			house_type::text AS house_type, day, multiplication_percentage, effective_date
 		FROM house_depreciation_standards
 		WHERE house_type::text IN ? AND day <= ?
-		ORDER BY house_type, day, effective_date DESC NULLS LAST
+			AND (project_flock_ids IS NULL OR ? = ANY(project_flock_ids))
-	`, houseTypes, maxDay).Scan(&rows).Error
+		ORDER BY house_type, day, (project_flock_ids IS NOT NULL) DESC, effective_date DESC NULLS LAST
+	`, houseTypes, maxDay, projectFlockID).Scan(&rows).Error
 	if err != nil {
 		return nil, nil, err
 	}

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

@@ -1390,7 +1390,7 @@ func (s *hppV2Service) buildNormalTransferDepreciationPart(
 	}
 
 	houseType := NormalizeDepreciationHouseType(contextRow.HouseType)
-	multiplicationByHouseType, effectiveDates, err := s.hppRepo.GetMultiplicationPercentages(context.Background(), []string{houseType}, scheduleDay)
+	multiplicationByHouseType, effectiveDates, err := s.hppRepo.GetMultiplicationPercentages(context.Background(), []string{houseType}, scheduleDay, contextRow.ProjectFlockID)
 	if err != nil {
 		return nil, err
 	}
@@ -1487,19 +1487,24 @@ func (s *hppV2Service) buildManualCutoverDepreciationPart(
 		return nil, nil
 	}
 
-	reportScheduleDay := DepreciationScheduleDay(*originDate, periodDate, contextRow.HouseType)
+	// Hitung schedule day relatif terhadap cutover_date, bukan dari chick_in_date.
-	if reportScheduleDay <= 0 {
+	// Ini menangani kasus cut-over flock yang belum 175 hari pada period date,
-		return nil, nil
+	// karena bisnis sudah menetapkan cutover_date sebagai awal depresiasi.
-	}
+	// Rumus setara secara matematis dengan DepreciationScheduleDay ketika flock >= 175 hari.
-
 	cutoverScheduleDay := DepreciationScheduleDay(*originDate, manualInput.CutoverDate, contextRow.HouseType)
 	startDay := 1
 	if cutoverScheduleDay > 0 {
 		startDay = cutoverScheduleDay
 	}
 
+	daysSinceCutover := int(dateOnly(periodDate).Sub(dateOnly(manualInput.CutoverDate)).Hours() / 24)
+	reportScheduleDay := startDay + daysSinceCutover
+	if reportScheduleDay <= 0 {
+		return nil, nil
+	}
+
 	houseType := NormalizeDepreciationHouseType(contextRow.HouseType)
-	multiplicationByHouseType, effectiveDates, err := s.hppRepo.GetMultiplicationPercentages(context.Background(), []string{houseType}, reportScheduleDay)
+	multiplicationByHouseType, effectiveDates, err := s.hppRepo.GetMultiplicationPercentages(context.Background(), []string{houseType}, reportScheduleDay, contextRow.ProjectFlockID)
 	if err != nil {
 		return nil, err
 	}

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

@@ -103,7 +103,7 @@ func (s *hppV2RepoStub) GetDepreciationPercents(_ context.Context, houseTypes []
 
 // GetMultiplicationPercentages — alias yang sama dengan GetDepreciationPercents untuk match
 // interface HppV2CostRepository (interface dipakai method name baru ini).
-func (s *hppV2RepoStub) GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, map[string]*time.Time, error) {
+func (s *hppV2RepoStub) GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int, _ uint) (map[string]map[int]float64, map[string]*time.Time, error) {
 	vals, err := s.GetDepreciationPercents(ctx, houseTypes, maxDay)
 	return vals, make(map[string]*time.Time), err
 }

internal/database/migrations/20260604041616_add_project_flock_id_to_house_depreciation_standards.down.sql

@@ -0,0 +1,16 @@
+-- Rollback: hapus kolom project_flock_ids dan semua index terkait,
+-- kembalikan unique constraint lama (house_type, day, effective_date).
+
+DROP INDEX IF EXISTS idx_hds_global_unique;
+DROP INDEX IF EXISTS idx_hds_custom_unique;
+DROP INDEX IF EXISTS idx_hds_project_flock_ids;
+
+-- Safety net: hapus baris custom yang mungkin tersisa sebelum drop kolom.
+DELETE FROM house_depreciation_standards WHERE project_flock_ids IS NOT NULL;
+
+ALTER TABLE house_depreciation_standards DROP COLUMN project_flock_ids;
+
+-- Kembalikan unique constraint lama.
+ALTER TABLE house_depreciation_standards
+    ADD CONSTRAINT house_depreciation_standards_house_type_day_eff_unique
+    UNIQUE (house_type, day, effective_date);

internal/database/migrations/20260604041616_add_project_flock_id_to_house_depreciation_standards.up.sql

@@ -0,0 +1,31 @@
+-- Tambah kolom project_flock_ids BIGINT[] ke house_depreciation_standards.
+-- Baris dengan project_flock_ids NOT NULL = kurva khusus untuk flock-flock tersebut.
+-- Baris dengan project_flock_ids NULL = kurva global default (fallback semua flock).
+--
+-- BIGINT[] memungkinkan 1 baris dipakai oleh N flock tanpa duplikasi:
+--   project_flock_ids = ARRAY[52, 53, 54]  →  baris ini berlaku untuk ketiga flock.
+-- Lookup engine: WHERE project_flock_ids IS NULL OR ? = ANY(project_flock_ids)
+
+-- 1. Hapus unique constraint lama (house_type, day, effective_date).
+--    Digantikan oleh dua partial unique indexes di bawah.
+ALTER TABLE house_depreciation_standards
+    DROP CONSTRAINT house_depreciation_standards_house_type_day_eff_unique;
+
+-- 2. Tambah kolom baru.
+ALTER TABLE house_depreciation_standards
+    ADD COLUMN project_flock_ids BIGINT[] NULL;
+
+-- 3. GIN index untuk efficient ? = ANY(project_flock_ids) lookup.
+CREATE INDEX idx_hds_project_flock_ids
+    ON house_depreciation_standards USING GIN (project_flock_ids);
+
+-- 4. Partial unique: satu baris global per (house_type, day, effective_date).
+CREATE UNIQUE INDEX idx_hds_global_unique
+    ON house_depreciation_standards (house_type, day, effective_date)
+    WHERE project_flock_ids IS NULL;
+
+-- 5. Partial unique: satu baris custom per (house_type, day, effective_date).
+--    Kalau butuh 2 kurva berbeda untuk hari+tanggal yang sama, pakai effective_date berbeda.
+CREATE UNIQUE INDEX idx_hds_custom_unique
+    ON house_depreciation_standards (house_type, day, effective_date)
+    WHERE project_flock_ids IS NOT NULL;

internal/database/migrations/20260604041658_update_farm_depreciation_manual_inputs.down.sql

@@ -0,0 +1,14 @@
+-- Reverse UPSERT: hapus baris PFK 47 & 48 yang kemungkinan baru diinsert oleh up migration ini.
+-- Jika sebelumnya sudah ada (ON CONFLICT DO UPDATE), baris ini akan terhapus —
+-- restore manual dari backup jika diperlukan.
+DELETE FROM farm_depreciation_manual_inputs
+WHERE project_flock_id IN (47, 48);
+
+-- UPDATE rows untuk PFK 4–27 tidak bisa di-reverse secara presisi:
+-- nilai total_cost sebelum migration ini tidak tersimpan di migration history
+-- (data awal di-load via cmd/import-farm-depreciation-manual-inputs dari Excel).
+-- PFK 10 dan 11 tidak berubah (nilai sama dengan state dari migration 20260529144559).
+-- Jika perlu rollback penuh: restore dari database backup atau re-import Excel lama.
+
+-- Recompute snapshots setelah rollback
+TRUNCATE TABLE farm_depreciation_snapshots;

internal/database/migrations/20260604041658_update_farm_depreciation_manual_inputs.up.sql

@@ -0,0 +1,105 @@
+
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost   = 1900157533.55,
+    cutover_date = DATE '2026-02-28',
+    updated_at   = NOW()
+WHERE project_flock_id = 10;
+
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost   = 146658321.066,
+    cutover_date = DATE '2026-02-28',
+    updated_at   = NOW()
+WHERE project_flock_id = 13;
+
+
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost   = 51824694.138,
+    cutover_date = DATE '2026-02-28',
+    updated_at   = NOW()
+WHERE project_flock_id = 17;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost   = 15491774.796,
+    cutover_date = DATE '2026-02-28',
+    updated_at   = NOW()
+WHERE project_flock_id = 8;
+
+
+
+
+-- Cutover 2026-02-28 (lanjutan)
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 575074391.36, cutover_date = DATE '2026-02-28', updated_at = NOW()
+WHERE project_flock_id = 4;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 578360642.51, cutover_date = DATE '2026-02-28', updated_at = NOW()
+WHERE project_flock_id = 5;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 880983605.92, cutover_date = DATE '2026-02-28', updated_at = NOW()
+WHERE project_flock_id = 6;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 391669576.153, cutover_date = DATE '2026-02-28', updated_at = NOW()
+WHERE project_flock_id = 9;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 2521797832.14, cutover_date = DATE '2026-02-28', updated_at = NOW()
+WHERE project_flock_id = 11;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 139227054.164, cutover_date = DATE '2026-02-28', updated_at = NOW()
+WHERE project_flock_id = 12;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 380083106.836, cutover_date = DATE '2026-02-28', updated_at = NOW()
+WHERE project_flock_id = 14;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 705136853.847, cutover_date = DATE '2026-02-28', updated_at = NOW()
+WHERE project_flock_id = 15;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 209816474.000, cutover_date = DATE '2026-02-28', updated_at = NOW()
+WHERE project_flock_id = 18;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 557606867.000, cutover_date = DATE '2026-02-28', updated_at = NOW()
+WHERE project_flock_id = 19;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 239330456.11, cutover_date = DATE '2026-02-28', updated_at = NOW()
+WHERE project_flock_id = 20;
+
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 4724203916.72, cutover_date = DATE '2026-02-28', updated_at = NOW()
+WHERE project_flock_id = 26;
+
+-- Cutover 2026-05-15
+UPDATE farm_depreciation_manual_inputs
+SET total_cost = 5449963647.43, cutover_date = DATE '2026-05-15', updated_at = NOW()
+WHERE project_flock_id = 27;
+
+-- Cutover 2026-06-08 (upsert — row mungkin belum ada)
+INSERT INTO farm_depreciation_manual_inputs (project_flock_id, total_cost, cutover_date, created_at, updated_at)
+VALUES (47, 5395429899.42, DATE '2026-06-08', NOW(), NOW())
+ON CONFLICT (project_flock_id) DO UPDATE
+    SET total_cost   = EXCLUDED.total_cost,
+        cutover_date = EXCLUDED.cutover_date,
+        updated_at   = NOW();
+
+-- Cutover 2026-06-16 (upsert — row mungkin belum ada)
+INSERT INTO farm_depreciation_manual_inputs (project_flock_id, total_cost, cutover_date, created_at, updated_at)
+VALUES (48, 5514616442.08, DATE '2026-06-16', NOW(), NOW())
+ON CONFLICT (project_flock_id) DO UPDATE
+    SET total_cost   = EXCLUDED.total_cost,
+        cutover_date = EXCLUDED.cutover_date,
+        updated_at   = NOW();
+
+-- Pengaman: pastikan snapshot di-recompute dengan total_cost baru
+-- saat user request /api/reports/expense/depreciation
+TRUNCATE TABLE farm_depreciation_snapshots;

internal/database/migrations/20260604041743_fix_hds_custom_unique_per_flock.down.sql

@@ -0,0 +1,8 @@
+DROP INDEX IF EXISTS idx_hds_custom_unique;
+
+-- Remove all per-flock custom curves; they must be re-seeded after rolling back.
+DELETE FROM house_depreciation_standards WHERE project_flock_ids IS NOT NULL;
+
+CREATE UNIQUE INDEX idx_hds_custom_unique
+    ON house_depreciation_standards (house_type, day, effective_date)
+    WHERE project_flock_ids IS NOT NULL;

internal/database/migrations/20260604041743_fix_hds_custom_unique_per_flock.up.sql

@@ -0,0 +1,10 @@
+-- Allow multiple custom depreciation curves per (house_type, day, effective_date)
+-- for different flock groups. Previously idx_hds_custom_unique only keyed on
+-- (house_type, day, effective_date), so separate curves for different project_flock_ids
+-- arrays on the same date were blocked.
+
+DROP INDEX IF EXISTS idx_hds_custom_unique;
+
+CREATE UNIQUE INDEX idx_hds_custom_unique
+    ON house_depreciation_standards (house_type, day, effective_date, project_flock_ids)
+    WHERE project_flock_ids IS NOT NULL;

internal/database/migrations/20260604041941_seed_house_depreciation_flocks_8_13_17.down.sql

@@ -0,0 +1,8 @@
+-- Hapus baris kurva custom dari house_depreciation_standards.
+-- Exact match pada array (IDs di-sort, sama persis dengan yang di-insert).
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[8,13,17]::bigint[]
+  AND effective_date = DATE '2026-06-03';
+
+-- Recompute snapshot depresiasi.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (8, 13, 17);

internal/database/migrations/20260604041941_seed_house_depreciation_flocks_8_13_17.up.sql

@@ -0,0 +1,131 @@
+-- Kurva depresiasi khusus flock 8, 13, 17 (house_type=open_house, effective_date=2026-06-03).
+-- Override hanya multiplication_percentage; house_type & standard_week diwarisi dari baris global.
+-- depreciation_percent diturunkan = (1 - multiplication_percentage) * 100.
+-- Lookup engine: ? = ANY(project_flock_ids) — satu baris dipakai semua flock.
+
+-- Hapus custom curve untuk array ini agar INSERT idempoten.
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[8,13,17]::bigint[]
+  AND house_type = 'open_house'::house_type_enum
+  AND effective_date = DATE '2026-06-03';
+
+INSERT INTO house_depreciation_standards
+    (project_flock_ids, house_type, day, effective_date,
+     multiplication_percentage, depreciation_percent, standard_week, name)
+SELECT
+    ARRAY[8,13,17]::bigint[], g.house_type, g.day, DATE '2026-06-03',
+    v.mult, (1 - v.mult) * 100, g.standard_week,
+    'Custom flocks 8, 13, 17 (eff 2026-06-03)'
+FROM (VALUES
+    (1, 0.9978::numeric), (2, 0.9978), (3, 0.9978), (4, 0.9978), (5, 0.9978),
+    (6, 0.9978), (7, 0.9978), (8, 0.9978), (9, 0.9978), (10, 0.9978),
+    (11, 0.9978), (12, 0.9978), (13, 0.9978), (14, 0.9978), (15, 0.9978),
+    (16, 0.9978), (17, 0.9978), (18, 0.9978), (19, 0.9978), (20, 0.9978),
+    (21, 0.9977), (22, 0.9977), (23, 0.9977), (24, 0.9977), (25, 0.9977),
+    (26, 0.9977), (27, 0.9977), (28, 0.9977), (29, 0.9977), (30, 0.9975),
+    (31, 0.9974), (32, 0.9974), (33, 0.9974), (34, 0.9974), (35, 0.9974),
+    (36, 0.9974), (37, 0.9974), (38, 0.9974), (39, 0.9974), (40, 0.9974),
+    (41, 0.9974), (42, 0.9974), (43, 0.9977), (44, 0.9977), (45, 0.9977),
+    (46, 0.9977), (47, 0.9977), (48, 0.9977), (49, 0.9977), (50, 0.9973),
+    (51, 0.9973), (52, 0.9973), (53, 0.9973), (54, 0.9973), (55, 0.9973),
+    (56, 0.9973), (57, 0.9973), (58, 0.9973), (59, 0.9973), (60, 0.9973),
+    (61, 0.9972), (62, 0.9972), (63, 0.9972), (64, 0.9976), (65, 0.9976),
+    (66, 0.9976), (67, 0.9976), (68, 0.9976), (69, 0.9976), (70, 0.9976),
+    (71, 0.9972), (72, 0.9972), (73, 0.9972), (74, 0.9972), (75, 0.9971),
+    (76, 0.9971), (77, 0.9971), (78, 0.9975), (79, 0.9975), (80, 0.9975),
+    (81, 0.9975), (82, 0.9975), (83, 0.9975), (84, 0.9975), (85, 0.9971),
+    (86, 0.9971), (87, 0.9971), (88, 0.997), (89, 0.997), (90, 0.997),
+    (91, 0.997), (92, 0.997), (93, 0.997), (94, 0.997), (95, 0.997),
+    (96, 0.997), (97, 0.997), (98, 0.997), (99, 0.9974), (100, 0.9974),
+    (101, 0.9974), (102, 0.9974), (103, 0.9974), (104, 0.9973), (105, 0.9973),
+    (106, 0.9969), (107, 0.9969), (108, 0.9969), (109, 0.9969), (110, 0.9968),
+    (111, 0.9968), (112, 0.9968), (113, 0.9973), (114, 0.9973), (115, 0.9973),
+    (116, 0.9972), (117, 0.9972), (118, 0.9972), (119, 0.9972), (120, 0.9968),
+    (121, 0.9967), (122, 0.9967), (123, 0.9967), (124, 0.9967), (125, 0.9967),
+    (126, 0.9967), (127, 0.9972), (128, 0.9971), (129, 0.9971), (130, 0.9971),
+    (131, 0.9971), (132, 0.9971), (133, 0.9971), (134, 0.9966), (135, 0.9966),
+    (136, 0.9966), (137, 0.9966), (138, 0.9966), (139, 0.9966), (140, 0.9965),
+    (141, 0.997), (142, 0.997), (143, 0.997), (144, 0.997), (145, 0.997),
+    (146, 0.997), (147, 0.997), (148, 0.9965), (149, 0.9964), (150, 0.9964),
+    (151, 0.9964), (152, 0.9964), (153, 0.9964), (154, 0.9964), (155, 0.9969),
+    (156, 0.9969), (157, 0.9969), (158, 0.9969), (159, 0.9968), (160, 0.9968),
+    (161, 0.9968), (162, 0.9968), (163, 0.9968), (164, 0.9968), (165, 0.9968),
+    (166, 0.9968), (167, 0.9968), (168, 0.9968), (169, 0.9962), (170, 0.9962),
+    (171, 0.9962), (172, 0.9962), (173, 0.9961), (174, 0.9961), (175, 0.9961),
+    (176, 0.9967), (177, 0.9966), (178, 0.9966), (179, 0.9966), (180, 0.9966),
+    (181, 0.9966), (182, 0.9966), (183, 0.9966), (184, 0.9966), (185, 0.9965),
+    (186, 0.9965), (187, 0.9965), (188, 0.9965), (189, 0.9965), (190, 0.9959),
+    (191, 0.9959), (192, 0.9959), (193, 0.9959), (194, 0.9958), (195, 0.9958),
+    (196, 0.9958), (197, 0.9964), (198, 0.9964), (199, 0.9964), (200, 0.9963),
+    (201, 0.9963), (202, 0.9963), (203, 0.9963), (204, 0.9963), (205, 0.9963),
+    (206, 0.9963), (207, 0.9962), (208, 0.9962), (209, 0.9962), (210, 0.9962),
+    (211, 0.9962), (212, 0.9962), (213, 0.9962), (214, 0.9961), (215, 0.9961),
+    (216, 0.9961), (217, 0.9961), (218, 0.9961), (219, 0.9961), (220, 0.9961),
+    (221, 0.996), (222, 0.996), (223, 0.996), (224, 0.996), (225, 0.9953),
+    (226, 0.9953), (227, 0.9953), (228, 0.9952), (229, 0.9952), (230, 0.9952),
+    (231, 0.9952), (232, 0.9958), (233, 0.9958), (234, 0.9958), (235, 0.9958),
+    (236, 0.9958), (237, 0.9958), (238, 0.9957), (239, 0.9957), (240, 0.9957),
+    (241, 0.9957), (242, 0.9957), (243, 0.9956), (244, 0.9956), (245, 0.9956),
+    (246, 0.9956), (247, 0.9956), (248, 0.9955), (249, 0.9955), (250, 0.9955),
+    (251, 0.9955), (252, 0.9955), (253, 0.9954), (254, 0.9954), (255, 0.9954),
+    (256, 0.9954), (257, 0.9954), (258, 0.9953), (259, 0.9953), (260, 0.9953),
+    (261, 0.9953), (262, 0.9952), (263, 0.9952), (264, 0.9952), (265, 0.9952),
+    (266, 0.9952), (267, 0.9951), (268, 0.9951), (269, 0.9951), (270, 0.9951),
+    (271, 0.995), (272, 0.995), (273, 0.995), (274, 0.995), (275, 0.9949),
+    (276, 0.9949), (277, 0.9949), (278, 0.9949), (279, 0.9948), (280, 0.9948),
+    (281, 0.9948), (282, 0.9947), (283, 0.9947), (284, 0.9947), (285, 0.9947),
+    (286, 0.9946), (287, 0.9946), (288, 0.9955), (289, 0.9955), (290, 0.9954),
+    (291, 0.9954), (292, 0.9954), (293, 0.9954), (294, 0.9954), (295, 0.9944),
+    (296, 0.9944), (297, 0.9943), (298, 0.9943), (299, 0.9943), (300, 0.9942),
+    (301, 0.9942), (302, 0.9942), (303, 0.9941), (304, 0.9941), (305, 0.9941),
+    (306, 0.994), (307, 0.994), (308, 0.994), (309, 0.9939), (310, 0.9939),
+    (311, 0.9938), (312, 0.9938), (313, 0.9938), (314, 0.9937), (315, 0.9937),
+    (316, 0.9937), (317, 0.9936), (318, 0.9936), (319, 0.9935), (320, 0.9935),
+    (321, 0.9934), (322, 0.9934), (323, 0.9945), (324, 0.9944), (325, 0.9944),
+    (326, 0.9944), (327, 0.9943), (328, 0.9943), (329, 0.9943), (330, 0.9931),
+    (331, 0.993), (332, 0.993), (333, 0.9929), (334, 0.9929), (335, 0.9928),
+    (336, 0.9928), (337, 0.9939), (338, 0.9939), (339, 0.9939), (340, 0.9938),
+    (341, 0.9938), (342, 0.9938), (343, 0.9937), (344, 0.9924), (345, 0.9924),
+    (346, 0.9923), (347, 0.9922), (348, 0.9922), (349, 0.9921), (350, 0.9921),
+    (351, 0.992), (352, 0.9919), (353, 0.9919), (354, 0.9918), (355, 0.9917),
+    (356, 0.9917), (357, 0.9916), (358, 0.9929), (359, 0.9929), (360, 0.9928),
+    (361, 0.9928), (362, 0.9927), (363, 0.9927), (364, 0.9926), (365, 0.9911),
+    (366, 0.991), (367, 0.9909), (368, 0.9908), (369, 0.9907), (370, 0.9907),
+    (371, 0.9906), (372, 0.9921), (373, 0.992), (374, 0.9919), (375, 0.9919),
+    (376, 0.9918), (377, 0.9917), (378, 0.9917), (379, 0.9916), (380, 0.9915),
+    (381, 0.9915), (382, 0.9914), (383, 0.9913), (384, 0.9912), (385, 0.9912),
+    (386, 0.9893), (387, 0.9892), (388, 0.9891), (389, 0.9889), (390, 0.9888),
+    (391, 0.9887), (392, 0.9885), (393, 0.9903), (394, 0.9903), (395, 0.9902),
+    (396, 0.9901), (397, 0.99), (398, 0.9899), (399, 0.9898), (400, 0.9896),
+    (401, 0.9895), (402, 0.9894), (403, 0.9893), (404, 0.9892), (405, 0.9891),
+    (406, 0.989), (407, 0.9888), (408, 0.9887), (409, 0.9886), (410, 0.9885),
+    (411, 0.9883), (412, 0.9882), (413, 0.988), (414, 0.9855), (415, 0.9853),
+    (416, 0.985), (417, 0.9848), (418, 0.9846), (419, 0.9843), (420, 0.9841),
+    (421, 0.9865), (422, 0.9863), (423, 0.9861), (424, 0.986), (425, 0.9858),
+    (426, 0.9855), (427, 0.9853), (428, 0.9851), (429, 0.9849), (430, 0.9847),
+    (431, 0.9844), (432, 0.9842), (433, 0.9839), (434, 0.9837), (435, 0.9834),
+    (436, 0.9831), (437, 0.9828), (438, 0.9825), (439, 0.9822), (440, 0.9819),
+    (441, 0.9815), (442, 0.9812), (443, 0.9808), (444, 0.9805), (445, 0.9801),
+    (446, 0.9797), (447, 0.9793), (448, 0.9788), (449, 0.9784), (450, 0.9779),
+    (451, 0.9774), (452, 0.9769), (453, 0.9763), (454, 0.9757), (455, 0.9751),
+    (456, 0.9745), (457, 0.9738), (458, 0.9731), (459, 0.9724), (460, 0.9716),
+    (461, 0.9708), (462, 0.9699), (463, 0.9752), (464, 0.9745), (465, 0.9739),
+    (466, 0.9732), (467, 0.9724), (468, 0.9716), (469, 0.9708), (470, 0.9624),
+    (471, 0.9609), (472, 0.9593), (473, 0.9576), (474, 0.9558), (475, 0.9537),
+    (476, 0.9515), (477, 0.949), (478, 0.9462), (479, 0.9432), (480, 0.9398),
+    (481, 0.9359), (482, 0.9315), (483, 0.9265), (484, 0.9206), (485, 0.9138),
+    (486, 0.9057), (487, 0.8958), (488, 0.8837), (489, 0.8684), (490, 0.8485),
+    (491, 0.8571), (492, 0.8333), (493, 0.8), (494, 0.75), (495, 0.6667),
+    (496, 0.5), (497, 0)
+) AS v(day, mult)
+JOIN LATERAL (
+    SELECT DISTINCT ON (day) house_type, day, standard_week
+    FROM house_depreciation_standards
+    WHERE project_flock_ids IS NULL
+      AND house_type = 'open_house'::house_type_enum
+      AND day = v.day
+    ORDER BY day, effective_date DESC NULLS LAST
+) g ON TRUE;
+
+-- Recompute snapshot depresiasi untuk semua flock yang dipetakan.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (8, 13, 17);

internal/database/migrations/20260604042051_seed_house_depreciation_flocks_18.down.sql

@@ -0,0 +1,8 @@
+-- Hapus baris kurva custom dari house_depreciation_standards.
+-- Exact match pada array (IDs di-sort, sama persis dengan yang di-insert).
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[18]::bigint[]
+  AND effective_date = DATE '2026-06-03';
+
+-- Recompute snapshot depresiasi.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (18);

internal/database/migrations/20260604042051_seed_house_depreciation_flocks_18.up.sql

@@ -0,0 +1,131 @@
+-- Kurva depresiasi khusus flock 18 (house_type=open_house, effective_date=2026-06-03).
+-- Override hanya multiplication_percentage; house_type & standard_week diwarisi dari baris global.
+-- depreciation_percent diturunkan = (1 - multiplication_percentage) * 100.
+-- Lookup engine: ? = ANY(project_flock_ids) — satu baris dipakai semua flock.
+
+-- Hapus custom curve untuk array ini agar INSERT idempoten.
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[18,14,12,15,9,19]::bigint[]
+  AND house_type = 'open_house'::house_type_enum
+  AND effective_date = DATE '2026-06-03';
+
+INSERT INTO house_depreciation_standards
+    (project_flock_ids, house_type, day, effective_date,
+     multiplication_percentage, depreciation_percent, standard_week, name)
+SELECT
+    ARRAY[18,14,12,15,9,19]::bigint[], g.house_type, g.day, DATE '2026-06-03',
+    v.mult, (1 - v.mult) * 100, g.standard_week,
+    'Custom flocks 18,14,12,15,9,19 (eff 2026-06-03)'
+FROM (VALUES
+    (1, 0.9976::numeric), (2, 0.9976), (3, 0.9976), (4, 0.9976), (5, 0.9976),
+    (6, 0.9976), (7, 0.9976), (8, 0.9976), (9, 0.9976), (10, 0.9976),
+    (11, 0.9976), (12, 0.9976), (13, 0.9976), (14, 0.9975), (15, 0.9979),
+    (16, 0.9979), (17, 0.9979), (18, 0.9979), (19, 0.9979), (20, 0.9979),
+    (21, 0.9979), (22, 0.9975), (23, 0.9975), (24, 0.9975), (25, 0.9975),
+    (26, 0.9975), (27, 0.9975), (28, 0.9975), (29, 0.9975), (30, 0.9975),
+    (31, 0.9974), (32, 0.9974), (33, 0.9974), (34, 0.9974), (35, 0.9974),
+    (36, 0.9974), (37, 0.9974), (38, 0.9974), (39, 0.9974), (40, 0.9974),
+    (41, 0.9974), (42, 0.9974), (43, 0.9977), (44, 0.9977), (45, 0.9977),
+    (46, 0.9977), (47, 0.9977), (48, 0.9977), (49, 0.9977), (50, 0.9973),
+    (51, 0.9973), (52, 0.9973), (53, 0.9973), (54, 0.9973), (55, 0.9973),
+    (56, 0.9973), (57, 0.9973), (58, 0.9973), (59, 0.9973), (60, 0.9973),
+    (61, 0.9972), (62, 0.9972), (63, 0.9972), (64, 0.9976), (65, 0.9976),
+    (66, 0.9976), (67, 0.9976), (68, 0.9976), (69, 0.9976), (70, 0.9976),
+    (71, 0.9972), (72, 0.9972), (73, 0.9972), (74, 0.9972), (75, 0.9971),
+    (76, 0.9971), (77, 0.9971), (78, 0.9975), (79, 0.9975), (80, 0.9975),
+    (81, 0.9975), (82, 0.9975), (83, 0.9975), (84, 0.9975), (85, 0.9971),
+    (86, 0.9971), (87, 0.9971), (88, 0.997), (89, 0.997), (90, 0.997),
+    (91, 0.997), (92, 0.997), (93, 0.997), (94, 0.997), (95, 0.997),
+    (96, 0.997), (97, 0.997), (98, 0.997), (99, 0.9974), (100, 0.9974),
+    (101, 0.9974), (102, 0.9974), (103, 0.9974), (104, 0.9973), (105, 0.9973),
+    (106, 0.9969), (107, 0.9969), (108, 0.9969), (109, 0.9969), (110, 0.9968),
+    (111, 0.9968), (112, 0.9968), (113, 0.9973), (114, 0.9973), (115, 0.9973),
+    (116, 0.9972), (117, 0.9972), (118, 0.9972), (119, 0.9972), (120, 0.9968),
+    (121, 0.9967), (122, 0.9967), (123, 0.9967), (124, 0.9967), (125, 0.9967),
+    (126, 0.9967), (127, 0.9972), (128, 0.9971), (129, 0.9971), (130, 0.9971),
+    (131, 0.9971), (132, 0.9971), (133, 0.9971), (134, 0.9966), (135, 0.9966),
+    (136, 0.9966), (137, 0.9966), (138, 0.9966), (139, 0.9966), (140, 0.9965),
+    (141, 0.997), (142, 0.997), (143, 0.997), (144, 0.997), (145, 0.997),
+    (146, 0.997), (147, 0.997), (148, 0.9965), (149, 0.9964), (150, 0.9964),
+    (151, 0.9964), (152, 0.9964), (153, 0.9964), (154, 0.9964), (155, 0.9969),
+    (156, 0.9969), (157, 0.9969), (158, 0.9969), (159, 0.9968), (160, 0.9968),
+    (161, 0.9968), (162, 0.9968), (163, 0.9968), (164, 0.9968), (165, 0.9968),
+    (166, 0.9968), (167, 0.9968), (168, 0.9968), (169, 0.9962), (170, 0.9962),
+    (171, 0.9962), (172, 0.9962), (173, 0.9961), (174, 0.9961), (175, 0.9961),
+    (176, 0.9967), (177, 0.9966), (178, 0.9966), (179, 0.9966), (180, 0.9966),
+    (181, 0.9966), (182, 0.9966), (183, 0.9966), (184, 0.9966), (185, 0.9965),
+    (186, 0.9965), (187, 0.9965), (188, 0.9965), (189, 0.9965), (190, 0.9959),
+    (191, 0.9959), (192, 0.9959), (193, 0.9959), (194, 0.9958), (195, 0.9958),
+    (196, 0.9958), (197, 0.9964), (198, 0.9964), (199, 0.9964), (200, 0.9963),
+    (201, 0.9963), (202, 0.9963), (203, 0.9963), (204, 0.9963), (205, 0.9963),
+    (206, 0.9963), (207, 0.9962), (208, 0.9962), (209, 0.9962), (210, 0.9962),
+    (211, 0.9962), (212, 0.9962), (213, 0.9962), (214, 0.9961), (215, 0.9961),
+    (216, 0.9961), (217, 0.9961), (218, 0.9961), (219, 0.9961), (220, 0.9961),
+    (221, 0.996), (222, 0.996), (223, 0.996), (224, 0.996), (225, 0.9953),
+    (226, 0.9953), (227, 0.9953), (228, 0.9952), (229, 0.9952), (230, 0.9952),
+    (231, 0.9952), (232, 0.9958), (233, 0.9958), (234, 0.9958), (235, 0.9958),
+    (236, 0.9958), (237, 0.9958), (238, 0.9957), (239, 0.9957), (240, 0.9957),
+    (241, 0.9957), (242, 0.9957), (243, 0.9956), (244, 0.9956), (245, 0.9956),
+    (246, 0.9956), (247, 0.9956), (248, 0.9955), (249, 0.9955), (250, 0.9955),
+    (251, 0.9955), (252, 0.9955), (253, 0.9954), (254, 0.9954), (255, 0.9954),
+    (256, 0.9954), (257, 0.9954), (258, 0.9953), (259, 0.9953), (260, 0.9953),
+    (261, 0.9953), (262, 0.9952), (263, 0.9952), (264, 0.9952), (265, 0.9952),
+    (266, 0.9952), (267, 0.9951), (268, 0.9951), (269, 0.9951), (270, 0.9951),
+    (271, 0.995), (272, 0.995), (273, 0.995), (274, 0.995), (275, 0.9949),
+    (276, 0.9949), (277, 0.9949), (278, 0.9949), (279, 0.9948), (280, 0.9948),
+    (281, 0.9948), (282, 0.9947), (283, 0.9947), (284, 0.9947), (285, 0.9947),
+    (286, 0.9946), (287, 0.9946), (288, 0.9955), (289, 0.9955), (290, 0.9954),
+    (291, 0.9954), (292, 0.9954), (293, 0.9954), (294, 0.9954), (295, 0.9944),
+    (296, 0.9944), (297, 0.9943), (298, 0.9943), (299, 0.9943), (300, 0.9942),
+    (301, 0.9942), (302, 0.9942), (303, 0.9941), (304, 0.9941), (305, 0.9941),
+    (306, 0.994), (307, 0.994), (308, 0.994), (309, 0.9939), (310, 0.9939),
+    (311, 0.9938), (312, 0.9938), (313, 0.9938), (314, 0.9937), (315, 0.9937),
+    (316, 0.9937), (317, 0.9936), (318, 0.9936), (319, 0.9935), (320, 0.9935),
+    (321, 0.9934), (322, 0.9934), (323, 0.9945), (324, 0.9944), (325, 0.9944),
+    (326, 0.9944), (327, 0.9943), (328, 0.9943), (329, 0.9943), (330, 0.9931),
+    (331, 0.993), (332, 0.993), (333, 0.9929), (334, 0.9929), (335, 0.9928),
+    (336, 0.9928), (337, 0.9939), (338, 0.9939), (339, 0.9939), (340, 0.9938),
+    (341, 0.9938), (342, 0.9938), (343, 0.9937), (344, 0.9924), (345, 0.9924),
+    (346, 0.9923), (347, 0.9922), (348, 0.9922), (349, 0.9921), (350, 0.9921),
+    (351, 0.992), (352, 0.9919), (353, 0.9919), (354, 0.9918), (355, 0.9917),
+    (356, 0.9917), (357, 0.9916), (358, 0.9929), (359, 0.9929), (360, 0.9928),
+    (361, 0.9928), (362, 0.9927), (363, 0.9927), (364, 0.9926), (365, 0.9911),
+    (366, 0.991), (367, 0.9909), (368, 0.9908), (369, 0.9907), (370, 0.9907),
+    (371, 0.9906), (372, 0.9921), (373, 0.992), (374, 0.9919), (375, 0.9919),
+    (376, 0.9918), (377, 0.9917), (378, 0.9917), (379, 0.9916), (380, 0.9915),
+    (381, 0.9915), (382, 0.9914), (383, 0.9913), (384, 0.9912), (385, 0.9912),
+    (386, 0.9893), (387, 0.9892), (388, 0.9891), (389, 0.9889), (390, 0.9888),
+    (391, 0.9887), (392, 0.9885), (393, 0.9903), (394, 0.9903), (395, 0.9902),
+    (396, 0.9901), (397, 0.99), (398, 0.9899), (399, 0.9898), (400, 0.9896),
+    (401, 0.9895), (402, 0.9894), (403, 0.9893), (404, 0.9892), (405, 0.9891),
+    (406, 0.989), (407, 0.9888), (408, 0.9887), (409, 0.9886), (410, 0.9885),
+    (411, 0.9883), (412, 0.9882), (413, 0.988), (414, 0.9855), (415, 0.9853),
+    (416, 0.985), (417, 0.9848), (418, 0.9846), (419, 0.9843), (420, 0.9841),
+    (421, 0.9865), (422, 0.9863), (423, 0.9861), (424, 0.986), (425, 0.9858),
+    (426, 0.9855), (427, 0.9853), (428, 0.9851), (429, 0.9849), (430, 0.9847),
+    (431, 0.9844), (432, 0.9842), (433, 0.9839), (434, 0.9837), (435, 0.9834),
+    (436, 0.9831), (437, 0.9828), (438, 0.9825), (439, 0.9822), (440, 0.9819),
+    (441, 0.9815), (442, 0.9812), (443, 0.9808), (444, 0.9805), (445, 0.9801),
+    (446, 0.9797), (447, 0.9793), (448, 0.9788), (449, 0.9784), (450, 0.9779),
+    (451, 0.9774), (452, 0.9769), (453, 0.9763), (454, 0.9757), (455, 0.9751),
+    (456, 0.9745), (457, 0.9738), (458, 0.9731), (459, 0.9724), (460, 0.9716),
+    (461, 0.9708), (462, 0.9699), (463, 0.9752), (464, 0.9745), (465, 0.9739),
+    (466, 0.9732), (467, 0.9724), (468, 0.9716), (469, 0.9708), (470, 0.9624),
+    (471, 0.9609), (472, 0.9593), (473, 0.9576), (474, 0.9558), (475, 0.9537),
+    (476, 0.9515), (477, 0.949), (478, 0.9462), (479, 0.9432), (480, 0.9398),
+    (481, 0.9359), (482, 0.9315), (483, 0.9265), (484, 0.9206), (485, 0.9138),
+    (486, 0.9057), (487, 0.8958), (488, 0.8837), (489, 0.8684), (490, 0.8485),
+    (491, 0.8571), (492, 0.8333), (493, 0.8), (494, 0.75), (495, 0.6667),
+    (496, 0.5), (497, 0)
+) AS v(day, mult)
+JOIN LATERAL (
+    SELECT DISTINCT ON (day) house_type, day, standard_week
+    FROM house_depreciation_standards
+    WHERE project_flock_ids IS NULL
+      AND house_type = 'open_house'::house_type_enum
+      AND day = v.day
+    ORDER BY day, effective_date DESC NULLS LAST
+) g ON TRUE;
+
+-- Recompute snapshot depresiasi untuk semua flock yang dipetakan.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (18, 14, 12, 15, 9, 19);

internal/database/migrations/20260604042912_seed_house_depreciation_flocks_26.down.sql

@@ -0,0 +1,8 @@
+-- Hapus baris kurva custom dari house_depreciation_standards.
+-- Exact match pada array (IDs di-sort, sama persis dengan yang di-insert).
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[26]::bigint[]
+  AND effective_date = DATE '2026-06-03';
+
+-- Recompute snapshot depresiasi.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (26);

internal/database/migrations/20260604042912_seed_house_depreciation_flocks_26.up.sql

@@ -0,0 +1,139 @@
+-- Kurva depresiasi khusus flock 26 (house_types=close_house, effective_date=2026-06-03).
+-- Override hanya multiplication_percentage; house_type & standard_week diwarisi dari baris global.
+-- depreciation_percent diturunkan = (1 - multiplication_percentage) * 100.
+-- Lookup engine: ? = ANY(project_flock_ids) — satu baris dipakai semua flock.
+
+-- Hapus custom curve untuk array ini agar INSERT idempoten.
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[26]::bigint[]
+  AND house_type = 'close_house'::house_type_enum
+  AND effective_date = DATE '2026-06-03';
+
+-- house_type: close_house
+INSERT INTO house_depreciation_standards
+    (project_flock_ids, house_type, day, effective_date,
+     multiplication_percentage, depreciation_percent, standard_week, name)
+SELECT
+    ARRAY[26]::bigint[], g.house_type, g.day, DATE '2026-06-03',
+    v.mult, (1 - v.mult) * 100, g.standard_week,
+    'Custom flocks 26 (eff 2026-06-03)'
+FROM (VALUES
+    (1, 0.9981::numeric), (2, 0.9981), (3, 0.9981), (4, 0.9981), (5, 0.9981),
+    (6, 0.9981), (7, 0.9981), (8, 0.9978), (9, 0.9978), (10, 0.9978),
+    (11, 0.9978), (12, 0.9978), (13, 0.9978), (14, 0.9978), (15, 0.9978),
+    (16, 0.9978), (17, 0.9978), (18, 0.9978), (19, 0.9978), (20, 0.9978),
+    (21, 0.9978), (22, 0.9981), (23, 0.9981), (24, 0.9981), (25, 0.9981),
+    (26, 0.9981), (27, 0.9981), (28, 0.9981), (29, 0.9978), (30, 0.9978),
+    (31, 0.9978), (32, 0.9978), (33, 0.9978), (34, 0.9978), (35, 0.9978),
+    (36, 0.9978), (37, 0.9978), (38, 0.9978), (39, 0.9978), (40, 0.9978),
+    (41, 0.9978), (42, 0.9978), (43, 0.9978), (44, 0.9978), (45, 0.9978),
+    (46, 0.9978), (47, 0.9978), (48, 0.9978), (49, 0.9978), (50, 0.9981),
+    (51, 0.9981), (52, 0.9981), (53, 0.9981), (54, 0.9981), (55, 0.9981),
+    (56, 0.9981), (57, 0.9978), (58, 0.9978), (59, 0.9978), (60, 0.9978),
+    (61, 0.9978), (62, 0.9978), (63, 0.9978), (64, 0.9978), (65, 0.9978),
+    (66, 0.9977), (67, 0.9977), (68, 0.9977), (69, 0.9977), (70, 0.9977),
+    (71, 0.9973), (72, 0.9973), (73, 0.9973), (74, 0.9973), (75, 0.9973),
+    (76, 0.9973), (77, 0.9973), (78, 0.9977), (79, 0.9977), (80, 0.9977),
+    (81, 0.9977), (82, 0.9977), (83, 0.9976), (84, 0.9976), (85, 0.9972),
+    (86, 0.9972), (87, 0.9972), (88, 0.9972), (89, 0.9972), (90, 0.9972),
+    (91, 0.9972), (92, 0.9972), (93, 0.9972), (94, 0.9972), (95, 0.9972),
+    (96, 0.9972), (97, 0.9972), (98, 0.9971), (99, 0.9975), (100, 0.9975),
+    (101, 0.9975), (102, 0.9975), (103, 0.9975), (104, 0.9975), (105, 0.9975),
+    (106, 0.9971), (107, 0.9971), (108, 0.9971), (109, 0.9971), (110, 0.9971),
+    (111, 0.997), (112, 0.997), (113, 0.9974), (114, 0.9974), (115, 0.9974),
+    (116, 0.9974), (117, 0.9974), (118, 0.9974), (119, 0.9974), (120, 0.997),
+    (121, 0.997), (122, 0.997), (123, 0.9969), (124, 0.9969), (125, 0.9969),
+    (126, 0.9969), (127, 0.9973), (128, 0.9973), (129, 0.9973), (130, 0.9973),
+    (131, 0.9973), (132, 0.9973), (133, 0.9973), (134, 0.9968), (135, 0.9968),
+    (136, 0.9968), (137, 0.9968), (138, 0.9968), (139, 0.9968), (140, 0.9968),
+    (141, 0.9972), (142, 0.9972), (143, 0.9972), (144, 0.9972), (145, 0.9972),
+    (146, 0.9972), (147, 0.9972), (148, 0.9967), (149, 0.9967), (150, 0.9967),
+    (151, 0.9967), (152, 0.9967), (153, 0.9967), (154, 0.9966), (155, 0.9971),
+    (156, 0.9971), (157, 0.9971), (158, 0.9971), (159, 0.9971), (160, 0.9971),
+    (161, 0.9971), (162, 0.9971), (163, 0.997), (164, 0.997), (165, 0.997),
+    (166, 0.997), (167, 0.997), (168, 0.997), (169, 0.9965), (170, 0.9965),
+    (171, 0.9965), (172, 0.9965), (173, 0.9964), (174, 0.9964), (175, 0.9964),
+    (176, 0.9969), (177, 0.9969), (178, 0.9969), (179, 0.9969), (180, 0.9969),
+    (181, 0.9969), (182, 0.9969), (183, 0.9968), (184, 0.9968), (185, 0.9968),
+    (186, 0.9968), (187, 0.9968), (188, 0.9968), (189, 0.9968), (190, 0.9962),
+    (191, 0.9962), (192, 0.9962), (193, 0.9962), (194, 0.9962), (195, 0.9962),
+    (196, 0.9962), (197, 0.9967), (198, 0.9967), (199, 0.9967), (200, 0.9967),
+    (201, 0.9966), (202, 0.9966), (203, 0.9966), (204, 0.9966), (205, 0.9966),
+    (206, 0.9966), (207, 0.9966), (208, 0.9966), (209, 0.9966), (210, 0.9965),
+    (211, 0.9965), (212, 0.9965), (213, 0.9965), (214, 0.9965), (215, 0.9965),
+    (216, 0.9965), (217, 0.9965), (218, 0.9964), (219, 0.9964), (220, 0.9964),
+    (221, 0.9964), (222, 0.9964), (223, 0.9964), (224, 0.9964), (225, 0.9957),
+    (226, 0.9957), (227, 0.9957), (228, 0.9957), (229, 0.9957), (230, 0.9957),
+    (231, 0.9956), (232, 0.9962), (233, 0.9962), (234, 0.9962), (235, 0.9962),
+    (236, 0.9962), (237, 0.9962), (238, 0.9962), (239, 0.9961), (240, 0.9961),
+    (241, 0.9961), (242, 0.9961), (243, 0.9961), (244, 0.9961), (245, 0.996),
+    (246, 0.996), (247, 0.996), (248, 0.996), (249, 0.996), (250, 0.996),
+    (251, 0.996), (252, 0.9959), (253, 0.9959), (254, 0.9959), (255, 0.9959),
+    (256, 0.9959), (257, 0.9959), (258, 0.9958), (259, 0.9958), (260, 0.9958),
+    (261, 0.9958), (262, 0.9958), (263, 0.9957), (264, 0.9957), (265, 0.9957),
+    (266, 0.9957), (267, 0.9957), (268, 0.9957), (269, 0.9956), (270, 0.9956),
+    (271, 0.9956), (272, 0.9956), (273, 0.9956), (274, 0.9955), (275, 0.9955),
+    (276, 0.9955), (277, 0.9955), (278, 0.9955), (279, 0.9954), (280, 0.9954),
+    (281, 0.9954), (282, 0.9954), (283, 0.9953), (284, 0.9953), (285, 0.9953),
+    (286, 0.9953), (287, 0.9953), (288, 0.996), (289, 0.996), (290, 0.996),
+    (291, 0.996), (292, 0.996), (293, 0.996), (294, 0.9959), (295, 0.9951),
+    (296, 0.9951), (297, 0.9951), (298, 0.995), (299, 0.995), (300, 0.995),
+    (301, 0.995), (302, 0.9949), (303, 0.9949), (304, 0.9949), (305, 0.9948),
+    (306, 0.9948), (307, 0.9948), (308, 0.9948), (309, 0.9947), (310, 0.9947),
+    (311, 0.9947), (312, 0.9947), (313, 0.9946), (314, 0.9946), (315, 0.9946),
+    (316, 0.9945), (317, 0.9945), (318, 0.9945), (319, 0.9944), (320, 0.9944),
+    (321, 0.9944), (322, 0.9944), (323, 0.9953), (324, 0.9952), (325, 0.9952),
+    (326, 0.9952), (327, 0.9952), (328, 0.9952), (329, 0.9951), (330, 0.9941),
+    (331, 0.9941), (332, 0.9941), (333, 0.994), (334, 0.994), (335, 0.994),
+    (336, 0.9939), (337, 0.9949), (338, 0.9949), (339, 0.9948), (340, 0.9948),
+    (341, 0.9948), (342, 0.9948), (343, 0.9947), (344, 0.9937), (345, 0.9936),
+    (346, 0.9936), (347, 0.9935), (348, 0.9935), (349, 0.9934), (350, 0.9934),
+    (351, 0.9934), (352, 0.9933), (353, 0.9933), (354, 0.9932), (355, 0.9932),
+    (356, 0.9931), (357, 0.9931), (358, 0.9942), (359, 0.9942), (360, 0.9941),
+    (361, 0.9941), (362, 0.9941), (363, 0.994), (364, 0.994), (365, 0.9927),
+    (366, 0.9927), (367, 0.9926), (368, 0.9926), (369, 0.9925), (370, 0.9925),
+    (371, 0.9924), (372, 0.9936), (373, 0.9936), (374, 0.9935), (375, 0.9935),
+    (376, 0.9935), (377, 0.9934), (378, 0.9934), (379, 0.9933), (380, 0.9933),
+    (381, 0.9932), (382, 0.9932), (383, 0.9931), (384, 0.9931), (385, 0.993),
+    (386, 0.9916), (387, 0.9915), (388, 0.9915), (389, 0.9914), (390, 0.9913),
+    (391, 0.9912), (392, 0.9912), (393, 0.9926), (394, 0.9925), (395, 0.9924),
+    (396, 0.9924), (397, 0.9923), (398, 0.9923), (399, 0.9922), (400, 0.9922),
+    (401, 0.9921), (402, 0.992), (403, 0.992), (404, 0.9919), (405, 0.9918),
+    (406, 0.9918), (407, 0.9917), (408, 0.9916), (409, 0.9916), (410, 0.9915),
+    (411, 0.9914), (412, 0.9913), (413, 0.9913), (414, 0.9894), (415, 0.9893),
+    (416, 0.9892), (417, 0.9891), (418, 0.989), (419, 0.9888), (420, 0.9887),
+    (421, 0.9905), (422, 0.9904), (423, 0.9903), (424, 0.9902), (425, 0.9901),
+    (426, 0.99), (427, 0.9899), (428, 0.9898), (429, 0.9897), (430, 0.9896),
+    (431, 0.9895), (432, 0.9894), (433, 0.9892), (434, 0.9891), (435, 0.989),
+    (436, 0.9889), (437, 0.9888), (438, 0.9886), (439, 0.9885), (440, 0.9884),
+    (441, 0.9882), (442, 0.9881), (443, 0.988), (444, 0.9878), (445, 0.9877),
+    (446, 0.9875), (447, 0.9873), (448, 0.9872), (449, 0.987), (450, 0.9868),
+    (451, 0.9867), (452, 0.9865), (453, 0.9863), (454, 0.9861), (455, 0.9859),
+    (456, 0.9857), (457, 0.9855), (458, 0.9853), (459, 0.9851), (460, 0.9848),
+    (461, 0.9846), (462, 0.9844), (463, 0.9873), (464, 0.9871), (465, 0.987),
+    (466, 0.9868), (467, 0.9866), (468, 0.9864), (469, 0.9863), (470, 0.9826),
+    (471, 0.9823), (472, 0.9819), (473, 0.9816), (474, 0.9813), (475, 0.9809),
+    (476, 0.9805), (477, 0.9802), (478, 0.9798), (479, 0.9793), (480, 0.9789),
+    (481, 0.9784), (482, 0.978), (483, 0.9775), (484, 0.977), (485, 0.9764),
+    (486, 0.9758), (487, 0.9752), (488, 0.9746), (489, 0.974), (490, 0.9733),
+    (491, 0.978), (492, 0.9775), (493, 0.977), (494, 0.9765), (495, 0.9759),
+    (496, 0.9753), (497, 0.9747), (498, 0.9675), (499, 0.9664), (500, 0.9653),
+    (501, 0.964), (502, 0.9627), (503, 0.9612), (504, 0.9597), (505, 0.9664),
+    (506, 0.9652), (507, 0.964), (508, 0.9626), (509, 0.9612), (510, 0.9596),
+    (511, 0.9579), (512, 0.9451), (513, 0.9419), (514, 0.9383), (515, 0.9342),
+    (516, 0.9296), (517, 0.9242), (518, 0.918), (519, 0.9286), (520, 0.9231),
+    (521, 0.9167), (522, 0.9091), (523, 0.9), (524, 0.8889), (525, 0.875),
+    (526, 0.8571), (527, 0.8333), (528, 0.8), (529, 0.75), (530, 0.6667),
+    (531, 0.5), (532, 0)
+) AS v(day, mult)
+JOIN LATERAL (
+    SELECT DISTINCT ON (day) house_type, day, standard_week
+    FROM house_depreciation_standards
+    WHERE project_flock_ids IS NULL
+      AND house_type = 'close_house'::house_type_enum
+      AND day = v.day
+    ORDER BY day, effective_date DESC NULLS LAST
+) g ON TRUE;
+
+-- Recompute snapshot depresiasi untuk semua flock yang dipetakan.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (26);

internal/database/migrations/20260604043007_seed_house_depreciation_flocks_20.down.sql

@@ -0,0 +1,8 @@
+-- Hapus baris kurva custom dari house_depreciation_standards.
+-- Exact match pada array (IDs di-sort, sama persis dengan yang di-insert).
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[20]::bigint[]
+  AND effective_date = DATE '2026-06-03';
+
+-- Recompute snapshot depresiasi.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (20);

internal/database/migrations/20260604043007_seed_house_depreciation_flocks_20.up.sql

@@ -0,0 +1,139 @@
+-- Kurva depresiasi khusus flock 20 (house_types=open_house, effective_date=2026-06-03).
+-- Override hanya multiplication_percentage; house_type & standard_week diwarisi dari baris global.
+-- depreciation_percent diturunkan = (1 - multiplication_percentage) * 100.
+-- Lookup engine: ? = ANY(project_flock_ids) — satu baris dipakai semua flock.
+
+-- Hapus custom curve untuk array ini agar INSERT idempoten.
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[20]::bigint[]
+  AND house_type = 'open_house'::house_type_enum
+  AND effective_date = DATE '2026-06-03';
+
+-- house_type: open_house
+INSERT INTO house_depreciation_standards
+    (project_flock_ids, house_type, day, effective_date,
+     multiplication_percentage, depreciation_percent, standard_week, name)
+SELECT
+    ARRAY[20]::bigint[], g.house_type, g.day, DATE '2026-06-03',
+    v.mult, (1 - v.mult) * 100, g.standard_week,
+    'Custom flocks 20 (eff 2026-06-03)'
+FROM (VALUES
+    (1, 0.9977::numeric), (2, 0.9977), (3, 0.9977), (4, 0.9977), (5, 0.9977),
+    (6, 0.9977), (7, 0.9977), (8, 0.9977), (9, 0.9977), (10, 0.9977),
+    (11, 0.9977), (12, 0.9977), (13, 0.9977), (14, 0.9977), (15, 0.998),
+    (16, 0.998), (17, 0.998), (18, 0.998), (19, 0.998), (20, 0.998),
+    (21, 0.998), (22, 0.9976), (23, 0.9976), (24, 0.9976), (25, 0.9976),
+    (26, 0.9976), (27, 0.9976), (28, 0.9976), (29, 0.9976), (30, 0.9976),
+    (31, 0.9976), (32, 0.9976), (33, 0.9976), (34, 0.9976), (35, 0.9976),
+    (36, 0.9976), (37, 0.9975), (38, 0.9975), (39, 0.9975), (40, 0.9975),
+    (41, 0.9975), (42, 0.9975), (43, 0.9979), (44, 0.9979), (45, 0.9979),
+    (46, 0.9979), (47, 0.9978), (48, 0.9978), (49, 0.9978), (50, 0.9975),
+    (51, 0.9975), (52, 0.9975), (53, 0.9975), (54, 0.9974), (55, 0.9974),
+    (56, 0.9974), (57, 0.9974), (58, 0.9974), (59, 0.9974), (60, 0.9974),
+    (61, 0.9974), (62, 0.9974), (63, 0.9974), (64, 0.9978), (65, 0.9978),
+    (66, 0.9977), (67, 0.9977), (68, 0.9977), (69, 0.9977), (70, 0.9977),
+    (71, 0.9973), (72, 0.9973), (73, 0.9973), (74, 0.9973), (75, 0.9973),
+    (76, 0.9973), (77, 0.9973), (78, 0.9977), (79, 0.9977), (80, 0.9977),
+    (81, 0.9977), (82, 0.9977), (83, 0.9976), (84, 0.9976), (85, 0.9972),
+    (86, 0.9972), (87, 0.9972), (88, 0.9972), (89, 0.9972), (90, 0.9972),
+    (91, 0.9972), (92, 0.9972), (93, 0.9972), (94, 0.9972), (95, 0.9972),
+    (96, 0.9972), (97, 0.9972), (98, 0.9971), (99, 0.9975), (100, 0.9975),
+    (101, 0.9975), (102, 0.9975), (103, 0.9975), (104, 0.9975), (105, 0.9975),
+    (106, 0.9971), (107, 0.9971), (108, 0.9971), (109, 0.9971), (110, 0.9971),
+    (111, 0.997), (112, 0.997), (113, 0.9974), (114, 0.9974), (115, 0.9974),
+    (116, 0.9974), (117, 0.9974), (118, 0.9974), (119, 0.9974), (120, 0.997),
+    (121, 0.997), (122, 0.997), (123, 0.9969), (124, 0.9969), (125, 0.9969),
+    (126, 0.9969), (127, 0.9973), (128, 0.9973), (129, 0.9973), (130, 0.9973),
+    (131, 0.9973), (132, 0.9973), (133, 0.9973), (134, 0.9968), (135, 0.9968),
+    (136, 0.9968), (137, 0.9968), (138, 0.9968), (139, 0.9968), (140, 0.9968),
+    (141, 0.9972), (142, 0.9972), (143, 0.9972), (144, 0.9972), (145, 0.9972),
+    (146, 0.9972), (147, 0.9972), (148, 0.9967), (149, 0.9967), (150, 0.9967),
+    (151, 0.9967), (152, 0.9967), (153, 0.9967), (154, 0.9966), (155, 0.9971),
+    (156, 0.9971), (157, 0.9971), (158, 0.9971), (159, 0.9971), (160, 0.9971),
+    (161, 0.9971), (162, 0.9971), (163, 0.997), (164, 0.997), (165, 0.997),
+    (166, 0.997), (167, 0.997), (168, 0.997), (169, 0.9965), (170, 0.9965),
+    (171, 0.9965), (172, 0.9965), (173, 0.9964), (174, 0.9964), (175, 0.9964),
+    (176, 0.9969), (177, 0.9969), (178, 0.9969), (179, 0.9969), (180, 0.9969),
+    (181, 0.9969), (182, 0.9969), (183, 0.9968), (184, 0.9968), (185, 0.9968),
+    (186, 0.9968), (187, 0.9968), (188, 0.9968), (189, 0.9968), (190, 0.9962),
+    (191, 0.9962), (192, 0.9962), (193, 0.9962), (194, 0.9962), (195, 0.9962),
+    (196, 0.9962), (197, 0.9967), (198, 0.9967), (199, 0.9967), (200, 0.9967),
+    (201, 0.9966), (202, 0.9966), (203, 0.9966), (204, 0.9966), (205, 0.9966),
+    (206, 0.9966), (207, 0.9966), (208, 0.9966), (209, 0.9966), (210, 0.9965),
+    (211, 0.9965), (212, 0.9965), (213, 0.9965), (214, 0.9965), (215, 0.9965),
+    (216, 0.9965), (217, 0.9965), (218, 0.9964), (219, 0.9964), (220, 0.9964),
+    (221, 0.9964), (222, 0.9964), (223, 0.9964), (224, 0.9964), (225, 0.9957),
+    (226, 0.9957), (227, 0.9957), (228, 0.9957), (229, 0.9957), (230, 0.9957),
+    (231, 0.9956), (232, 0.9962), (233, 0.9962), (234, 0.9962), (235, 0.9962),
+    (236, 0.9962), (237, 0.9962), (238, 0.9962), (239, 0.9961), (240, 0.9961),
+    (241, 0.9961), (242, 0.9961), (243, 0.9961), (244, 0.9961), (245, 0.996),
+    (246, 0.996), (247, 0.996), (248, 0.996), (249, 0.996), (250, 0.996),
+    (251, 0.996), (252, 0.9959), (253, 0.9959), (254, 0.9959), (255, 0.9959),
+    (256, 0.9959), (257, 0.9959), (258, 0.9958), (259, 0.9958), (260, 0.9958),
+    (261, 0.9958), (262, 0.9958), (263, 0.9957), (264, 0.9957), (265, 0.9957),
+    (266, 0.9957), (267, 0.9957), (268, 0.9957), (269, 0.9956), (270, 0.9956),
+    (271, 0.9956), (272, 0.9956), (273, 0.9956), (274, 0.9955), (275, 0.9955),
+    (276, 0.9955), (277, 0.9955), (278, 0.9955), (279, 0.9954), (280, 0.9954),
+    (281, 0.9954), (282, 0.9954), (283, 0.9953), (284, 0.9953), (285, 0.9953),
+    (286, 0.9953), (287, 0.9953), (288, 0.996), (289, 0.996), (290, 0.996),
+    (291, 0.996), (292, 0.996), (293, 0.996), (294, 0.9959), (295, 0.9951),
+    (296, 0.9951), (297, 0.9951), (298, 0.995), (299, 0.995), (300, 0.995),
+    (301, 0.995), (302, 0.9949), (303, 0.9949), (304, 0.9949), (305, 0.9948),
+    (306, 0.9948), (307, 0.9948), (308, 0.9948), (309, 0.9947), (310, 0.9947),
+    (311, 0.9947), (312, 0.9947), (313, 0.9946), (314, 0.9946), (315, 0.9946),
+    (316, 0.9945), (317, 0.9945), (318, 0.9945), (319, 0.9944), (320, 0.9944),
+    (321, 0.9944), (322, 0.9944), (323, 0.9953), (324, 0.9952), (325, 0.9952),
+    (326, 0.9952), (327, 0.9952), (328, 0.9952), (329, 0.9951), (330, 0.9941),
+    (331, 0.9941), (332, 0.9941), (333, 0.994), (334, 0.994), (335, 0.994),
+    (336, 0.9939), (337, 0.9949), (338, 0.9949), (339, 0.9948), (340, 0.9948),
+    (341, 0.9948), (342, 0.9948), (343, 0.9947), (344, 0.9937), (345, 0.9936),
+    (346, 0.9936), (347, 0.9935), (348, 0.9935), (349, 0.9934), (350, 0.9934),
+    (351, 0.9934), (352, 0.9933), (353, 0.9933), (354, 0.9932), (355, 0.9932),
+    (356, 0.9931), (357, 0.9931), (358, 0.9942), (359, 0.9942), (360, 0.9941),
+    (361, 0.9941), (362, 0.9941), (363, 0.994), (364, 0.994), (365, 0.9927),
+    (366, 0.9927), (367, 0.9926), (368, 0.9926), (369, 0.9925), (370, 0.9925),
+    (371, 0.9924), (372, 0.9936), (373, 0.9936), (374, 0.9935), (375, 0.9935),
+    (376, 0.9935), (377, 0.9934), (378, 0.9934), (379, 0.9933), (380, 0.9933),
+    (381, 0.9932), (382, 0.9932), (383, 0.9931), (384, 0.9931), (385, 0.993),
+    (386, 0.9916), (387, 0.9915), (388, 0.9915), (389, 0.9914), (390, 0.9913),
+    (391, 0.9912), (392, 0.9912), (393, 0.9926), (394, 0.9925), (395, 0.9924),
+    (396, 0.9924), (397, 0.9923), (398, 0.9923), (399, 0.9922), (400, 0.9922),
+    (401, 0.9921), (402, 0.992), (403, 0.992), (404, 0.9919), (405, 0.9918),
+    (406, 0.9918), (407, 0.9917), (408, 0.9916), (409, 0.9916), (410, 0.9915),
+    (411, 0.9914), (412, 0.9913), (413, 0.9913), (414, 0.9894), (415, 0.9893),
+    (416, 0.9892), (417, 0.9891), (418, 0.989), (419, 0.9888), (420, 0.9887),
+    (421, 0.9905), (422, 0.9904), (423, 0.9903), (424, 0.9902), (425, 0.9901),
+    (426, 0.99), (427, 0.9899), (428, 0.9898), (429, 0.9897), (430, 0.9896),
+    (431, 0.9895), (432, 0.9894), (433, 0.9892), (434, 0.9891), (435, 0.989),
+    (436, 0.9889), (437, 0.9888), (438, 0.9886), (439, 0.9885), (440, 0.9884),
+    (441, 0.9882), (442, 0.9881), (443, 0.988), (444, 0.9878), (445, 0.9877),
+    (446, 0.9875), (447, 0.9873), (448, 0.9872), (449, 0.987), (450, 0.9868),
+    (451, 0.9867), (452, 0.9865), (453, 0.9863), (454, 0.9861), (455, 0.9859),
+    (456, 0.9857), (457, 0.9855), (458, 0.9853), (459, 0.9851), (460, 0.9848),
+    (461, 0.9846), (462, 0.9844), (463, 0.9873), (464, 0.9871), (465, 0.987),
+    (466, 0.9868), (467, 0.9866), (468, 0.9864), (469, 0.9863), (470, 0.9826),
+    (471, 0.9823), (472, 0.9819), (473, 0.9816), (474, 0.9813), (475, 0.9809),
+    (476, 0.9805), (477, 0.9802), (478, 0.9798), (479, 0.9793), (480, 0.9789),
+    (481, 0.9784), (482, 0.978), (483, 0.9775), (484, 0.977), (485, 0.9764),
+    (486, 0.9758), (487, 0.9752), (488, 0.9746), (489, 0.974), (490, 0.9733),
+    (491, 0.978), (492, 0.9775), (493, 0.977), (494, 0.9765), (495, 0.9759),
+    (496, 0.9753), (497, 0.9747), (498, 0.9675), (499, 0.9664), (500, 0.9653),
+    (501, 0.964), (502, 0.9627), (503, 0.9612), (504, 0.9597), (505, 0.9664),
+    (506, 0.9652), (507, 0.964), (508, 0.9626), (509, 0.9612), (510, 0.9596),
+    (511, 0.9579), (512, 0.9451), (513, 0.9419), (514, 0.9383), (515, 0.9342),
+    (516, 0.9296), (517, 0.9242), (518, 0.918), (519, 0.9286), (520, 0.9231),
+    (521, 0.9167), (522, 0.9091), (523, 0.9), (524, 0.8889), (525, 0.875),
+    (526, 0.8571), (527, 0.8333), (528, 0.8), (529, 0.75), (530, 0.6667),
+    (531, 0.5), (532, 0)
+) AS v(day, mult)
+JOIN LATERAL (
+    SELECT DISTINCT ON (day) house_type, day, standard_week
+    FROM house_depreciation_standards
+    WHERE project_flock_ids IS NULL
+      AND house_type = 'open_house'::house_type_enum
+      AND day = v.day
+    ORDER BY day, effective_date DESC NULLS LAST
+) g ON TRUE;
+
+-- Recompute snapshot depresiasi untuk semua flock yang dipetakan.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (20);

internal/database/migrations/20260604043052_seed_house_depreciation_flocks_4.down.sql

@@ -0,0 +1,8 @@
+-- Hapus baris kurva custom dari house_depreciation_standards.
+-- Exact match pada array (IDs di-sort, sama persis dengan yang di-insert).
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[4]::bigint[]
+  AND effective_date = DATE '2026-06-03';
+
+-- Recompute snapshot depresiasi.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (4);

internal/database/migrations/20260604043052_seed_house_depreciation_flocks_4.up.sql

@@ -0,0 +1,85 @@
+-- Kurva depresiasi khusus flock 4 (house_types=open_house, effective_date=2026-06-03).
+-- Override hanya multiplication_percentage; house_type & standard_week diwarisi dari baris global.
+-- depreciation_percent diturunkan = (1 - multiplication_percentage) * 100.
+-- Lookup engine: ? = ANY(project_flock_ids) — satu baris dipakai semua flock.
+
+-- Hapus custom curve untuk array ini agar INSERT idempoten.
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[4]::bigint[]
+  AND house_type = 'open_house'::house_type_enum
+  AND effective_date = DATE '2026-06-03';
+
+-- house_type: open_house
+INSERT INTO house_depreciation_standards
+    (project_flock_ids, house_type, day, effective_date,
+     multiplication_percentage, depreciation_percent, standard_week, name)
+SELECT
+    ARRAY[4]::bigint[], g.house_type, g.day, DATE '2026-06-03',
+    v.mult, (1 - v.mult) * 100, g.standard_week,
+    'Custom flocks 4 (eff 2026-06-03)'
+FROM (VALUES
+    (1, 0.9958::numeric), (2, 0.9958), (3, 0.9958), (4, 0.9958), (5, 0.9958),
+    (6, 0.9957), (7, 0.9957), (8, 0.9957), (9, 0.9957), (10, 0.9957),
+    (11, 0.9956), (12, 0.9956), (13, 0.9956), (14, 0.9956), (15, 0.9956),
+    (16, 0.9955), (17, 0.9955), (18, 0.9955), (19, 0.9955), (20, 0.9955),
+    (21, 0.9954), (22, 0.9954), (23, 0.9954), (24, 0.9954), (25, 0.9954),
+    (26, 0.9953), (27, 0.9953), (28, 0.9953), (29, 0.9953), (30, 0.9952),
+    (31, 0.9952), (32, 0.9952), (33, 0.9952), (34, 0.9952), (35, 0.9951),
+    (36, 0.9951), (37, 0.9951), (38, 0.9951), (39, 0.995), (40, 0.995),
+    (41, 0.995), (42, 0.995), (43, 0.9949), (44, 0.9949), (45, 0.9949),
+    (46, 0.9949), (47, 0.9948), (48, 0.9948), (49, 0.9948), (50, 0.9947),
+    (51, 0.9947), (52, 0.9947), (53, 0.9947), (54, 0.9946), (55, 0.9946),
+    (56, 0.9955), (57, 0.9955), (58, 0.9954), (59, 0.9954), (60, 0.9954),
+    (61, 0.9954), (62, 0.9954), (63, 0.9944), (64, 0.9944), (65, 0.9943),
+    (66, 0.9943), (67, 0.9943), (68, 0.9942), (69, 0.9942), (70, 0.9942),
+    (71, 0.9941), (72, 0.9941), (73, 0.9941), (74, 0.994), (75, 0.994),
+    (76, 0.994), (77, 0.9939), (78, 0.9939), (79, 0.9938), (80, 0.9938),
+    (81, 0.9938), (82, 0.9937), (83, 0.9937), (84, 0.9937), (85, 0.9936),
+    (86, 0.9936), (87, 0.9935), (88, 0.9935), (89, 0.9934), (90, 0.9934),
+    (91, 0.9945), (92, 0.9944), (93, 0.9944), (94, 0.9944), (95, 0.9943),
+    (96, 0.9943), (97, 0.9943), (98, 0.9931), (99, 0.993), (100, 0.993),
+    (101, 0.9929), (102, 0.9929), (103, 0.9928), (104, 0.9928), (105, 0.9939),
+    (106, 0.9939), (107, 0.9939), (108, 0.9938), (109, 0.9938), (110, 0.9938),
+    (111, 0.9937), (112, 0.9924), (113, 0.9924), (114, 0.9923), (115, 0.9922),
+    (116, 0.9922), (117, 0.9921), (118, 0.9921), (119, 0.992), (120, 0.9919),
+    (121, 0.9919), (122, 0.9918), (123, 0.9917), (124, 0.9917), (125, 0.9916),
+    (126, 0.9929), (127, 0.9929), (128, 0.9928), (129, 0.9928), (130, 0.9927),
+    (131, 0.9927), (132, 0.9926), (133, 0.9911), (134, 0.991), (135, 0.9909),
+    (136, 0.9908), (137, 0.9907), (138, 0.9907), (139, 0.9906), (140, 0.9921),
+    (141, 0.992), (142, 0.9919), (143, 0.9919), (144, 0.9918), (145, 0.9917),
+    (146, 0.9917), (147, 0.9916), (148, 0.9915), (149, 0.9915), (150, 0.9914),
+    (151, 0.9913), (152, 0.9912), (153, 0.9912), (154, 0.9893), (155, 0.9892),
+    (156, 0.9891), (157, 0.9889), (158, 0.9888), (159, 0.9887), (160, 0.9885),
+    (161, 0.9903), (162, 0.9903), (163, 0.9902), (164, 0.9901), (165, 0.99),
+    (166, 0.9899), (167, 0.9898), (168, 0.9896), (169, 0.9895), (170, 0.9894),
+    (171, 0.9893), (172, 0.9892), (173, 0.9891), (174, 0.989), (175, 0.9888),
+    (176, 0.9887), (177, 0.9886), (178, 0.9885), (179, 0.9883), (180, 0.9882),
+    (181, 0.988), (182, 0.9855), (183, 0.9853), (184, 0.985), (185, 0.9848),
+    (186, 0.9846), (187, 0.9843), (188, 0.9841), (189, 0.9865), (190, 0.9863),
+    (191, 0.9861), (192, 0.986), (193, 0.9858), (194, 0.9855), (195, 0.9853),
+    (196, 0.9851), (197, 0.9849), (198, 0.9847), (199, 0.9844), (200, 0.9842),
+    (201, 0.9839), (202, 0.9837), (203, 0.9834), (204, 0.9831), (205, 0.9828),
+    (206, 0.9825), (207, 0.9822), (208, 0.9819), (209, 0.9815), (210, 0.9812),
+    (211, 0.9808), (212, 0.9805), (213, 0.9801), (214, 0.9797), (215, 0.9793),
+    (216, 0.9788), (217, 0.9784), (218, 0.9779), (219, 0.9774), (220, 0.9769),
+    (221, 0.9763), (222, 0.9757), (223, 0.9751), (224, 0.9745), (225, 0.9738),
+    (226, 0.9731), (227, 0.9724), (228, 0.9716), (229, 0.9708), (230, 0.9699),
+    (231, 0.9752), (232, 0.9745), (233, 0.9739), (234, 0.9732), (235, 0.9724),
+    (236, 0.9716), (237, 0.9708), (238, 0.9624), (239, 0.9609), (240, 0.9593),
+    (241, 0.9576), (242, 0.9558), (243, 0.9537), (244, 0.9515), (245, 0.949),
+    (246, 0.9462), (247, 0.9432), (248, 0.9398), (249, 0.9359), (250, 0.9315),
+    (251, 0.9265), (252, 0.9206), (253, 0.9138), (254, 0.9057), (255, 0.8958),
+    (256, 0.8837), (257, 0.8684), (258, 0.8485), (259, 0.8571), (260, 0.8333),
+    (261, 0.8), (262, 0.75), (263, 0.6667), (264, 0.5), (265, 0)
+) AS v(day, mult)
+JOIN LATERAL (
+    SELECT DISTINCT ON (day) house_type, day, standard_week
+    FROM house_depreciation_standards
+    WHERE project_flock_ids IS NULL
+      AND house_type = 'open_house'::house_type_enum
+      AND day = v.day
+    ORDER BY day, effective_date DESC NULLS LAST
+) g ON TRUE;
+
+-- Recompute snapshot depresiasi untuk semua flock yang dipetakan.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (4);

internal/database/migrations/20260604043132_seed_house_depreciation_flocks_5.down.sql

@@ -0,0 +1,8 @@
+-- Hapus baris kurva custom dari house_depreciation_standards.
+-- Exact match pada array (IDs di-sort, sama persis dengan yang di-insert).
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[5]::bigint[]
+  AND effective_date = DATE '2026-06-03';
+
+-- Recompute snapshot depresiasi.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (5);

internal/database/migrations/20260604043132_seed_house_depreciation_flocks_5.up.sql

@@ -0,0 +1,118 @@
+-- Kurva depresiasi khusus flock 5 (house_types=open_house, effective_date=2026-06-03).
+-- Override hanya multiplication_percentage; house_type & standard_week diwarisi dari baris global.
+-- depreciation_percent diturunkan = (1 - multiplication_percentage) * 100.
+-- Lookup engine: ? = ANY(project_flock_ids) — satu baris dipakai semua flock.
+
+-- Hapus custom curve untuk array ini agar INSERT idempoten.
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[5]::bigint[]
+  AND house_type = 'open_house'::house_type_enum
+  AND effective_date = DATE '2026-06-03';
+
+-- house_type: open_house
+INSERT INTO house_depreciation_standards
+    (project_flock_ids, house_type, day, effective_date,
+     multiplication_percentage, depreciation_percent, standard_week, name)
+SELECT
+    ARRAY[5]::bigint[], g.house_type, g.day, DATE '2026-06-03',
+    v.mult, (1 - v.mult) * 100, g.standard_week,
+    'Custom flocks 5 (eff 2026-06-03)'
+FROM (VALUES
+    (1, 0.9976::numeric), (2, 0.9972), (3, 0.9972), (4, 0.9972), (5, 0.9972),
+    (6, 0.9971), (7, 0.9971), (8, 0.9971), (9, 0.9975), (10, 0.9975),
+    (11, 0.9975), (12, 0.9975), (13, 0.9975), (14, 0.9975), (15, 0.9975),
+    (16, 0.9971), (17, 0.9971), (18, 0.9971), (19, 0.997), (20, 0.997),
+    (21, 0.997), (22, 0.997), (23, 0.997), (24, 0.997), (25, 0.997),
+    (26, 0.997), (27, 0.997), (28, 0.997), (29, 0.997), (30, 0.9974),
+    (31, 0.9974), (32, 0.9974), (33, 0.9974), (34, 0.9974), (35, 0.9973),
+    (36, 0.9973), (37, 0.9969), (38, 0.9969), (39, 0.9969), (40, 0.9969),
+    (41, 0.9968), (42, 0.9968), (43, 0.9968), (44, 0.9973), (45, 0.9973),
+    (46, 0.9973), (47, 0.9972), (48, 0.9972), (49, 0.9972), (50, 0.9972),
+    (51, 0.9968), (52, 0.9967), (53, 0.9967), (54, 0.9967), (55, 0.9967),
+    (56, 0.9967), (57, 0.9967), (58, 0.9972), (59, 0.9971), (60, 0.9971),
+    (61, 0.9971), (62, 0.9971), (63, 0.9971), (64, 0.9971), (65, 0.9966),
+    (66, 0.9966), (67, 0.9966), (68, 0.9966), (69, 0.9966), (70, 0.9966),
+    (71, 0.9965), (72, 0.997), (73, 0.997), (74, 0.997), (75, 0.997),
+    (76, 0.997), (77, 0.997), (78, 0.997), (79, 0.9965), (80, 0.9964),
+    (81, 0.9964), (82, 0.9964), (83, 0.9964), (84, 0.9964), (85, 0.9964),
+    (86, 0.9969), (87, 0.9969), (88, 0.9969), (89, 0.9969), (90, 0.9968),
+    (91, 0.9968), (92, 0.9968), (93, 0.9968), (94, 0.9968), (95, 0.9968),
+    (96, 0.9968), (97, 0.9968), (98, 0.9968), (99, 0.9968), (100, 0.9962),
+    (101, 0.9962), (102, 0.9962), (103, 0.9962), (104, 0.9961), (105, 0.9961),
+    (106, 0.9961), (107, 0.9967), (108, 0.9966), (109, 0.9966), (110, 0.9966),
+    (111, 0.9966), (112, 0.9966), (113, 0.9966), (114, 0.9966), (115, 0.9966),
+    (116, 0.9965), (117, 0.9965), (118, 0.9965), (119, 0.9965), (120, 0.9965),
+    (121, 0.9959), (122, 0.9959), (123, 0.9959), (124, 0.9959), (125, 0.9958),
+    (126, 0.9958), (127, 0.9958), (128, 0.9964), (129, 0.9964), (130, 0.9964),
+    (131, 0.9963), (132, 0.9963), (133, 0.9963), (134, 0.9963), (135, 0.9963),
+    (136, 0.9963), (137, 0.9963), (138, 0.9962), (139, 0.9962), (140, 0.9962),
+    (141, 0.9962), (142, 0.9962), (143, 0.9962), (144, 0.9962), (145, 0.9961),
+    (146, 0.9961), (147, 0.9961), (148, 0.9961), (149, 0.9961), (150, 0.9961),
+    (151, 0.9961), (152, 0.996), (153, 0.996), (154, 0.996), (155, 0.996),
+    (156, 0.9953), (157, 0.9953), (158, 0.9953), (159, 0.9952), (160, 0.9952),
+    (161, 0.9952), (162, 0.9952), (163, 0.9958), (164, 0.9958), (165, 0.9958),
+    (166, 0.9958), (167, 0.9958), (168, 0.9958), (169, 0.9957), (170, 0.9957),
+    (171, 0.9957), (172, 0.9957), (173, 0.9957), (174, 0.9956), (175, 0.9956),
+    (176, 0.9956), (177, 0.9956), (178, 0.9956), (179, 0.9955), (180, 0.9955),
+    (181, 0.9955), (182, 0.9955), (183, 0.9955), (184, 0.9954), (185, 0.9954),
+    (186, 0.9954), (187, 0.9954), (188, 0.9954), (189, 0.9953), (190, 0.9953),
+    (191, 0.9953), (192, 0.9953), (193, 0.9952), (194, 0.9952), (195, 0.9952),
+    (196, 0.9952), (197, 0.9952), (198, 0.9951), (199, 0.9951), (200, 0.9951),
+    (201, 0.9951), (202, 0.995), (203, 0.995), (204, 0.995), (205, 0.995),
+    (206, 0.9949), (207, 0.9949), (208, 0.9949), (209, 0.9949), (210, 0.9948),
+    (211, 0.9948), (212, 0.9948), (213, 0.9947), (214, 0.9947), (215, 0.9947),
+    (216, 0.9947), (217, 0.9946), (218, 0.9946), (219, 0.9955), (220, 0.9955),
+    (221, 0.9954), (222, 0.9954), (223, 0.9954), (224, 0.9954), (225, 0.9954),
+    (226, 0.9944), (227, 0.9944), (228, 0.9943), (229, 0.9943), (230, 0.9943),
+    (231, 0.9942), (232, 0.9942), (233, 0.9942), (234, 0.9941), (235, 0.9941),
+    (236, 0.9941), (237, 0.994), (238, 0.994), (239, 0.994), (240, 0.9939),
+    (241, 0.9939), (242, 0.9938), (243, 0.9938), (244, 0.9938), (245, 0.9937),
+    (246, 0.9937), (247, 0.9937), (248, 0.9936), (249, 0.9936), (250, 0.9935),
+    (251, 0.9935), (252, 0.9934), (253, 0.9934), (254, 0.9945), (255, 0.9944),
+    (256, 0.9944), (257, 0.9944), (258, 0.9943), (259, 0.9943), (260, 0.9943),
+    (261, 0.9931), (262, 0.993), (263, 0.993), (264, 0.9929), (265, 0.9929),
+    (266, 0.9928), (267, 0.9928), (268, 0.9939), (269, 0.9939), (270, 0.9939),
+    (271, 0.9938), (272, 0.9938), (273, 0.9938), (274, 0.9937), (275, 0.9924),
+    (276, 0.9924), (277, 0.9923), (278, 0.9922), (279, 0.9922), (280, 0.9921),
+    (281, 0.9921), (282, 0.992), (283, 0.9919), (284, 0.9919), (285, 0.9918),
+    (286, 0.9917), (287, 0.9917), (288, 0.9916), (289, 0.9929), (290, 0.9929),
+    (291, 0.9928), (292, 0.9928), (293, 0.9927), (294, 0.9927), (295, 0.9926),
+    (296, 0.9911), (297, 0.991), (298, 0.9909), (299, 0.9908), (300, 0.9907),
+    (301, 0.9907), (302, 0.9906), (303, 0.9921), (304, 0.992), (305, 0.9919),
+    (306, 0.9919), (307, 0.9918), (308, 0.9917), (309, 0.9917), (310, 0.9916),
+    (311, 0.9915), (312, 0.9915), (313, 0.9914), (314, 0.9913), (315, 0.9912),
+    (316, 0.9912), (317, 0.9893), (318, 0.9892), (319, 0.9891), (320, 0.9889),
+    (321, 0.9888), (322, 0.9887), (323, 0.9885), (324, 0.9903), (325, 0.9903),
+    (326, 0.9902), (327, 0.9901), (328, 0.99), (329, 0.9899), (330, 0.9898),
+    (331, 0.9896), (332, 0.9895), (333, 0.9894), (334, 0.9893), (335, 0.9892),
+    (336, 0.9891), (337, 0.989), (338, 0.9888), (339, 0.9887), (340, 0.9886),
+    (341, 0.9885), (342, 0.9883), (343, 0.9882), (344, 0.988), (345, 0.9855),
+    (346, 0.9853), (347, 0.985), (348, 0.9848), (349, 0.9846), (350, 0.9843),
+    (351, 0.9841), (352, 0.9865), (353, 0.9863), (354, 0.9861), (355, 0.986),
+    (356, 0.9858), (357, 0.9855), (358, 0.9853), (359, 0.9851), (360, 0.9849),
+    (361, 0.9847), (362, 0.9844), (363, 0.9842), (364, 0.9839), (365, 0.9837),
+    (366, 0.9834), (367, 0.9831), (368, 0.9828), (369, 0.9825), (370, 0.9822),
+    (371, 0.9819), (372, 0.9815), (373, 0.9812), (374, 0.9808), (375, 0.9805),
+    (376, 0.9801), (377, 0.9797), (378, 0.9793), (379, 0.9788), (380, 0.9784),
+    (381, 0.9779), (382, 0.9774), (383, 0.9769), (384, 0.9763), (385, 0.9757),
+    (386, 0.9751), (387, 0.9745), (388, 0.9738), (389, 0.9731), (390, 0.9724),
+    (391, 0.9716), (392, 0.9708), (393, 0.9699), (394, 0.9752), (395, 0.9745),
+    (396, 0.9739), (397, 0.9732), (398, 0.9724), (399, 0.9716), (400, 0.9708),
+    (401, 0.9624), (402, 0.9609), (403, 0.9593), (404, 0.9576), (405, 0.9558),
+    (406, 0.9537), (407, 0.9515), (408, 0.949), (409, 0.9462), (410, 0.9432),
+    (411, 0.9398), (412, 0.9359), (413, 0.9315), (414, 0.9265), (415, 0.9206),
+    (416, 0.9138), (417, 0.9057), (418, 0.8958), (419, 0.8837), (420, 0.8684),
+    (421, 0.8485), (422, 0.8571), (423, 0.8333), (424, 0.8), (425, 0.75),
+    (426, 0.6667), (427, 0.5), (428, 0)
+) AS v(day, mult)
+JOIN LATERAL (
+    SELECT DISTINCT ON (day) house_type, day, standard_week
+    FROM house_depreciation_standards
+    WHERE project_flock_ids IS NULL
+      AND house_type = 'open_house'::house_type_enum
+      AND day = v.day
+    ORDER BY day, effective_date DESC NULLS LAST
+) g ON TRUE;
+
+-- Recompute snapshot depresiasi untuk semua flock yang dipetakan.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (5);

internal/database/migrations/20260604043209_seed_house_depreciation_flocks_6.down.sql

@@ -0,0 +1,8 @@
+-- Hapus baris kurva custom dari house_depreciation_standards.
+-- Exact match pada array (IDs di-sort, sama persis dengan yang di-insert).
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[6]::bigint[]
+  AND effective_date = DATE '2026-06-03';
+
+-- Recompute snapshot depresiasi.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (6);

internal/database/migrations/20260604043209_seed_house_depreciation_flocks_6.up.sql

@@ -0,0 +1,129 @@
+-- Kurva depresiasi khusus flock 6 (house_types=open_house, effective_date=2026-06-03).
+-- Override hanya multiplication_percentage; house_type & standard_week diwarisi dari baris global.
+-- depreciation_percent diturunkan = (1 - multiplication_percentage) * 100.
+-- Lookup engine: ? = ANY(project_flock_ids) — satu baris dipakai semua flock.
+
+-- Hapus custom curve untuk array ini agar INSERT idempoten.
+DELETE FROM house_depreciation_standards
+WHERE project_flock_ids = ARRAY[6]::bigint[]
+  AND house_type = 'open_house'::house_type_enum
+  AND effective_date = DATE '2026-06-03';
+
+-- house_type: open_house
+INSERT INTO house_depreciation_standards
+    (project_flock_ids, house_type, day, effective_date,
+     multiplication_percentage, depreciation_percent, standard_week, name)
+SELECT
+    ARRAY[6]::bigint[], g.house_type, g.day, DATE '2026-06-03',
+    v.mult, (1 - v.mult) * 100, g.standard_week,
+    'Custom flocks 6 (eff 2026-06-03)'
+FROM (VALUES
+    (1, 0.9979::numeric), (2, 0.9979), (3, 0.9979), (4, 0.9979), (5, 0.9979),
+    (6, 0.9975), (7, 0.9975), (8, 0.9975), (9, 0.9975), (10, 0.9975),
+    (11, 0.9975), (12, 0.9975), (13, 0.9975), (14, 0.9975), (15, 0.9974),
+    (16, 0.9974), (17, 0.9974), (18, 0.9974), (19, 0.9974), (20, 0.9974),
+    (21, 0.9974), (22, 0.9974), (23, 0.9974), (24, 0.9974), (25, 0.9974),
+    (26, 0.9974), (27, 0.9977), (28, 0.9977), (29, 0.9977), (30, 0.9977),
+    (31, 0.9977), (32, 0.9977), (33, 0.9977), (34, 0.9973), (35, 0.9973),
+    (36, 0.9973), (37, 0.9973), (38, 0.9973), (39, 0.9973), (40, 0.9973),
+    (41, 0.9973), (42, 0.9973), (43, 0.9973), (44, 0.9973), (45, 0.9972),
+    (46, 0.9972), (47, 0.9972), (48, 0.9976), (49, 0.9976), (50, 0.9976),
+    (51, 0.9976), (52, 0.9976), (53, 0.9976), (54, 0.9976), (55, 0.9972),
+    (56, 0.9972), (57, 0.9972), (58, 0.9972), (59, 0.9971), (60, 0.9971),
+    (61, 0.9971), (62, 0.9975), (63, 0.9975), (64, 0.9975), (65, 0.9975),
+    (66, 0.9975), (67, 0.9975), (68, 0.9975), (69, 0.9971), (70, 0.9971),
+    (71, 0.9971), (72, 0.997), (73, 0.997), (74, 0.997), (75, 0.997),
+    (76, 0.997), (77, 0.997), (78, 0.997), (79, 0.997), (80, 0.997),
+    (81, 0.997), (82, 0.997), (83, 0.9974), (84, 0.9974), (85, 0.9974),
+    (86, 0.9974), (87, 0.9974), (88, 0.9973), (89, 0.9973), (90, 0.9969),
+    (91, 0.9969), (92, 0.9969), (93, 0.9969), (94, 0.9968), (95, 0.9968),
+    (96, 0.9968), (97, 0.9973), (98, 0.9973), (99, 0.9973), (100, 0.9972),
+    (101, 0.9972), (102, 0.9972), (103, 0.9972), (104, 0.9968), (105, 0.9967),
+    (106, 0.9967), (107, 0.9967), (108, 0.9967), (109, 0.9967), (110, 0.9967),
+    (111, 0.9972), (112, 0.9971), (113, 0.9971), (114, 0.9971), (115, 0.9971),
+    (116, 0.9971), (117, 0.9971), (118, 0.9966), (119, 0.9966), (120, 0.9966),
+    (121, 0.9966), (122, 0.9966), (123, 0.9966), (124, 0.9965), (125, 0.997),
+    (126, 0.997), (127, 0.997), (128, 0.997), (129, 0.997), (130, 0.997),
+    (131, 0.997), (132, 0.9965), (133, 0.9964), (134, 0.9964), (135, 0.9964),
+    (136, 0.9964), (137, 0.9964), (138, 0.9964), (139, 0.9969), (140, 0.9969),
+    (141, 0.9969), (142, 0.9969), (143, 0.9968), (144, 0.9968), (145, 0.9968),
+    (146, 0.9968), (147, 0.9968), (148, 0.9968), (149, 0.9968), (150, 0.9968),
+    (151, 0.9968), (152, 0.9968), (153, 0.9962), (154, 0.9962), (155, 0.9962),
+    (156, 0.9962), (157, 0.9961), (158, 0.9961), (159, 0.9961), (160, 0.9967),
+    (161, 0.9966), (162, 0.9966), (163, 0.9966), (164, 0.9966), (165, 0.9966),
+    (166, 0.9966), (167, 0.9966), (168, 0.9966), (169, 0.9965), (170, 0.9965),
+    (171, 0.9965), (172, 0.9965), (173, 0.9965), (174, 0.9959), (175, 0.9959),
+    (176, 0.9959), (177, 0.9959), (178, 0.9958), (179, 0.9958), (180, 0.9958),
+    (181, 0.9964), (182, 0.9964), (183, 0.9964), (184, 0.9963), (185, 0.9963),
+    (186, 0.9963), (187, 0.9963), (188, 0.9963), (189, 0.9963), (190, 0.9963),
+    (191, 0.9962), (192, 0.9962), (193, 0.9962), (194, 0.9962), (195, 0.9962),
+    (196, 0.9962), (197, 0.9962), (198, 0.9961), (199, 0.9961), (200, 0.9961),
+    (201, 0.9961), (202, 0.9961), (203, 0.9961), (204, 0.9961), (205, 0.996),
+    (206, 0.996), (207, 0.996), (208, 0.996), (209, 0.9953), (210, 0.9953),
+    (211, 0.9953), (212, 0.9952), (213, 0.9952), (214, 0.9952), (215, 0.9952),
+    (216, 0.9958), (217, 0.9958), (218, 0.9958), (219, 0.9958), (220, 0.9958),
+    (221, 0.9958), (222, 0.9957), (223, 0.9957), (224, 0.9957), (225, 0.9957),
+    (226, 0.9957), (227, 0.9956), (228, 0.9956), (229, 0.9956), (230, 0.9956),
+    (231, 0.9956), (232, 0.9955), (233, 0.9955), (234, 0.9955), (235, 0.9955),
+    (236, 0.9955), (237, 0.9954), (238, 0.9954), (239, 0.9954), (240, 0.9954),
+    (241, 0.9954), (242, 0.9953), (243, 0.9953), (244, 0.9953), (245, 0.9953),
+    (246, 0.9952), (247, 0.9952), (248, 0.9952), (249, 0.9952), (250, 0.9952),
+    (251, 0.9951), (252, 0.9951), (253, 0.9951), (254, 0.9951), (255, 0.995),
+    (256, 0.995), (257, 0.995), (258, 0.995), (259, 0.9949), (260, 0.9949),
+    (261, 0.9949), (262, 0.9949), (263, 0.9948), (264, 0.9948), (265, 0.9948),
+    (266, 0.9947), (267, 0.9947), (268, 0.9947), (269, 0.9947), (270, 0.9946),
+    (271, 0.9946), (272, 0.9955), (273, 0.9955), (274, 0.9954), (275, 0.9954),
+    (276, 0.9954), (277, 0.9954), (278, 0.9954), (279, 0.9944), (280, 0.9944),
+    (281, 0.9943), (282, 0.9943), (283, 0.9943), (284, 0.9942), (285, 0.9942),
+    (286, 0.9942), (287, 0.9941), (288, 0.9941), (289, 0.9941), (290, 0.994),
+    (291, 0.994), (292, 0.994), (293, 0.9939), (294, 0.9939), (295, 0.9938),
+    (296, 0.9938), (297, 0.9938), (298, 0.9937), (299, 0.9937), (300, 0.9937),
+    (301, 0.9936), (302, 0.9936), (303, 0.9935), (304, 0.9935), (305, 0.9934),
+    (306, 0.9934), (307, 0.9945), (308, 0.9944), (309, 0.9944), (310, 0.9944),
+    (311, 0.9943), (312, 0.9943), (313, 0.9943), (314, 0.9931), (315, 0.993),
+    (316, 0.993), (317, 0.9929), (318, 0.9929), (319, 0.9928), (320, 0.9928),
+    (321, 0.9939), (322, 0.9939), (323, 0.9939), (324, 0.9938), (325, 0.9938),
+    (326, 0.9938), (327, 0.9937), (328, 0.9924), (329, 0.9924), (330, 0.9923),
+    (331, 0.9922), (332, 0.9922), (333, 0.9921), (334, 0.9921), (335, 0.992),
+    (336, 0.9919), (337, 0.9919), (338, 0.9918), (339, 0.9917), (340, 0.9917),
+    (341, 0.9916), (342, 0.9929), (343, 0.9929), (344, 0.9928), (345, 0.9928),
+    (346, 0.9927), (347, 0.9927), (348, 0.9926), (349, 0.9911), (350, 0.991),
+    (351, 0.9909), (352, 0.9908), (353, 0.9907), (354, 0.9907), (355, 0.9906),
+    (356, 0.9921), (357, 0.992), (358, 0.9919), (359, 0.9919), (360, 0.9918),
+    (361, 0.9917), (362, 0.9917), (363, 0.9916), (364, 0.9915), (365, 0.9915),
+    (366, 0.9914), (367, 0.9913), (368, 0.9912), (369, 0.9912), (370, 0.9893),
+    (371, 0.9892), (372, 0.9891), (373, 0.9889), (374, 0.9888), (375, 0.9887),
+    (376, 0.9885), (377, 0.9903), (378, 0.9903), (379, 0.9902), (380, 0.9901),
+    (381, 0.99), (382, 0.9899), (383, 0.9898), (384, 0.9896), (385, 0.9895),
+    (386, 0.9894), (387, 0.9893), (388, 0.9892), (389, 0.9891), (390, 0.989),
+    (391, 0.9888), (392, 0.9887), (393, 0.9886), (394, 0.9885), (395, 0.9883),
+    (396, 0.9882), (397, 0.988), (398, 0.9855), (399, 0.9853), (400, 0.985),
+    (401, 0.9848), (402, 0.9846), (403, 0.9843), (404, 0.9841), (405, 0.9865),
+    (406, 0.9863), (407, 0.9861), (408, 0.986), (409, 0.9858), (410, 0.9855),
+    (411, 0.9853), (412, 0.9851), (413, 0.9849), (414, 0.9847), (415, 0.9844),
+    (416, 0.9842), (417, 0.9839), (418, 0.9837), (419, 0.9834), (420, 0.9831),
+    (421, 0.9828), (422, 0.9825), (423, 0.9822), (424, 0.9819), (425, 0.9815),
+    (426, 0.9812), (427, 0.9808), (428, 0.9805), (429, 0.9801), (430, 0.9797),
+    (431, 0.9793), (432, 0.9788), (433, 0.9784), (434, 0.9779), (435, 0.9774),
+    (436, 0.9769), (437, 0.9763), (438, 0.9757), (439, 0.9751), (440, 0.9745),
+    (441, 0.9738), (442, 0.9731), (443, 0.9724), (444, 0.9716), (445, 0.9708),
+    (446, 0.9699), (447, 0.9752), (448, 0.9745), (449, 0.9739), (450, 0.9732),
+    (451, 0.9724), (452, 0.9716), (453, 0.9708), (454, 0.9624), (455, 0.9609),
+    (456, 0.9593), (457, 0.9576), (458, 0.9558), (459, 0.9537), (460, 0.9515),
+    (461, 0.949), (462, 0.9462), (463, 0.9432), (464, 0.9398), (465, 0.9359),
+    (466, 0.9315), (467, 0.9265), (468, 0.9206), (469, 0.9138), (470, 0.9057),
+    (471, 0.8958), (472, 0.8837), (473, 0.8684), (474, 0.8485), (475, 0.8571),
+    (476, 0.8333), (477, 0.8), (478, 0.75), (479, 0.6667), (480, 0.5),
+    (481, 0)
+) AS v(day, mult)
+JOIN LATERAL (
+    SELECT DISTINCT ON (day) house_type, day, standard_week
+    FROM house_depreciation_standards
+    WHERE project_flock_ids IS NULL
+      AND house_type = 'open_house'::house_type_enum
+      AND day = v.day
+    ORDER BY day, effective_date DESC NULLS LAST
+) g ON TRUE;
+
+-- Recompute snapshot depresiasi untuk semua flock yang dipetakan.
+DELETE FROM farm_depreciation_snapshots WHERE project_flock_id IN (6);

internal/modules/production/chickins/controllers/chickin.controller.go

@@ -172,6 +172,23 @@ func (u *ChickinController) DeleteOne(c *fiber.Ctx) error {
 		})
 }
 
+func (u *ChickinController) UpdateChickInDate(c *fiber.Ctx) error {
+	req := new(validation.UpdateChickInDate)
+	if err := c.BodyParser(req); err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid request body")
+	}
+
+	if err := u.ChickinService.UpdateChickInDate(c, req); err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).JSON(response.Common{
+		Code:    fiber.StatusOK,
+		Status:  "success",
+		Message: "Chick in date berhasil diperbarui",
+	})
+}
+
 func (u *ChickinController) Approval(c *fiber.Ctx) error {
 	req := new(validation.Approve)
 

internal/modules/production/chickins/repositories/project_chickin.repository.go

@@ -2,6 +2,7 @@ package repository
 
 import (
 	"context"
+	"time"
 
 	"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
@@ -18,6 +19,7 @@ type ProjectChickinRepository interface {
 	GetTotalChickinQtyByProjectFlockID(ctx context.Context, projectFlockID uint) (float64, error)
 	GetByProjectFlockKandangIDForUpdate(ctx context.Context, projectFlockKandangID uint) ([]entity.ProjectChickin, error)
 	UpdateUsageFields(ctx context.Context, tx *gorm.DB, chickinID uint, usageQty, pendingUsageQty float64) error
+	UpdateChickInDateByProjectFlockKandangID(ctx context.Context, tx *gorm.DB, pfkID uint, newDate time.Time) error
 }
 
 type ChickinRepositoryImpl struct {
@@ -134,3 +136,10 @@ func (r *ChickinRepositoryImpl) UpdateUsageFields(ctx context.Context, tx *gorm.
 			"pending_usage_qty": pendingUsageQty,
 		}).Error
 }
+
+func (r *ChickinRepositoryImpl) UpdateChickInDateByProjectFlockKandangID(ctx context.Context, tx *gorm.DB, pfkID uint, newDate time.Time) error {
+	return tx.WithContext(ctx).
+		Model(&entity.ProjectChickin{}).
+		Where("project_flock_kandang_id = ? AND deleted_at IS NULL", pfkID).
+		Update("chick_in_date", newDate).Error
+}

internal/modules/production/chickins/route.go

@@ -17,8 +17,9 @@ func ChickinRoutes(v1 fiber.Router, u user.UserService, s chickin.ChickinService
 
 	route.Get("/", m.RequirePermissions(m.P_ChickinsGetAll), ctrl.GetAll)
 	route.Post("/", m.RequirePermissions(m.P_ChickinsCreateOne), ctrl.CreateOne)
-	route.Get("/:id",m.RequirePermissions(m.P_ChickinsGetOne), ctrl.GetOne)
+	route.Patch("/chick-in-date", m.RequirePermissions(m.P_ChickinsCreateOne), ctrl.UpdateChickInDate)
+	route.Get("/:id", m.RequirePermissions(m.P_ChickinsGetOne), ctrl.GetOne)
 	// route.Patch("/:id", ctrl.UpdateOne)
 	route.Delete("/:id", ctrl.DeleteOne)
-	route.Post("/approvals",m.RequirePermissions(m.P_ChickinsApproval), ctrl.Approval)
+	route.Post("/approvals", m.RequirePermissions(m.P_ChickinsApproval), ctrl.Approval)
 }

internal/modules/production/chickins/services/chickin.service.go

@@ -48,6 +48,7 @@ type ChickinService interface {
 	DeleteOne(ctx *fiber.Ctx, id uint) error
 	Approval(ctx *fiber.Ctx, req *validation.Approve) ([]entity.ProjectChickin, error)
 	EnsureChickInExists(ctx context.Context, projectFlockKandangID uint) error
+	UpdateChickInDate(ctx *fiber.Ctx, req *validation.UpdateChickInDate) error
 }
 
 type chickinService struct {
@@ -2110,3 +2111,33 @@ func (s chickinService) EnsureChickInExists(ctx context.Context, projectFlockKan
 
 	return fiber.NewError(fiber.StatusBadRequest, "Chick in project flock belum disetujui sehingga belum dapat membuat recording")
 }
+
+func (s chickinService) UpdateChickInDate(ctx *fiber.Ctx, req *validation.UpdateChickInDate) error {
+	if err := s.Validate.Struct(req); err != nil {
+		return err
+	}
+
+	newDate, err := time.Parse("2006-01-02", req.ChickInDate)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Format tanggal tidak valid, gunakan YYYY-MM-DD")
+	}
+
+	_, err = s.ProjectflockKandangRepo.GetByID(ctx.Context(), req.ProjectFlockKandangId)
+	if err != nil {
+		return fiber.NewError(fiber.StatusNotFound, "Project flock kandang tidak ditemukan")
+	}
+
+	return s.Repository.DB().WithContext(ctx.Context()).Transaction(func(tx *gorm.DB) error {
+		if err := s.Repository.UpdateChickInDateByProjectFlockKandangID(ctx.Context(), tx, req.ProjectFlockKandangId, newDate); err != nil {
+			return err
+		}
+
+		return tx.Exec(`
+			UPDATE recordings
+			SET day = GREATEST(0, (record_datetime::date - ?::date)::int),
+			    updated_at = NOW()
+			WHERE project_flock_kandangs_id = ?
+			  AND deleted_at IS NULL
+		`, req.ChickInDate, req.ProjectFlockKandangId).Error
+	})
+}

internal/modules/production/chickins/validations/chickin.validation.go

@@ -27,3 +27,8 @@ type Approve struct {
 	ApprovableIds []uint  `json:"approvable_ids" validate:"required_strict,min=1,dive,gt=0"`
 	Notes         *string `json:"notes,omitempty" validate:"omitempty,max=500"`
 }
+
+type UpdateChickInDate struct {
+	ProjectFlockKandangId uint   `json:"project_flock_kandang_id" validate:"required,gt=0"`
+	ChickInDate           string `json:"chick_in_date" validate:"required,datetime=2006-01-02"`
+}

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

@@ -51,7 +51,7 @@ type ExpenseDepreciationRepository interface {
 	DeleteSnapshotsFromDate(ctx context.Context, fromDate time.Time, farmIDs []uint) error
 	DeleteSnapshotsByFarmIDs(ctx context.Context, farmIDs []uint) error
 	GetLatestTransferInputsByFarms(ctx context.Context, period time.Time, farmIDs []uint) ([]FarmDepreciationLatestTransferRow, error)
-	GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, map[string]*time.Time, error)
+	GetMultiplicationPercentages(ctx context.Context, houseTypes []string, maxDay int, projectFlockID uint) (map[string]map[int]float64, map[string]*time.Time, error)
 	GetLatestManualInputsByFarms(ctx context.Context, areaIDs, locationIDs, projectFlockIDs []int64) ([]FarmDepreciationManualInputRow, error)
 	UpsertManualInput(ctx context.Context, row *entity.FarmDepreciationManualInput) error
 	DB() *gorm.DB
@@ -245,6 +245,7 @@ func (r *expenseDepreciationRepository) GetMultiplicationPercentages(
 	ctx context.Context,
 	houseTypes []string,
 	maxDay int,
+	projectFlockID uint,
 ) (map[string]map[int]float64, map[string]*time.Time, error) {
 	result := make(map[string]map[int]float64)
 	effectiveDates := make(map[string]*time.Time)
@@ -258,8 +259,9 @@ func (r *expenseDepreciationRepository) GetMultiplicationPercentages(
 			house_type::text AS house_type, day, multiplication_percentage, effective_date
 		FROM house_depreciation_standards
 		WHERE house_type::text IN ? AND day <= ?
-		ORDER BY house_type, day, effective_date DESC NULLS LAST
+			AND (project_flock_ids IS NULL OR ? = ANY(project_flock_ids))
-	`, houseTypes, maxDay).Scan(&rows).Error; err != nil {
+		ORDER BY house_type, day, (project_flock_ids IS NOT NULL) DESC, effective_date DESC NULLS LAST
+	`, houseTypes, maxDay, projectFlockID).Scan(&rows).Error; err != nil {
 		return nil, nil, err
 	}