diff --git a/cmd/seed-house-depreciation-standards/main.go b/cmd/seed-house-depreciation-standards/main.go new file mode 100644 index 00000000..35091f0d --- /dev/null +++ b/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" +} diff --git a/cmd/seed-house-depreciation-standards/main_test.go b/cmd/seed-house-depreciation-standards/main_test.go new file mode 100644 index 00000000..c183ad26 --- /dev/null +++ b/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) + } +} diff --git a/internal/common/repository/common.hppv2.repository.go b/internal/common/repository/common.hppv2.repository.go index 787599e5..a25ebf70 100644 --- a/internal/common/repository/common.hppv2.repository.go +++ b/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 - `, houseTypes, maxDay).Scan(&rows).Error + AND (project_flock_ids IS NULL OR ? = ANY(project_flock_ids)) + 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 } diff --git a/internal/common/service/common.hppv2.service.go b/internal/common/service/common.hppv2.service.go index 5b32e446..d132cb14 100644 --- a/internal/common/service/common.hppv2.service.go +++ b/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) - if reportScheduleDay <= 0 { - return nil, nil - } - + // Hitung schedule day relatif terhadap cutover_date, bukan dari chick_in_date. + // Ini menangani kasus cut-over flock yang belum 175 hari pada period date, + // 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 } diff --git a/internal/common/service/common.hppv2.service_test.go b/internal/common/service/common.hppv2.service_test.go index 346af535..5cbf0523 100644 --- a/internal/common/service/common.hppv2.service_test.go +++ b/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 } diff --git a/internal/database/migrations/20260603031237_block_marketing_overconsume_telur.down.sql b/internal/database/migrations/20260603031237_block_marketing_overconsume_telur.down.sql new file mode 100644 index 00000000..d3d685cd --- /dev/null +++ b/internal/database/migrations/20260603031237_block_marketing_overconsume_telur.down.sql @@ -0,0 +1,17 @@ +BEGIN; + +-- Revert the TELUR / TELUR_GRADE marketing over-sell block. Removing these rows +-- makes resolveOverConsume() fall back to the default allow rule again (the +-- post-20260313061525 behaviour). The reasons are unique to this migration, so +-- the DELETE only touches rows created here. + +DELETE FROM fifo_stock_v2_overconsume_rules +WHERE lane = 'USABLE' + AND function_code = 'MARKETING_OUT' + AND flag_group_code IN ('TELUR', 'TELUR_GRADE') + AND reason IN ( + 'fifo_v2_exception_marketing_block_telur', + 'fifo_v2_exception_marketing_block_telur_grade' + ); + +COMMIT; diff --git a/internal/database/migrations/20260603031237_block_marketing_overconsume_telur.up.sql b/internal/database/migrations/20260603031237_block_marketing_overconsume_telur.up.sql new file mode 100644 index 00000000..870fde89 --- /dev/null +++ b/internal/database/migrations/20260603031237_block_marketing_overconsume_telur.up.sql @@ -0,0 +1,54 @@ +BEGIN; + +-- Restore the marketing over-sell block for TELUR and TELUR_GRADE only. +-- +-- Migration 20260313061525 narrowed the MARKETING_OUT over-sell block to +-- flag_group_code='AYAM' and deactivated the global rule. That left TELUR / +-- TELUR_GRADE with no matching block, so resolveOverConsume() fell back to the +-- default rule 'fifo_v2_default_allow' (allow_overconsume=TRUE) and egg +-- Delivery Orders could over-sell silently into marketing_delivery_products.pending_qty. +-- +-- These rules make resolveOverConsume('TELUR'|'TELUR_GRADE','MARKETING_OUT') = FALSE, +-- so an egg DO that exceeds available stock is REJECTED (ErrInsufficientStock) +-- instead of being recorded as pending. Scope is "Telur saja" — AYAM and +-- transfer behaviour are intentionally left unchanged. +-- +-- NOTE: run the total_used reconciliation (cmd/reconcile-fifo-total-used) BEFORE +-- applying this in production. Enabling the block while phantom total_used still +-- inflates consumption would reject otherwise-valid egg orders. + +INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active) +SELECT 'TELUR', 'MARKETING_OUT', 'USABLE', FALSE, 20, 'fifo_v2_exception_marketing_block_telur', TRUE +WHERE NOT EXISTS ( + SELECT 1 FROM fifo_stock_v2_overconsume_rules + WHERE lane = 'USABLE' + AND function_code = 'MARKETING_OUT' + AND flag_group_code = 'TELUR' + AND reason = 'fifo_v2_exception_marketing_block_telur' +); + +UPDATE fifo_stock_v2_overconsume_rules +SET allow_overconsume = FALSE, priority = 20, is_active = TRUE +WHERE lane = 'USABLE' + AND function_code = 'MARKETING_OUT' + AND flag_group_code = 'TELUR' + AND reason = 'fifo_v2_exception_marketing_block_telur'; + +INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active) +SELECT 'TELUR_GRADE', 'MARKETING_OUT', 'USABLE', FALSE, 20, 'fifo_v2_exception_marketing_block_telur_grade', TRUE +WHERE NOT EXISTS ( + SELECT 1 FROM fifo_stock_v2_overconsume_rules + WHERE lane = 'USABLE' + AND function_code = 'MARKETING_OUT' + AND flag_group_code = 'TELUR_GRADE' + AND reason = 'fifo_v2_exception_marketing_block_telur_grade' +); + +UPDATE fifo_stock_v2_overconsume_rules +SET allow_overconsume = FALSE, priority = 20, is_active = TRUE +WHERE lane = 'USABLE' + AND function_code = 'MARKETING_OUT' + AND flag_group_code = 'TELUR_GRADE' + AND reason = 'fifo_v2_exception_marketing_block_telur_grade'; + +COMMIT; diff --git a/internal/database/migrations/20260604041616_add_project_flock_id_to_house_depreciation_standards.down.sql b/internal/database/migrations/20260604041616_add_project_flock_id_to_house_depreciation_standards.down.sql new file mode 100644 index 00000000..20ac4ef1 --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604041616_add_project_flock_id_to_house_depreciation_standards.up.sql b/internal/database/migrations/20260604041616_add_project_flock_id_to_house_depreciation_standards.up.sql new file mode 100644 index 00000000..a74f7282 --- /dev/null +++ b/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; diff --git a/internal/database/migrations/20260604041658_update_farm_depreciation_manual_inputs.down.sql b/internal/database/migrations/20260604041658_update_farm_depreciation_manual_inputs.down.sql new file mode 100644 index 00000000..48e4ff1a --- /dev/null +++ b/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; diff --git a/internal/database/migrations/20260604041658_update_farm_depreciation_manual_inputs.up.sql b/internal/database/migrations/20260604041658_update_farm_depreciation_manual_inputs.up.sql new file mode 100644 index 00000000..24a72a2e --- /dev/null +++ b/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; diff --git a/internal/database/migrations/20260604041743_fix_hds_custom_unique_per_flock.down.sql b/internal/database/migrations/20260604041743_fix_hds_custom_unique_per_flock.down.sql new file mode 100644 index 00000000..dd4dface --- /dev/null +++ b/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; diff --git a/internal/database/migrations/20260604041743_fix_hds_custom_unique_per_flock.up.sql b/internal/database/migrations/20260604041743_fix_hds_custom_unique_per_flock.up.sql new file mode 100644 index 00000000..c0310ceb --- /dev/null +++ b/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; diff --git a/internal/database/migrations/20260604041941_seed_house_depreciation_flocks_8_13_17.down.sql b/internal/database/migrations/20260604041941_seed_house_depreciation_flocks_8_13_17.down.sql new file mode 100644 index 00000000..b90ef3d8 --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604041941_seed_house_depreciation_flocks_8_13_17.up.sql b/internal/database/migrations/20260604041941_seed_house_depreciation_flocks_8_13_17.up.sql new file mode 100644 index 00000000..6af1fd3b --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604042051_seed_house_depreciation_flocks_18.down.sql b/internal/database/migrations/20260604042051_seed_house_depreciation_flocks_18.down.sql new file mode 100644 index 00000000..bbed3dc3 --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604042051_seed_house_depreciation_flocks_18.up.sql b/internal/database/migrations/20260604042051_seed_house_depreciation_flocks_18.up.sql new file mode 100644 index 00000000..79a1f191 --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604042912_seed_house_depreciation_flocks_26.down.sql b/internal/database/migrations/20260604042912_seed_house_depreciation_flocks_26.down.sql new file mode 100644 index 00000000..15d88022 --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604042912_seed_house_depreciation_flocks_26.up.sql b/internal/database/migrations/20260604042912_seed_house_depreciation_flocks_26.up.sql new file mode 100644 index 00000000..0ca7d389 --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604043007_seed_house_depreciation_flocks_20.down.sql b/internal/database/migrations/20260604043007_seed_house_depreciation_flocks_20.down.sql new file mode 100644 index 00000000..d9a5c898 --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604043007_seed_house_depreciation_flocks_20.up.sql b/internal/database/migrations/20260604043007_seed_house_depreciation_flocks_20.up.sql new file mode 100644 index 00000000..fb37bff4 --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604043052_seed_house_depreciation_flocks_4.down.sql b/internal/database/migrations/20260604043052_seed_house_depreciation_flocks_4.down.sql new file mode 100644 index 00000000..7217b088 --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604043052_seed_house_depreciation_flocks_4.up.sql b/internal/database/migrations/20260604043052_seed_house_depreciation_flocks_4.up.sql new file mode 100644 index 00000000..7f799cac --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604043132_seed_house_depreciation_flocks_5.down.sql b/internal/database/migrations/20260604043132_seed_house_depreciation_flocks_5.down.sql new file mode 100644 index 00000000..2ab2bfc6 --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604043132_seed_house_depreciation_flocks_5.up.sql b/internal/database/migrations/20260604043132_seed_house_depreciation_flocks_5.up.sql new file mode 100644 index 00000000..e45312cc --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604043209_seed_house_depreciation_flocks_6.down.sql b/internal/database/migrations/20260604043209_seed_house_depreciation_flocks_6.down.sql new file mode 100644 index 00000000..0562674f --- /dev/null +++ b/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); diff --git a/internal/database/migrations/20260604043209_seed_house_depreciation_flocks_6.up.sql b/internal/database/migrations/20260604043209_seed_house_depreciation_flocks_6.up.sql new file mode 100644 index 00000000..ae57a387 --- /dev/null +++ b/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); diff --git a/internal/modules/marketing/controllers/deliveryorder.controller.go b/internal/modules/marketing/controllers/deliveryorder.controller.go index 208d8b48..1b1b1d41 100644 --- a/internal/modules/marketing/controllers/deliveryorder.controller.go +++ b/internal/modules/marketing/controllers/deliveryorder.controller.go @@ -75,6 +75,9 @@ func (u *DeliveryOrdersController) GetAll(c *fiber.Ctx) error { WarehouseID: uint(c.QueryInt("warehouse_id", 0)), SortBy: sortBy, SortOrder: sortOrder, + StartDate: strings.TrimSpace(c.Query("start_date", "")), + EndDate: strings.TrimSpace(c.Query("end_date", "")), + FilterBy: strings.TrimSpace(c.Query("filter_by", "")), } if isAllExcelExportRequest(c) { diff --git a/internal/modules/marketing/controllers/deliveryorder.export.go b/internal/modules/marketing/controllers/deliveryorder.export.go index 7dc20a64..b2fd72eb 100644 --- a/internal/modules/marketing/controllers/deliveryorder.export.go +++ b/internal/modules/marketing/controllers/deliveryorder.export.go @@ -201,11 +201,6 @@ func setMarketingExportRows(file *excelize.File, sheet string, items []dto.Marke for _, group := range item.DeliveryOrder { doNumber := safeMarketingExportText(group.DoNumber) - doDate := "-" - if group.DeliveryDate != nil { - doDate = formatMarketingExportDate(*group.DeliveryDate) - } - gudang := "-" if group.Warehouse != nil { gudang = safeMarketingExportText(group.Warehouse.Name) @@ -215,7 +210,7 @@ func setMarketingExportRows(file *excelize.File, sheet string, items []dto.Marke row++ r := strconv.Itoa(row) vals := map[string]interface{}{ - "A": doNumber, "B": doDate, "C": status, "D": customer, "E": salesPerson, + "A": doNumber, "B": soDate, "C": status, "D": customer, "E": salesPerson, "F": "-", "G": "-", "H": gudang, "I": "-", "J": "-", "K": "-", "L": "-", "M": "-", "N": "-", "O": "-", "P": grandTotal, "Q": notes, @@ -251,7 +246,7 @@ func setMarketingExportRows(file *excelize.File, sheet string, items []dto.Marke if err := file.SetCellValue(sheet, "A"+r, doNumber); err != nil { return err } - if err := file.SetCellValue(sheet, "B"+r, doDate); err != nil { + if err := file.SetCellValue(sheet, "B"+r, soDate); err != nil { return err } if err := file.SetCellValue(sheet, "C"+r, status); err != nil { @@ -347,7 +342,7 @@ func setMarketingExportRows(file *excelize.File, sheet string, items []dto.Marke } gudang := "-" - if prod.ProductWarehouse != nil { + if prod.ProductWarehouse != nil && prod.ProductWarehouse.Warehouse != nil { gudang = safeMarketingExportText(prod.ProductWarehouse.Warehouse.Name) } diff --git a/internal/modules/marketing/controllers/deliveryorder.export_test.go b/internal/modules/marketing/controllers/deliveryorder.export_test.go index d41a3f6e..b73b891e 100644 --- a/internal/modules/marketing/controllers/deliveryorder.export_test.go +++ b/internal/modules/marketing/controllers/deliveryorder.export_test.go @@ -15,6 +15,10 @@ import ( ) func TestBuildMarketingExportWorkbookHeadersAndRows(t *testing.T) { + // DO item has soDate=2026-05-31 and deliveryDate=2026-06-01 to verify + // the export uses soDate (not deliveryDate) in column B. + deliveryDate := time.Date(2026, time.June, 1, 0, 0, 0, 0, time.UTC) + items := []dto.MarketingListDTO{ { MarketingRelationDTO: dto.MarketingRelationDTO{ @@ -51,6 +55,22 @@ func TestBuildMarketingExportWorkbookHeadersAndRows(t *testing.T) { Action: strPtr("REJECTED"), }, }, + { + MarketingRelationDTO: dto.MarketingRelationDTO{ + SoNumber: "SO-00760", + SoDate: time.Date(2026, time.May, 31, 0, 0, 0, 0, time.UTC), + }, + Customer: customerDTO.CustomerRelationDTO{Name: "CORDELA"}, + DeliveryOrder: []dto.DeliveryGroupDTO{ + { + DoNumber: "DO-01954", + DeliveryDate: &deliveryDate, + }, + }, + LatestApproval: approvalDTO.ApprovalRelationDTO{ + StepName: "Delivery Order", + }, + }, } content, err := buildMarketingExportWorkbook(items) @@ -69,9 +89,10 @@ func TestBuildMarketingExportWorkbookHeadersAndRows(t *testing.T) { "B1": "Tanggal", "C1": "Status", "D1": "Customer", - "E1": "Grand Total", - "F1": "Products", - "G1": "Notes", + "E1": "Sales", + "G1": "Nama Produk", + "P1": "Grand Total", + "Q1": "Catatan", } for cell, expected := range expectedHeaders { got, err := file.GetCellValue(marketingExportSheetName, cell) @@ -83,19 +104,25 @@ func TestBuildMarketingExportWorkbookHeadersAndRows(t *testing.T) { } } + // SO-00762: 3 products → rows 2, 3, 4 assertCellEquals(t, file, "A2", "SO-00762") assertCellEquals(t, file, "B2", "22-04-2026") assertCellEquals(t, file, "C2", "Pengajuan") assertCellEquals(t, file, "D2", "AJAT") - assertCellEquals(t, file, "E2", "Rp 5.206.200.000") - assertCellEquals(t, file, "F2", "PAKAN GROWING CRUMBLE 8603 MALINDO, 295 GOLD PELLET") - assertCellEquals(t, file, "G2", "tes") + assertCellEquals(t, file, "G2", "PAKAN GROWING CRUMBLE 8603 MALINDO") + assertCellEquals(t, file, "Q2", "tes") - assertCellEquals(t, file, "A3", "SO-00761") - assertCellEquals(t, file, "C3", "Ditolak") - assertCellEquals(t, file, "E3", "Rp 75.000") - assertCellEquals(t, file, "F3", "HS30 FOAM @20 LITER") - assertCellEquals(t, file, "G3", "-") + // SO-00761 (rejected): 1 product → row 5 + assertCellEquals(t, file, "A5", "SO-00761") + assertCellEquals(t, file, "C5", "Ditolak") + assertCellEquals(t, file, "G5", "HS30 FOAM @20 LITER") + assertCellEquals(t, file, "Q5", "-") + + // DO-01954: column B must use soDate (31-05-2026), not deliveryDate (01-06-2026) + assertCellEquals(t, file, "A6", "DO-01954") + assertCellEquals(t, file, "B6", "31-05-2026") + assertCellEquals(t, file, "C6", "Delivery Order") + assertCellEquals(t, file, "D6", "CORDELA") } func assertCellEquals(t *testing.T, file *excelize.File, cell, expected string) { diff --git a/internal/modules/marketing/services/deliveryorder.service.go b/internal/modules/marketing/services/deliveryorder.service.go index d442f457..929e0ab0 100644 --- a/internal/modules/marketing/services/deliveryorder.service.go +++ b/internal/modules/marketing/services/deliveryorder.service.go @@ -321,6 +321,21 @@ func (s deliveryOrdersService) GetAll(c *fiber.Ctx, params *validation.DeliveryO return db.Where("id = ?", params.MarketingId) } + dateStart, dateEnd, dateErr := utils.ParseDateRangeForQuery(params.StartDate, params.EndDate) + if dateErr != nil { + return db.Where("1 = 0") + } + dateCol := "marketings.so_date" + if strings.TrimSpace(params.FilterBy) == "created_at" { + dateCol = "marketings.created_at" + } + if dateStart != nil { + db = db.Where(dateCol+" >= ?", *dateStart) + } + if dateEnd != nil { + db = db.Where(dateCol+" < ?", *dateEnd) + } + orderDir := "DESC" if params.SortOrder != "" { orderDir = strings.ToUpper(params.SortOrder) @@ -964,7 +979,10 @@ func (s deliveryOrdersService) consumeDeliveryStock(ctx context.Context, tx *gor marketingProduct.ProductWarehouseId, resolveMarketingAsOf(deliveryProduct.DeliveryDate, deliveryProduct.CreatedAt), ); err != nil { - return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Insufficient stock for product warehouse %d: %v", marketingProduct.ProductWarehouseId, err)) + if errors.Is(err, fifoV2.ErrInsufficientStock) { + return fiber.NewError(fiber.StatusBadRequest, "Stok tidak mencukupi untuk memenuhi permintaan delivery order ini") + } + return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Gagal mengalokasikan stok: %v", err)) } refreshed, err := deliveryProductRepo.GetByID(ctx, deliveryProduct.Id, nil) diff --git a/internal/modules/marketing/validations/deliveryorder.validation.go b/internal/modules/marketing/validations/deliveryorder.validation.go index c602de54..3504eb7b 100644 --- a/internal/modules/marketing/validations/deliveryorder.validation.go +++ b/internal/modules/marketing/validations/deliveryorder.validation.go @@ -34,6 +34,9 @@ type DeliveryOrderQuery struct { WarehouseID uint `query:"warehouse_id" validate:"omitempty,gt=0"` SortBy string `query:"sort_by" validate:"omitempty,oneof=so_number so_date status customer grand_total created_at"` SortOrder string `query:"sort_order" validate:"omitempty,oneof=asc desc"` + StartDate string `query:"start_date" validate:"omitempty,datetime=2006-01-02"` + EndDate string `query:"end_date" validate:"omitempty,datetime=2006-01-02"` + FilterBy string `query:"filter_by" validate:"omitempty,oneof=so_date created_at"` } type DeliveryOrderApprove struct { diff --git a/internal/modules/production/chickins/controllers/chickin.controller.go b/internal/modules/production/chickins/controllers/chickin.controller.go index f4425206..c5cd79bd 100644 --- a/internal/modules/production/chickins/controllers/chickin.controller.go +++ b/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) diff --git a/internal/modules/production/chickins/repositories/project_chickin.repository.go b/internal/modules/production/chickins/repositories/project_chickin.repository.go index 7f56a261..9d4daf22 100644 --- a/internal/modules/production/chickins/repositories/project_chickin.repository.go +++ b/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 +} diff --git a/internal/modules/production/chickins/route.go b/internal/modules/production/chickins/route.go index 4243a602..dbb6d5ce 100644 --- a/internal/modules/production/chickins/route.go +++ b/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) } diff --git a/internal/modules/production/chickins/services/chickin.service.go b/internal/modules/production/chickins/services/chickin.service.go index 09c617f8..0978fd9d 100644 --- a/internal/modules/production/chickins/services/chickin.service.go +++ b/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,38 @@ 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") + } + + if err := 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 + }); err != nil { + return err + } + + s.invalidateDepreciationSnapshots(ctx.Context(), nil, []uint{req.ProjectFlockKandangId}, newDate) + return nil +} diff --git a/internal/modules/production/chickins/validations/chickin.validation.go b/internal/modules/production/chickins/validations/chickin.validation.go index ebc6487f..0b8e1d71 100644 --- a/internal/modules/production/chickins/validations/chickin.validation.go +++ b/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"` +} diff --git a/internal/modules/production/recordings/services/recording.service.go b/internal/modules/production/recordings/services/recording.service.go index a4647980..85c19f6e 100644 --- a/internal/modules/production/recordings/services/recording.service.go +++ b/internal/modules/production/recordings/services/recording.service.go @@ -409,7 +409,14 @@ func (s *recordingService) CreateOne(c *fiber.Ctx, req *validation.Create) (*ent return nil, err } if err := s.ChickinSvc.EnsureChickInExists(ctx, pfk.Id); err != nil { - return nil, err + if !isLaying { + return nil, err + } + // LAYING fallback: kandang laying tidak punya project_chickins sendiri — + // populasinya dari laying transfer. Cek apakah ada executed laying transfer. + if fallbackErr := s.ensureLayingTransferExecutedForKandang(ctx, pfk.Id); fallbackErr != nil { + return nil, err + } } if s.ProductionStandardSvc != nil { if err := s.ProductionStandardSvc.EnsureWeekStart(ctx, pfk.ProjectFlock.ProductionStandardId, category); err != nil { @@ -3998,6 +4005,27 @@ func (s *recordingService) reflowRollbackRecordingInventory(ctx context.Context, return nil } +func (s *recordingService) ensureLayingTransferExecutedForKandang(ctx context.Context, pfkID uint) error { + var count int64 + err := s.Repository.DB().WithContext(ctx). + Table("laying_transfer_targets ltt"). + Joins("JOIN laying_transfers lt ON lt.id = ltt.laying_transfer_id"). + Where("ltt.target_project_flock_kandang_id = ?", pfkID). + Where("ltt.deleted_at IS NULL"). + Where("lt.deleted_at IS NULL"). + Where("lt.executed_at IS NOT NULL"). + Where("ltt.total_qty > 0"). + Count(&count).Error + if err != nil { + s.Log.Errorf("Failed to check executed laying transfer for pfk_id=%d: %+v", pfkID, err) + return fiber.NewError(fiber.StatusInternalServerError, "Gagal memeriksa transfer laying") + } + if count == 0 { + return fiber.NewError(fiber.StatusBadRequest, "Kandang laying belum memiliki transfer laying yang telah dieksekusi sehingga belum dapat membuat recording") + } + return nil +} + func (s *recordingService) requireFIFO() error { if s.FifoStockV2Svc == nil { s.Log.Errorf("FIFO v2 service is not available for recording operations") diff --git a/internal/modules/repports/repositories/expense_depreciation.repository.go b/internal/modules/repports/repositories/expense_depreciation.repository.go index 39223b83..cd71029c 100644 --- a/internal/modules/repports/repositories/expense_depreciation.repository.go +++ b/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 - `, houseTypes, maxDay).Scan(&rows).Error; err != nil { + AND (project_flock_ids IS NULL OR ? = ANY(project_flock_ids)) + 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 }