[FEAT/BE] down to hs256 without rotate key

.gitlab-ci.yml

@@ -1,186 +1,35 @@
-stages:
-  - build
-  - gitops
-
-variables:
-  AWS_REGION: ap-southeast-3
-  ECR_REGISTRY: 886436954922.dkr.ecr.ap-southeast-3.amazonaws.com
-  ECR_REPO_NAME: mbugroup/lti-api
-  ECR_REPOSITORY: ${ECR_REGISTRY}/${ECR_REPO_NAME}
-  TARGET_PLATFORM: linux/amd64
-
-  DOCKER_HOST: unix:///var/run/docker.sock
-  DOCKER_TLS_CERTDIR: ""
-  DOCKER_BUILDKIT: "1"
-
 workflow:
   rules:
-    # run untuk branch utama & MR
+    # MR pipeline
-    - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == "development"'
+    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
-    - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == "production"'
+      when: always
-    - if: '$CI_PIPELINE_SOURCE == "merge_request_event" && $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "production"'
+
+    # Push pipeline hanya untuk env branch
+    - if: '$CI_COMMIT_BRANCH == "development"'
+      when: always
+    - if: '$CI_COMMIT_BRANCH == "staging"'
+      when: always
+    - if: '$CI_COMMIT_BRANCH == "production"'
+      when: always
+
+    # Selain itu jangan buat pipeline
     - when: never
 
-# =========================
+include:
-# Helper: login ECR
+  # khusus MR (notif)
-# =========================
+  - local: "ci/merge_request.yml"
-.ecr_login: &ecr_login |
+    rules:
-  AWS_CLI_ENV_ARGS=""
+      - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
-  AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_REGION=$AWS_REGION"
-  AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-}"
-  AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-}"
-  if [ -n "${AWS_SESSION_TOKEN:-}" ]; then
-    AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_SESSION_TOKEN=$AWS_SESSION_TOKEN"
-  fi
 
-  PASS="$(docker run --rm $AWS_CLI_ENV_ARGS public.ecr.aws/aws-cli/aws-cli:latest \
+  # khusus push ke branch env
-    ecr get-login-password --region "$AWS_REGION" || true)"
+  - local: "ci/development.yml"
-  if [ -z "$PASS" ]; then
+    rules:
-    echo "ERROR: Failed to get ECR login password."
+      - if: '$CI_COMMIT_BRANCH == "development"'
-    exit 1
-  fi
-  echo "$PASS" | docker login --username AWS --password-stdin "$ECR_REGISTRY"
 
-# =========================
+  - local: "ci/staging.yml"
-# MR
+    rules:
-# =========================
+      - if: '$CI_COMMIT_BRANCH == "staging"'
-build_mr:
-  stage: build
-  image: public.ecr.aws/docker/library/docker:27
-  tags: [self-hosted-dev]
-  rules:
-    - if: '$CI_PIPELINE_SOURCE == "merge_request_event" && $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "production"'
-  variables:
-    IMAGE_TAG: "prod-${CI_COMMIT_SHORT_SHA}"
-  before_script:
-    - set -eu
-    - docker version
-    - docker info
-    - *ecr_login
-  script: |
-    set -eu
-    # force base image pulls via AWS ECR Public to avoid Docker Hub TLS timeout
-    sed -i 's|^FROM golang:1.23-alpine AS builder$|FROM public.ecr.aws/docker/library/golang:1.23-alpine AS builder|' Dockerfile
-    sed -i 's|^FROM alpine:3.20$|FROM public.ecr.aws/docker/library/alpine:3.20|' Dockerfile
-    echo "Build (MR) : $ECR_REPOSITORY:$IMAGE_TAG"
-    docker build --platform "$TARGET_PLATFORM" -f Dockerfile -t "$ECR_REPOSITORY:$IMAGE_TAG" .
-    echo "Pushing image for MR..."
-    docker push "$ECR_REPOSITORY:$IMAGE_TAG"
 
-# =========================
+  - local: "ci/production.yml"
-# DEVELOPMENT (push branch development)
+    rules:
-# =========================
+      - if: '$CI_COMMIT_BRANCH == "production"'
-build_push_dev:
-  stage: build
-  image: public.ecr.aws/docker/library/docker:27
-  tags: [self-hosted-dev]
-  rules:
-    - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == "development"'
-  variables:
-    IMAGE_TAG: "dev-${CI_COMMIT_SHORT_SHA}"
-  before_script:
-    - set -eu
-    - docker version
-    - docker info
-    - *ecr_login
-  script: |
-    set -eu
-    # force base image pulls via AWS ECR Public to avoid Docker Hub TLS timeout
-    sed -i 's|^FROM golang:1.23-alpine AS builder$|FROM public.ecr.aws/docker/library/golang:1.23-alpine AS builder|' Dockerfile
-    sed -i 's|^FROM alpine:3.20$|FROM public.ecr.aws/docker/library/alpine:3.20|' Dockerfile
-    echo "Build & push (dev): $ECR_REPOSITORY:$IMAGE_TAG"
-    docker build --platform "$TARGET_PLATFORM" -f Dockerfile -t "$ECR_REPOSITORY:$IMAGE_TAG" .
-    docker push "$ECR_REPOSITORY:$IMAGE_TAG"
-
-update_gitops_dev_lti:
-  stage: gitops
-  image: public.ecr.aws/docker/library/alpine:3.20
-  tags: [self-hosted-dev]
-  rules:
-    - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == "development"'
-  needs: ["build_push_dev"]
-  variables:
-    IMAGE_TAG: "dev-${CI_COMMIT_SHORT_SHA}"
-    GITOPS_BRANCH: main
-    VALUES_FILE: environments/lti/dev/lti-values-dev.yaml
-    GITOPS_REPO_URL: https://oauth2:${GITOPS_TOKEN}@gitlab.com/cristian.anggita.parjaman/gitops.git
-  before_script:
-    - set -eu
-    - apk add --no-cache git yq
-    - git config --global user.email "ci@gitlab"
-    - git config --global user.name "gitlab-ci"
-  script: |
-    set -eu
-    rm -rf gitops
-    git clone --depth 1 --branch "$GITOPS_BRANCH" "$GITOPS_REPO_URL" gitops
-    cd gitops
-
-    echo "Updating dev image.tag to $IMAGE_TAG"
-    yq -i '.image.tag = strenv(IMAGE_TAG)' "$VALUES_FILE"
-
-    git add "$VALUES_FILE"
-    if git diff --cached --quiet; then
-      echo "No changes to commit"
-      exit 0
-    fi
-    git commit -m "lti dev deploy ${IMAGE_TAG}"
-    git push origin "$GITOPS_BRANCH"
-
-# =========================
-# PRODUCTION (push branch production)
-# =========================
-build_push_prod:
-  stage: build
-  image: public.ecr.aws/docker/library/docker:27
-  tags: [self-hosted-dev]
-  rules:
-    - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == "production"'
-  variables:
-    IMAGE_TAG: "prod-${CI_COMMIT_SHORT_SHA}"
-  before_script:
-    - set -eu
-    - docker version
-    - docker info
-    - *ecr_login
-  script: |
-    set -eu
-    # force base image pulls via AWS ECR Public to avoid Docker Hub TLS timeout
-    sed -i 's|^FROM golang:1.23-alpine AS builder$|FROM public.ecr.aws/docker/library/golang:1.23-alpine AS builder|' Dockerfile
-    sed -i 's|^FROM alpine:3.20$|FROM public.ecr.aws/docker/library/alpine:3.20|' Dockerfile
-    echo "Build & push (prod): $ECR_REPOSITORY:$IMAGE_TAG"
-    docker build --platform "$TARGET_PLATFORM" -f Dockerfile -t "$ECR_REPOSITORY:$IMAGE_TAG" .
-    docker push "$ECR_REPOSITORY:$IMAGE_TAG"
-
-update_gitops_prod_lti:
-  stage: gitops
-  image: public.ecr.aws/docker/library/alpine:3.20
-  tags: [self-hosted-dev]
-  rules:
-    - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == "production"'
-  needs: ["build_push_prod"]
-  variables:
-    IMAGE_TAG: "prod-${CI_COMMIT_SHORT_SHA}"
-    GITOPS_BRANCH: main
-    VALUES_FILE: environments/lti/prod/lti-values-prod.yaml
-    GITOPS_REPO_URL: https://oauth2:${GITOPS_TOKEN}@gitlab.com/cristian.anggita.parjaman/gitops.git
-  before_script:
-    - set -eu
-    - apk add --no-cache git yq
-    - git config --global user.email "ci@gitlab"
-    - git config --global user.name "gitlab-ci"
-  script: |
-    set -eu
-    rm -rf gitops
-    git clone --depth 1 --branch "$GITOPS_BRANCH" "$GITOPS_REPO_URL" gitops
-    cd gitops
-
-    echo "Updating prod image.tag to $IMAGE_TAG"
-    yq -i '.image.tag = strenv(IMAGE_TAG)' "$VALUES_FILE"
-
-    git add "$VALUES_FILE"
-    if git diff --cached --quiet; then
-      echo "No changes to commit"
-      exit 0
-    fi
-    git commit -m "lti prod deploy ${IMAGE_TAG}"
-    git push origin "$GITOPS_BRANCH"

Dockerfile

@@ -1,7 +1,7 @@
 # =========================
 # Builder stage
 # =========================
-FROM public.ecr.aws/docker/library/golang:1.23-alpine AS builder
+FROM golang:1.23-alpine AS builder
 
 RUN apk add --no-cache git ca-certificates tzdata
 WORKDIR /app
@@ -15,17 +15,14 @@ COPY . .
 RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
     go build -trimpath -ldflags="-s -w" -o lti-api ./cmd/api
 
-# Build SEED binary
+# Build SEED binary (pastikan cmd/seed ada)
 RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
     go build -trimpath -ldflags="-s -w" -o lti-seed ./cmd/seed
 
-# Build migrate CLI with postgres + file drivers
-RUN GOBIN=/usr/local/bin go install -tags "postgres file" -ldflags="-s -w" github.com/golang-migrate/migrate/v4/cmd/migrate@v4.18.3
-
 # =========================
 # Runtime stage
 # =========================
-FROM public.ecr.aws/docker/library/alpine:3.20
+FROM alpine:3.20
 
 RUN apk add --no-cache ca-certificates tzdata curl bash postgresql-client \
   && adduser -D -H -u 10001 appuser
@@ -34,8 +31,6 @@ WORKDIR /app
 
 COPY --from=builder /app/lti-api /app/lti-api
 COPY --from=builder /app/lti-seed /app/lti-seed
-COPY --from=builder /usr/local/bin/migrate /app/migrate
-COPY --from=builder /app/internal/database/migrations /app/migrations
 
 USER appuser
 EXPOSE 8081

README.md

@@ -42,6 +42,8 @@ Copy .env.example to .env and adjust the variables (e.g. DATABASE_URL, JWT secre
 cp .env.example .env
 ```
 
+Catatan: isi `SSO_HS_SECRET` jika ingin verifikasi token HS256 tanpa JWKS.
+
 ### 5. Setup Docker
 
 Run initial docker.
@@ -111,4 +113,3 @@ IT Development PT Mitra Berlian Unggas Group
 ## 📃 License
 
 > This project is private. All rights reserved.
-# mr test Sat  7 Feb 2026 00:14:58 WIB

ci/development.yml

@@ -1,159 +1,91 @@
 stages:
-  - build
+  - deploy
-  - gitops
 
-variables:
+deploy-dev:
-  AWS_REGION: ap-southeast-3
+  stage: deploy
-  ECR_REGISTRY: 886436954922.dkr.ecr.ap-southeast-3.amazonaws.com
+  image: alpine:3.20
-  ECR_REPO_NAME: mbugroup/lti-api
-  ECR_REPOSITORY: ${ECR_REGISTRY}/${ECR_REPO_NAME}
 
-  DOCKER_HOST: unix:///var/run/docker.sock
-  DOCKER_TLS_CERTDIR: ""
-  DOCKER_BUILDKIT: "1"
-
-workflow:
-  rules:
-    - if: '$CI_COMMIT_BRANCH'
-
-# =========================
-# Helper: login ECR
-# =========================
-.ecr_login: &ecr_login |
-  AWS_CLI_ENV_ARGS=""
-  AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_REGION=$AWS_REGION"
-  AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-}"
-  AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-}"
-  if [ -n "${AWS_SESSION_TOKEN:-}" ]; then
-    AWS_CLI_ENV_ARGS="$AWS_CLI_ENV_ARGS -e AWS_SESSION_TOKEN=$AWS_SESSION_TOKEN"
-  fi
-
-  PASS="$(docker run --rm $AWS_CLI_ENV_ARGS public.ecr.aws/aws-cli/aws-cli:latest \
-    ecr get-login-password --region "$AWS_REGION" || true)"
-  if [ -z "$PASS" ]; then
-    echo "ERROR: Failed to get ECR login password."
-    exit 1
-  fi
-  echo "$PASS" | docker login --username AWS --password-stdin "$ECR_REGISTRY"
-
-# =========================
-# DEV
-# =========================
-build_push_dev_lti:
-  stage: build
-  image: public.ecr.aws/docker/library/docker:27
-  tags: [self-hosted-dev]
   rules:
     - if: '$CI_COMMIT_BRANCH == "development"'
+      when: on_success
+    - when: never
+
   variables:
-    IMAGE_TAG: "dev-${CI_COMMIT_SHORT_SHA}"
+    DEPLOY_APP: "LTI-MBUGROUP"
+    GIT_SUBMODULE_STRATEGY: recursive
+    GIT_DEPTH: "1"
+
   before_script:
-    - set -eu
+    - echo "🧰 Installing dependencies..."
-    - docker version
+    - apk update && apk add --no-cache openssh git curl bash
-    - docker info
-    - *ecr_login
-  script: |
-    set -eu
-    echo "Build & push: $ECR_REPOSITORY:$IMAGE_TAG"
 
-    docker build \
+    # Setup SSH di runner
-      -t "$ECR_REPOSITORY:$IMAGE_TAG" \
+    - mkdir -p ~/.ssh
-      .
+    - echo "$SSH_PRIVATE_KEY" | tr -d '\r' > ~/.ssh/id_rsa
+    - chmod 600 ~/.ssh/id_rsa
+    - eval "$(ssh-agent -s)"
+    - ssh-add ~/.ssh/id_rsa
 
-    docker push "$ECR_REPOSITORY:$IMAGE_TAG"
+    # Trust host keys (server + gitlab) biar SSH gak nanya interaktif
+    - ssh-keyscan -H "$SERVER_IP" >> ~/.ssh/known_hosts
+    - ssh-keyscan -H gitlab.com >> ~/.ssh/known_hosts
 
-update_gitops_dev_lti:
+  script:
-  stage: gitops
+    - echo "🚀 Deploying latest code to $SERVER_USER@$SERVER_IP"
-  image: public.ecr.aws/docker/library/alpine:3.20
+    - >
-  tags: [self-hosted-dev]
+      if ssh -o StrictHostKeyChecking=no "$SERVER_USER@$SERVER_IP" "
-  rules:
+        set -e
-    - if: '$CI_COMMIT_BRANCH == "development"'
-  needs: ["build_push_dev_lti"]
-  variables:
-    IMAGE_TAG: "dev-${CI_COMMIT_SHORT_SHA}"
-    GITOPS_BRANCH: main
-    VALUES_FILE: environments/lti/dev/lti-values-dev.yaml
-    GITOPS_REPO_URL: https://oauth2:${GITOPS_TOKEN}@gitlab.com/cristian.anggita.parjaman/gitops.git
-  before_script:
-    - set -eu
-    - apk add --no-cache git yq
-    - git config --global user.email "ci@gitlab"
-    - git config --global user.name "gitlab-ci"
-  script: |
-    set -eu
-    rm -rf gitops
-    git clone --depth 1 --branch "$GITOPS_BRANCH" "$GITOPS_REPO_URL" gitops
-    cd gitops
 
-    echo "Updating DEV image.tag to $IMAGE_TAG in $VALUES_FILE"
+        cd /home/devops/docker/deployment/development/lti-api
-    yq -i '.image.repository = strenv(ECR_REPOSITORY)' "$VALUES_FILE"
-    yq -i '.image.tag = strenv(IMAGE_TAG)' "$VALUES_FILE"
 
-    git add "$VALUES_FILE"
+        # Pastikan remote origin SSH (antisipasi kalau pernah ke-set HTTPS)
-    if git diff --cached --quiet; then
+        git remote set-url origin git@gitlab.com:mbugroup/lti-api.git
-      echo "No changes to commit"
-      exit 0
-    fi
-    git commit -m "lti dev deploy ${IMAGE_TAG}"
-    git push origin "$GITOPS_BRANCH"
 
-# =========================
+        # Pastikan server percaya gitlab.com juga (untuk git fetch via SSH)
-# PROD
+        mkdir -p ~/.ssh
-# =========================
+        ssh-keyscan -H gitlab.com >> ~/.ssh/known_hosts
-# build_push_prod_lti:
-#   stage: build
-#   image: public.ecr.aws/docker/library/docker:27
-#   tags: [self-hosted-dev]
-#   rules:
-#     - if: '$CI_COMMIT_BRANCH == "production"'
-#   variables:
-#     IMAGE_TAG: "prod-${CI_COMMIT_SHORT_SHA}"
-#   before_script:
-#     - set -eu
-#     - docker version
-#     - docker info
-#     - *ecr_login
-#   script: |
-#     set -eu
-#     echo "Build & push: $ECR_REPOSITORY:$IMAGE_TAG"
 
-#     docker build \
+        # Fetch/reset pakai SSH
-#       -t "$ECR_REPOSITORY:$IMAGE_TAG" \
+        GIT_SSH_COMMAND='ssh -o StrictHostKeyChecking=no' git fetch origin development
-#       .
+        git reset --hard origin/development
 
-#     docker push "$ECR_REPOSITORY:$IMAGE_TAG"
+        docker compose restart dev-api-lti || docker compose up -d dev-api-lti
+      "; then
+        STATUS='success';
+      else
+        STATUS='failed';
+      fi;
 
-# update_gitops_prod_lti:
+      RUN_URL="${CI_PROJECT_URL}/-/pipelines/${CI_PIPELINE_ID}";
-#   stage: gitops
-#   image: public.ecr.aws/docker/library/alpine:3.20
-#   tags: [self-hosted-dev]
-#   rules:
-#     - if: '$CI_COMMIT_BRANCH == "production"'
-#   needs: ["build_push_prod_lti"]
-#   variables:
-#     IMAGE_TAG: "prod-${CI_COMMIT_SHORT_SHA}"
-#     GITOPS_BRANCH: main
-#     VALUES_FILE: environments/lti/prod/lti-values-prod.yaml
-#     GITOPS_REPO_URL: https://oauth2:${GITOPS_TOKEN}@gitlab.com/cristian.anggita.parjaman/gitops.git
-#   before_script:
-#     - set -eu
-#     - apk add --no-cache git yq
-#     - git config --global user.email "ci@gitlab"
-#     - git config --global user.name "gitlab-ci"
-#   script: |
-#     set -eu
-#     rm -rf gitops
-#     git clone --depth 1 --branch "$GITOPS_BRANCH" "$GITOPS_REPO_URL" gitops
-#     cd gitops
 
-#     echo "Updating PROD image.tag to $IMAGE_TAG in $VALUES_FILE"
+      if [ "$STATUS" = "success" ]; then
-#     yq -i '.image.repository = strenv(ECR_REPOSITORY)' "$VALUES_FILE"
+        COLOR=3066993;
-#     yq -i '.image.tag = strenv(IMAGE_TAG)' "$VALUES_FILE"
+        TITLE="✅ Deployment API Succeeded";
+        DESC="Deployment job on branch \`${CI_COMMIT_REF_NAME}\` completed successfully.";
+      else
+        COLOR=15158332;
+        TITLE="❌ Deployment API Failed Gaes";
+        DESC="Deployment job on branch \`${CI_COMMIT_REF_NAME}\` failed.";
+      fi;
 
-#     git add "$VALUES_FILE"
+      echo "{
-#     if git diff --cached --quiet; then
+        \"username\": \"CI Bot\",
-#       echo "No changes to commit"
+        \"embeds\": [{
-#       exit 0
+          \"title\": \"$TITLE\",
-#     fi
+          \"description\": \"$DESC\",
-#     git commit -m "lti prod deploy ${IMAGE_TAG}"
+          \"color\": $COLOR,
-#     git push origin "$GITOPS_BRANCH"
+          \"fields\": [
+            {\"name\": \"Repository\", \"value\": \"${CI_PROJECT_PATH}\", \"inline\": true},
+            {\"name\": \"Actor\", \"value\": \"${GITLAB_USER_LOGIN}\", \"inline\": true},
+            {\"name\": \"Commit\", \"value\": \"${CI_COMMIT_SHA}\", \"inline\": false},
+            {\"name\": \"Pipeline\", \"value\": \"[Open run](${RUN_URL})\", \"inline\": false}
+          ]
+        }]
+      }" > payload.json;
+
+      echo "📡 Sending notification to Discord...";
+      curl -sS -H "Content-Type: application/json" \
+        -d @payload.json "$DISCORD_WEBHOOK_URL";
+
+  environment:
+    name: development

cmd/adjust-quantity-product-warehouse-from-purchase/main.go

@@ -1,297 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"flag"
-	"fmt"
-	"log"
-	"math"
-	"os"
-	"strings"
-
-	"gitlab.com/mbugroup/lti-api.git/internal/config"
-	"gitlab.com/mbugroup/lti-api.git/internal/database"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gorm.io/gorm"
-)
-
-const (
-	levelAllNoFlagProducts = 1
-	levelProductName       = 2
-	levelProductWarehouse  = 3
-	qtyEpsilon             = 1e-6
-)
-
-type targetRow struct {
-	ProductWarehouseID uint    `gorm:"column:product_warehouse_id"`
-	ProductID          uint    `gorm:"column:product_id"`
-	ProductName        string  `gorm:"column:product_name"`
-	CurrentQty         float64 `gorm:"column:current_qty"`
-	ComputedQty        float64 `gorm:"column:computed_qty"`
-}
-
-func main() {
-	var (
-		level              int
-		productName        string
-		productWarehouseID uint
-		apply              bool
-	)
-
-	flag.IntVar(
-		&level,
-		"level",
-		levelAllNoFlagProducts,
-		"CLI level: 1=all products without flags, 2=specific product name (with flags), 3=specific product warehouse id",
-	)
-	flag.StringVar(&productName, "product-name", "", "Product name (required for level 2)")
-	flag.UintVar(&productWarehouseID, "product-warehouse-id", 0, "Product warehouse id (required for level 3)")
-	flag.BoolVar(&apply, "apply", false, "Apply changes. If false, run as dry-run")
-	flag.Parse()
-
-	productName = strings.TrimSpace(productName)
-	if err := validateFlags(level, productName, productWarehouseID); err != nil {
-		log.Fatalf("invalid flags: %v", err)
-	}
-
-	ctx := context.Background()
-	db := database.Connect(config.DBHost, config.DBName)
-
-	targets, err := loadTargets(ctx, db, level, productName, productWarehouseID)
-	if err != nil {
-		log.Fatalf("failed to load target product warehouses: %v", err)
-	}
-
-	fmt.Printf("Mode: %s\n", modeLabel(apply))
-	fmt.Printf("Level: %d (%s)\n", level, levelLabel(level))
-	if productName != "" {
-		fmt.Printf("Filter product_name: %s\n", productName)
-	}
-	if productWarehouseID > 0 {
-		fmt.Printf("Filter product_warehouse_id: %d\n", productWarehouseID)
-	}
-	fmt.Printf("Targets found: %d\n\n", len(targets))
-
-	if len(targets) == 0 {
-		fmt.Println("No matching product warehouse rows to process")
-		return
-	}
-
-	for _, row := range targets {
-		fmt.Printf(
-			"PLAN pw=%d product_id=%d product=%q current_qty=%.3f computed_qty=%.3f delta=%.3f\n",
-			row.ProductWarehouseID,
-			row.ProductID,
-			row.ProductName,
-			row.CurrentQty,
-			row.ComputedQty,
-			row.ComputedQty-row.CurrentQty,
-		)
-	}
-
-	if !apply {
-		fmt.Println()
-		fmt.Printf("Summary: planned=%d updated=0 skipped=0 failed=0\n", len(targets))
-		return
-	}
-
-	updated := 0
-	skipped := 0
-	err = db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		for _, row := range targets {
-			if nearlyEqual(row.CurrentQty, row.ComputedQty) {
-				fmt.Printf(
-					"SKIP pw=%d reason=no_change current_qty=%.3f computed_qty=%.3f\n",
-					row.ProductWarehouseID,
-					row.CurrentQty,
-					row.ComputedQty,
-				)
-				skipped++
-				continue
-			}
-
-			if err := tx.Table("product_warehouses").
-				Where("id = ?", row.ProductWarehouseID).
-				Update("qty", row.ComputedQty).Error; err != nil {
-				return fmt.Errorf("update qty for product_warehouse_id=%d: %w", row.ProductWarehouseID, err)
-			}
-
-			fmt.Printf(
-				"DONE pw=%d product_id=%d product=%q old_qty=%.3f new_qty=%.3f\n",
-				row.ProductWarehouseID,
-				row.ProductID,
-				row.ProductName,
-				row.CurrentQty,
-				row.ComputedQty,
-			)
-			updated++
-		}
-		return nil
-	})
-	if err != nil {
-		fmt.Println()
-		fmt.Printf("Summary: planned=%d updated=%d skipped=%d failed=1\n", len(targets), updated, skipped)
-		log.Printf("error: %v", err)
-		os.Exit(1)
-	}
-
-	fmt.Println()
-	fmt.Printf("Summary: planned=%d updated=%d skipped=%d failed=0\n", len(targets), updated, skipped)
-}
-
-func validateFlags(level int, productName string, productWarehouseID uint) error {
-	switch level {
-	case levelAllNoFlagProducts:
-		if productName != "" {
-			return errors.New("--product-name cannot be used on level 1")
-		}
-		if productWarehouseID > 0 {
-			return errors.New("--product-warehouse-id cannot be used on level 1")
-		}
-	case levelProductName:
-		if productName == "" {
-			return errors.New("--product-name is required on level 2")
-		}
-		if productWarehouseID > 0 {
-			return errors.New("--product-warehouse-id cannot be used on level 2")
-		}
-	case levelProductWarehouse:
-		if productWarehouseID == 0 {
-			return errors.New("--product-warehouse-id is required on level 3")
-		}
-		if productName != "" {
-			return errors.New("--product-name cannot be used on level 3")
-		}
-	default:
-		return fmt.Errorf("unsupported --level=%d (allowed: 1, 2, 3)", level)
-	}
-
-	return nil
-}
-
-func loadTargets(
-	ctx context.Context,
-	db *gorm.DB,
-	level int,
-	productName string,
-	productWarehouseID uint,
-) ([]targetRow, error) {
-	switch level {
-	case levelAllNoFlagProducts:
-		return loadTargetsLevel1ByProductWithoutFlags(ctx, db)
-	case levelProductName:
-		return loadTargetsLevel2ByProductWarehouseWithFlags(ctx, db, productName)
-	case levelProductWarehouse:
-		return loadTargetByProductWarehouseID(ctx, db, productWarehouseID)
-	default:
-		return nil, fmt.Errorf("unsupported level %d", level)
-	}
-}
-
-func loadTargetsLevel1ByProductWithoutFlags(ctx context.Context, db *gorm.DB) ([]targetRow, error) {
-	rows := make([]targetRow, 0)
-	if err := db.WithContext(ctx).
-		Table("product_warehouses pw").
-		Select(`
-			pw.id AS product_warehouse_id,
-			pw.product_id AS product_id,
-			p.name AS product_name,
-			COALESCE(pw.qty, 0) AS current_qty,
-			COALESCE(SUM(pi.total_qty), 0) AS computed_qty
-		`).
-		Joins("JOIN products p ON p.id = pw.product_id").
-		Joins("LEFT JOIN flags f ON f.flagable_id = p.id AND f.flagable_type = ?", entity.FlagableTypeProduct).
-		Joins("LEFT JOIN purchase_items pi ON pi.product_warehouse_id = pw.id").
-		Where("p.deleted_at IS NULL").
-		Where("f.id IS NULL").
-		Group("pw.id, pw.product_id, p.name, pw.qty").
-		Order("pw.id ASC").
-		Scan(&rows).Error; err != nil {
-		return nil, err
-	}
-
-	return rows, nil
-}
-
-func loadTargetsLevel2ByProductWarehouseWithFlags(
-	ctx context.Context,
-	db *gorm.DB,
-	productName string,
-) ([]targetRow, error) {
-	rows := make([]targetRow, 0)
-	if err := db.WithContext(ctx).
-		Table("product_warehouses pw").
-		Select(`
-			pw.id AS product_warehouse_id,
-			pw.product_id AS product_id,
-			p.name AS product_name,
-			COALESCE(pw.qty, 0) AS current_qty,
-			COALESCE(SUM(pi.total_qty), 0) AS computed_qty
-		`).
-		Joins("JOIN products p ON p.id = pw.product_id").
-		Joins("LEFT JOIN purchase_items pi ON pi.product_warehouse_id = pw.id").
-		Where("p.deleted_at IS NULL").
-		Where(`
-			EXISTS (
-				SELECT 1
-				FROM flags f
-				WHERE f.flagable_id = p.id
-				  AND f.flagable_type = ?
-			)
-		`, entity.FlagableTypeProduct).
-		Where("LOWER(p.name) = LOWER(?)", productName).
-		Group("pw.id, pw.product_id, p.name, pw.qty").
-		Order("pw.id ASC").
-		Scan(&rows).Error; err != nil {
-		return nil, err
-	}
-
-	return rows, nil
-}
-
-func loadTargetByProductWarehouseID(ctx context.Context, db *gorm.DB, productWarehouseID uint) ([]targetRow, error) {
-	rows := make([]targetRow, 0)
-	if err := db.WithContext(ctx).
-		Table("product_warehouses pw").
-		Select(`
-			pw.id AS product_warehouse_id,
-			pw.product_id AS product_id,
-			p.name AS product_name,
-			COALESCE(pw.qty, 0) AS current_qty,
-			COALESCE(SUM(pi.total_qty), 0) AS computed_qty
-		`).
-		Joins("JOIN products p ON p.id = pw.product_id").
-		Joins("LEFT JOIN purchase_items pi ON pi.product_warehouse_id = pw.id").
-		Where("pw.id = ?", productWarehouseID).
-		Group("pw.id, pw.product_id, p.name, pw.qty").
-		Scan(&rows).Error; err != nil {
-		return nil, err
-	}
-
-	return rows, nil
-}
-
-func modeLabel(apply bool) string {
-	if apply {
-		return "APPLY"
-	}
-	return "DRY-RUN"
-}
-
-func levelLabel(level int) string {
-	switch level {
-	case levelAllNoFlagProducts:
-		return "all products without flags (source: purchase_items by product_warehouse_id)"
-	case levelProductName:
-		return "specific product name with flags (source: purchase_items by product_warehouse_id)"
-	case levelProductWarehouse:
-		return "specific product_warehouse_id (source: purchase_items by product_warehouse_id)"
-	default:
-		return "unknown"
-	}
-}
-
-func nearlyEqual(a, b float64) bool {
-	return math.Abs(a-b) <= qtyEpsilon
-}

cmd/api-key/main.go

@@ -1,132 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"os"
-	"strings"
-
-	"gitlab.com/mbugroup/lti-api.git/internal/apikeys"
-	"gitlab.com/mbugroup/lti-api.git/internal/config"
-	"gitlab.com/mbugroup/lti-api.git/internal/database"
-)
-
-func main() {
-	if len(os.Args) < 2 {
-		usage()
-		os.Exit(1)
-	}
-
-	db := database.Connect(config.DBHost, config.DBName)
-	service := apikeys.NewService(db)
-	ctx := context.Background()
-
-	switch os.Args[1] {
-	case "create":
-		fs := flag.NewFlagSet("create", flag.ExitOnError)
-		name := fs.String("name", "dashboard-read-api", "integration client name")
-		environment := fs.String("env", config.AppEnv, "environment label")
-		permissions := fs.String("permissions", "", "comma separated permission codes")
-		allArea := fs.Bool("all-area", true, "grant all areas")
-		areaIDs := fs.String("area-ids", "", "comma separated area ids")
-		allLocation := fs.Bool("all-location", true, "grant all locations")
-		locationIDs := fs.String("location-ids", "", "comma separated location ids")
-		fs.Parse(os.Args[2:])
-
-		permissionCodes := apikeys.DefaultDashboardPermissions()
-		if strings.TrimSpace(*permissions) != "" {
-			permissionCodes = splitCSV(*permissions)
-		}
-
-		issued, err := service.Create(ctx, apikeys.CreateInput{
-			Name:            *name,
-			Environment:     *environment,
-			PermissionCodes: permissionCodes,
-			AllArea:         *allArea,
-			AreaIDs:         parseUintCSV(*areaIDs),
-			AllLocation:     *allLocation,
-			LocationIDs:     parseUintCSV(*locationIDs),
-		})
-		if err != nil {
-			panic(err)
-		}
-
-		fmt.Printf("name: %s\n", issued.Record.Name)
-		fmt.Printf("environment: %s\n", issued.Record.Environment)
-		fmt.Printf("prefix: %s\n", issued.Record.KeyPrefix)
-		fmt.Printf("status: %s\n", issued.Record.Status)
-		fmt.Printf("api_key: %s\n", issued.Key)
-	case "list":
-		fs := flag.NewFlagSet("list", flag.ExitOnError)
-		environment := fs.String("env", "", "filter by environment")
-		fs.Parse(os.Args[2:])
-
-		records, err := service.List(ctx, *environment)
-		if err != nil {
-			panic(err)
-		}
-
-		for _, record := range records {
-			fmt.Printf("%s\t%s\t%s\t%s\tareas=%t\tlocations=%t\n",
-				record.Environment,
-				record.KeyPrefix,
-				record.Status,
-				record.Name,
-				record.AllArea,
-				record.AllLocation,
-			)
-		}
-	case "revoke":
-		fs := flag.NewFlagSet("revoke", flag.ExitOnError)
-		environment := fs.String("env", config.AppEnv, "environment label")
-		prefix := fs.String("prefix", "", "key prefix to revoke")
-		fs.Parse(os.Args[2:])
-
-		if err := service.Revoke(ctx, *environment, *prefix); err != nil {
-			panic(err)
-		}
-		fmt.Printf("revoked %s/%s\n", *environment, *prefix)
-	default:
-		usage()
-		os.Exit(1)
-	}
-}
-
-func usage() {
-	fmt.Println("usage:")
-	fmt.Println("  go run ./cmd/api-key create [flags]")
-	fmt.Println("  go run ./cmd/api-key list [flags]")
-	fmt.Println("  go run ./cmd/api-key revoke -env <environment> -prefix <prefix>")
-}
-
-func splitCSV(raw string) []string {
-	if strings.TrimSpace(raw) == "" {
-		return nil
-	}
-	parts := strings.Split(raw, ",")
-	out := make([]string, 0, len(parts))
-	for _, part := range parts {
-		part = strings.TrimSpace(part)
-		if part != "" {
-			out = append(out, part)
-		}
-	}
-	return out
-}
-
-func parseUintCSV(raw string) []uint {
-	parts := splitCSV(raw)
-	if len(parts) == 0 {
-		return nil
-	}
-
-	values := make([]uint, 0, len(parts))
-	for _, part := range parts {
-		var value uint
-		if _, err := fmt.Sscanf(part, "%d", &value); err == nil && value > 0 {
-			values = append(values, value)
-		}
-	}
-	return values
-}

cmd/api/main.go

@@ -9,14 +9,12 @@ import (
 	"syscall"
 	"time"
 
-	"gitlab.com/mbugroup/lti-api.git/internal/apikeys"
 	"gitlab.com/mbugroup/lti-api.git/internal/cache"
 	"gitlab.com/mbugroup/lti-api.git/internal/config"
 	"gitlab.com/mbugroup/lti-api.git/internal/database"
 	"gitlab.com/mbugroup/lti-api.git/internal/middleware"
 	"gitlab.com/mbugroup/lti-api.git/internal/modules/sso/session"
 	sso "gitlab.com/mbugroup/lti-api.git/internal/modules/sso/verifier"
-	"gitlab.com/mbugroup/lti-api.git/internal/readapi"
 	"gitlab.com/mbugroup/lti-api.git/internal/route"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 
@@ -71,7 +69,7 @@ func setupSSO(ctx context.Context, rdb *redis.Client) {
 
 	var lastErr error
 	for attempt := 1; attempt <= maxAttempts; attempt++ {
-		if err := sso.Init(ctx, config.SSOJWKSURL, config.SSOIssuer, config.SSOAllowedAudiences); err != nil {
+		if err := sso.Init(ctx, config.SSOJWKSURL, config.SSOIssuer, config.SSOAllowedAudiences, config.SSOHMACSecret); err != nil {
 			lastErr = err
 			utils.Log.WithError(err).Warnf("SSO initialization attempt %d/%d failed", attempt, maxAttempts)
 			select {
@@ -133,7 +131,6 @@ func setupDatabase() *gorm.DB {
 }
 
 func setupRoutes(app *fiber.App, db *gorm.DB, rdb *redis.Client) {
-	middleware.SetAPIKeyAuthenticator(apikeys.NewService(db))
 
 	// route.Routes(app, db)
 	// app.Use(utils.NotFoundHandler)
@@ -172,8 +169,6 @@ func setupRoutes(app *fiber.App, db *gorm.DB, rdb *redis.Client) {
 		return c.Status(status).JSON(body)
 	})
 
-	readAPIRoutes := app.Group("/api")
-	readapi.RegisterRoutes(readAPIRoutes)
 	route.Routes(app, db)
 	app.Use(utils.NotFoundHandler)
 }

cmd/delete-adjustments/main.go

@@ -1,407 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
-	"gitlab.com/mbugroup/lti-api.git/internal/config"
-	"gitlab.com/mbugroup/lti-api.git/internal/database"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
-	"gorm.io/gorm"
-)
-
-type adjustmentRow struct {
-	ID                 uint      `gorm:"column:id"`
-	ProductWarehouseID uint      `gorm:"column:product_warehouse_id"`
-	ProductID          uint      `gorm:"column:product_id"`
-	FunctionCode       string    `gorm:"column:function_code"`
-	TotalQty           float64   `gorm:"column:total_qty"`
-	UsageQty           float64   `gorm:"column:usage_qty"`
-	PendingQty         float64   `gorm:"column:pending_qty"`
-	StockLogIncrease   float64   `gorm:"column:stock_log_increase"`
-	StockLogDecrease   float64   `gorm:"column:stock_log_decrease"`
-	CreatedAt          time.Time `gorm:"column:created_at"`
-}
-
-type routeResolution struct {
-	FlagGroupCode string `gorm:"column:flag_group_code"`
-	Lane          string `gorm:"column:lane"`
-	FunctionCode  string `gorm:"column:function_code"`
-}
-
-func main() {
-	var (
-		idsRaw string
-		apply  bool
-	)
-
-	flag.StringVar(&idsRaw, "ids", "", "Comma-separated adjustment IDs (required), example: 1,2")
-	flag.BoolVar(&apply, "apply", false, "Apply delete. If false, run as dry-run")
-	flag.Parse()
-
-	ids, err := parseIDs(idsRaw)
-	if err != nil {
-		log.Fatalf("invalid --ids: %v", err)
-	}
-	if len(ids) == 0 {
-		log.Fatal("--ids is required")
-	}
-
-	ctx := context.Background()
-	db := database.Connect(config.DBHost, config.DBName)
-
-	fifoStockV2Svc := commonSvc.NewFifoStockV2Service(db, nil)
-
-	adjustments, err := loadAdjustments(ctx, db, ids)
-	if err != nil {
-		log.Fatalf("failed to load adjustments: %v", err)
-	}
-	if len(adjustments) == 0 {
-		log.Fatal("no adjustments found for provided IDs")
-	}
-
-	sort.Slice(adjustments, func(i, j int) bool {
-		return adjustments[i].ID < adjustments[j].ID
-	})
-
-	fmt.Printf("Mode: %s\n", modeLabel(apply))
-	fmt.Printf("Adjustments loaded: %d\n\n", len(adjustments))
-
-	success := 0
-	failed := 0
-	skipped := 0
-
-	for _, adj := range adjustments {
-		if strings.TrimSpace(adj.FunctionCode) == "" {
-			fmt.Printf("SKIP adj=%d reason=function_code empty\n", adj.ID)
-			skipped++
-			continue
-		}
-
-		route, err := resolveRouteByFunctionCode(ctx, db, adj.ProductID, strings.ToUpper(strings.TrimSpace(adj.FunctionCode)))
-		if err != nil {
-			fmt.Printf("FAIL adj=%d error=resolve route: %v\n", adj.ID, err)
-			failed++
-			continue
-		}
-
-		switch route.Lane {
-		case "USABLE":
-			desiredQty := adj.UsageQty + adj.PendingQty
-			if desiredQty <= 0 && adj.StockLogDecrease > 0 {
-				desiredQty = adj.StockLogDecrease
-			}
-
-			activeAlloc, err := countActiveUsableAllocations(ctx, db, fifo.UsableKeyAdjustmentOut.String(), adj.ID)
-			if err != nil {
-				fmt.Printf("FAIL adj=%d error=count usable allocations: %v\n", adj.ID, err)
-				failed++
-				continue
-			}
-
-			fmt.Printf(
-				"PLAN adj=%d lane=USABLE function=%s usage=%.3f pending=%.3f active_alloc=%d action=reflow_to_zero+delete\n",
-				adj.ID,
-				route.FunctionCode,
-				adj.UsageQty,
-				adj.PendingQty,
-				activeAlloc,
-			)
-
-			if !apply {
-				skipped++
-				continue
-			}
-
-			err = db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-				reflowReq := commonSvc.FifoStockV2ReflowRequest{
-					FlagGroupCode:      route.FlagGroupCode,
-					ProductWarehouseID: adj.ProductWarehouseID,
-					AsOf:               &adj.CreatedAt,
-					IdempotencyKey:     fmt.Sprintf("delete-adjustment-usable-%d-%d", adj.ID, time.Now().UnixNano()),
-					Tx:                 tx,
-				}
-				if _, err := fifoStockV2Svc.Reflow(ctx, reflowReq); err != nil {
-					return fmt.Errorf("reflow usable to zero: %w", err)
-				}
-
-				if err := hardDeleteUsableAllocations(ctx, tx, fifo.UsableKeyAdjustmentOut.String(), adj.ID); err != nil {
-					return err
-				}
-				if err := hardDeleteAdjustmentStockLogs(ctx, tx, adj.ID); err != nil {
-					return err
-				}
-				if err := hardDeleteAdjustment(ctx, tx, adj.ID); err != nil {
-					return err
-				}
-				return nil
-			})
-			if err != nil {
-				fmt.Printf("FAIL adj=%d error=%v\n", adj.ID, err)
-				failed++
-				continue
-			}
-
-			fmt.Printf("DONE adj=%d deleted\n", adj.ID)
-			success++
-
-		case "STOCKABLE":
-			removeQty := adj.TotalQty
-			if removeQty <= 0 && adj.StockLogIncrease > 0 {
-				removeQty = adj.StockLogIncrease
-			}
-
-			activeAlloc, err := countActiveStockableAllocations(ctx, db, fifo.StockableKeyAdjustmentIn.String(), adj.ID)
-			if err != nil {
-				fmt.Printf("FAIL adj=%d error=count stockable allocations: %v\n", adj.ID, err)
-				failed++
-				continue
-			}
-			if activeAlloc > 0 {
-				fmt.Printf(
-					"FAIL adj=%d reason=stockable still allocated active_alloc=%d action=delete blocked\n",
-					adj.ID,
-					activeAlloc,
-				)
-				failed++
-				continue
-			}
-
-			fmt.Printf(
-				"PLAN adj=%d lane=STOCKABLE function=%s total=%.3f remove_qty=%.3f action=reflow_to_zero+delete\n",
-				adj.ID,
-				route.FunctionCode,
-				adj.TotalQty,
-				removeQty,
-			)
-
-			if !apply {
-				skipped++
-				continue
-			}
-
-			err = db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-				if err := tx.WithContext(ctx).
-					Table("adjustment_stocks").
-					Where("id = ?", adj.ID).
-					Updates(map[string]any{
-						"total_qty":  0,
-						"total_used": 0,
-					}).Error; err != nil {
-					return fmt.Errorf("set stockable qty to zero: %w", err)
-				}
-
-				reflowReq := commonSvc.FifoStockV2ReflowRequest{
-					FlagGroupCode:      route.FlagGroupCode,
-					ProductWarehouseID: adj.ProductWarehouseID,
-					AsOf:               &adj.CreatedAt,
-					IdempotencyKey:     fmt.Sprintf("delete-adjustment-stockable-%d-%d", adj.ID, time.Now().UnixNano()),
-					Tx:                 tx,
-				}
-				if _, err := fifoStockV2Svc.Reflow(ctx, reflowReq); err != nil {
-					return fmt.Errorf("reflow stockable to zero: %w", err)
-				}
-
-				if err := hardDeleteStockableAllocations(ctx, tx, fifo.StockableKeyAdjustmentIn.String(), adj.ID); err != nil {
-					return err
-				}
-				if err := hardDeleteAdjustmentStockLogs(ctx, tx, adj.ID); err != nil {
-					return err
-				}
-				if err := hardDeleteAdjustment(ctx, tx, adj.ID); err != nil {
-					return err
-				}
-				return nil
-			})
-			if err != nil {
-				fmt.Printf("FAIL adj=%d error=%v\n", adj.ID, err)
-				failed++
-				continue
-			}
-
-			fmt.Printf("DONE adj=%d deleted\n", adj.ID)
-			success++
-
-		default:
-			fmt.Printf("SKIP adj=%d reason=unsupported lane=%s\n", adj.ID, route.Lane)
-			skipped++
-		}
-	}
-
-	fmt.Println()
-	fmt.Printf("Summary: success=%d failed=%d skipped=%d\n", success, failed, skipped)
-	if failed > 0 {
-		os.Exit(1)
-	}
-}
-
-func modeLabel(apply bool) string {
-	if apply {
-		return "APPLY"
-	}
-	return "DRY-RUN"
-}
-
-func parseIDs(raw string) ([]uint, error) {
-	raw = strings.TrimSpace(raw)
-	if raw == "" {
-		return nil, nil
-	}
-
-	parts := strings.Split(raw, ",")
-	out := make([]uint, 0, len(parts))
-	seen := map[uint]struct{}{}
-
-	for _, part := range parts {
-		part = strings.TrimSpace(part)
-		if part == "" {
-			continue
-		}
-		v, err := strconv.ParseUint(part, 10, 64)
-		if err != nil {
-			return nil, fmt.Errorf("invalid id %q", part)
-		}
-		if v == 0 {
-			return nil, fmt.Errorf("id must be > 0: %q", part)
-		}
-		id := uint(v)
-		if _, ok := seen[id]; ok {
-			continue
-		}
-		seen[id] = struct{}{}
-		out = append(out, id)
-	}
-	return out, nil
-}
-
-func loadAdjustments(ctx context.Context, db *gorm.DB, ids []uint) ([]adjustmentRow, error) {
-	var rows []adjustmentRow
-	err := db.WithContext(ctx).
-		Table("adjustment_stocks a").
-		Select(`
-			a.id,
-			a.product_warehouse_id,
-			pw.product_id,
-			a.function_code,
-			COALESCE(a.total_qty, 0) AS total_qty,
-			COALESCE(a.usage_qty, 0) AS usage_qty,
-			COALESCE(a.pending_qty, 0) AS pending_qty,
-			COALESCE((
-				SELECT sl.increase
-				FROM stock_logs sl
-				WHERE sl.loggable_type = 'ADJUSTMENT'
-					AND sl.loggable_id = a.id
-				ORDER BY sl.id DESC
-				LIMIT 1
-			), 0) AS stock_log_increase,
-			COALESCE((
-				SELECT sl.decrease
-				FROM stock_logs sl
-				WHERE sl.loggable_type = 'ADJUSTMENT'
-					AND sl.loggable_id = a.id
-				ORDER BY sl.id DESC
-				LIMIT 1
-			), 0) AS stock_log_decrease,
-			a.created_at
-		`).
-		Joins("JOIN product_warehouses pw ON pw.id = a.product_warehouse_id").
-		Where("a.id IN ?", ids).
-		Find(&rows).Error
-	if err != nil {
-		return nil, err
-	}
-	return rows, nil
-}
-
-func resolveRouteByFunctionCode(ctx context.Context, db *gorm.DB, productID uint, functionCode string) (*routeResolution, error) {
-	var rows []routeResolution
-	err := db.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules rr").
-		Select("rr.flag_group_code, rr.lane, rr.function_code").
-		Joins("JOIN fifo_stock_v2_flag_groups fg ON fg.code = rr.flag_group_code AND fg.is_active = TRUE").
-		Where("rr.is_active = TRUE").
-		Where("rr.function_code = ?", functionCode).
-		Where(`
-			EXISTS (
-				SELECT 1
-				FROM flags f
-				JOIN fifo_stock_v2_flag_members fm ON fm.flag_name = f.name AND fm.is_active = TRUE
-				WHERE f.flagable_type = ?
-					AND f.flagable_id = ?
-					AND fm.flag_group_code = rr.flag_group_code
-			)
-		`, entity.FlagableTypeProduct, productID).
-		Order("CASE WHEN rr.source_table = 'adjustment_stocks' THEN 0 ELSE 1 END ASC").
-		Order("rr.id ASC").
-		Find(&rows).Error
-	if err != nil {
-		return nil, err
-	}
-	if len(rows) == 0 {
-		return nil, fmt.Errorf("no route found for product_id=%d function_code=%s", productID, functionCode)
-	}
-
-	selected := rows[0]
-	for _, row := range rows {
-		if row.Lane != selected.Lane {
-			return nil, fmt.Errorf("ambiguous lane for product_id=%d function_code=%s", productID, functionCode)
-		}
-	}
-	selected.FunctionCode = functionCode
-	return &selected, nil
-}
-
-func countActiveUsableAllocations(ctx context.Context, db *gorm.DB, usableType string, usableID uint) (int64, error) {
-	var count int64
-	err := db.WithContext(ctx).
-		Table("stock_allocations").
-		Where("usable_type = ? AND usable_id = ?", usableType, usableID).
-		Where("status = ?", entity.StockAllocationStatusActive).
-		Where("allocation_purpose = ?", entity.StockAllocationPurposeConsume).
-		Count(&count).Error
-	return count, err
-}
-
-func countActiveStockableAllocations(ctx context.Context, db *gorm.DB, stockableType string, stockableID uint) (int64, error) {
-	var count int64
-	err := db.WithContext(ctx).
-		Table("stock_allocations").
-		Where("stockable_type = ? AND stockable_id = ?", stockableType, stockableID).
-		Where("status = ?", entity.StockAllocationStatusActive).
-		Where("allocation_purpose = ?", entity.StockAllocationPurposeConsume).
-		Count(&count).Error
-	return count, err
-}
-
-func hardDeleteUsableAllocations(ctx context.Context, tx *gorm.DB, usableType string, usableID uint) error {
-	return tx.WithContext(ctx).
-		Exec("DELETE FROM stock_allocations WHERE usable_type = ? AND usable_id = ? AND allocation_purpose = ?", usableType, usableID, entity.StockAllocationPurposeConsume).
-		Error
-}
-
-func hardDeleteStockableAllocations(ctx context.Context, tx *gorm.DB, stockableType string, stockableID uint) error {
-	return tx.WithContext(ctx).
-		Exec("DELETE FROM stock_allocations WHERE stockable_type = ? AND stockable_id = ? AND allocation_purpose = ?", stockableType, stockableID, entity.StockAllocationPurposeConsume).
-		Error
-}
-
-func hardDeleteAdjustmentStockLogs(ctx context.Context, tx *gorm.DB, adjustmentID uint) error {
-	return tx.WithContext(ctx).
-		Exec("DELETE FROM stock_logs WHERE loggable_type = ? AND loggable_id = ?", "ADJUSTMENT", adjustmentID).
-		Error
-}
-
-func hardDeleteAdjustment(ctx context.Context, tx *gorm.DB, adjustmentID uint) error {
-	return tx.WithContext(ctx).
-		Exec("DELETE FROM adjustment_stocks WHERE id = ?", adjustmentID).
-		Error
-}

cmd/generate-read-api/main.go

@@ -1,74 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"gitlab.com/mbugroup/lti-api.git/internal/cache"
-	"gitlab.com/mbugroup/lti-api.git/internal/config"
-	"gitlab.com/mbugroup/lti-api.git/internal/readapi"
-	"gitlab.com/mbugroup/lti-api.git/internal/route"
-
-	"github.com/gofiber/fiber/v2"
-	"github.com/redis/go-redis/v9"
-)
-
-func main() {
-	root, err := findRepoRoot()
-	if err != nil {
-		panic(err)
-	}
-
-	readapi.PrimeBuildConfig()
-	cache.SetRedis(redis.NewClient(&redis.Options{Addr: "127.0.0.1:6379"}))
-	app := fiber.New(config.FiberConfig())
-	app.Get("/healthz", func(c *fiber.Ctx) error {
-		return c.JSON(fiber.Map{"status": "ok", "service": "api", "version": config.Version})
-	})
-	app.Get("/readyz", func(c *fiber.Ctx) error {
-		return c.JSON(fiber.Map{"status": "ok", "db": "up", "redis": "up"})
-	})
-	route.Routes(app, nil)
-
-	artifacts, err := readapi.BuildArtifactsFromApp(app)
-	if err != nil {
-		panic(err)
-	}
-
-	files := map[string][]byte{
-		filepath.Join(root, "docs", "openapi", "read-api.json"):             artifacts.OpenAPIJSON,
-		filepath.Join(root, "docs", "openapi", "read-api.yaml"):             artifacts.OpenAPIYAML,
-		filepath.Join(root, "docs", "postman", "read-api.collection.json"):  artifacts.PostmanCollectionJSON,
-		filepath.Join(root, "docs", "postman", "read-api.environment.json"): artifacts.PostmanEnvironmentJSON,
-	}
-
-	for path, body := range files {
-		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-			panic(err)
-		}
-		if err := os.WriteFile(path, body, 0o644); err != nil {
-			panic(err)
-		}
-		fmt.Printf("wrote %s\n", path)
-	}
-}
-
-func findRepoRoot() (string, error) {
-	wd, err := os.Getwd()
-	if err != nil {
-		return "", err
-	}
-
-	current := wd
-	for {
-		if _, err := os.Stat(filepath.Join(current, "go.mod")); err == nil {
-			return current, nil
-		}
-		parent := filepath.Dir(current)
-		if parent == current {
-			return "", fmt.Errorf("go.mod not found from %s", wd)
-		}
-		current = parent
-	}
-}

cmd/import-adjustment-stock-prices/main.go

@@ -1,587 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"sort"
-	"strconv"
-	"strings"
-
-	"github.com/xuri/excelize/v2"
-	"gitlab.com/mbugroup/lti-api.git/internal/config"
-	"gitlab.com/mbugroup/lti-api.git/internal/database"
-	"gorm.io/gorm"
-)
-
-type importOptions struct {
-	FilePath string
-	Sheet    string
-	Apply    bool
-}
-
-type headerIndexes struct {
-	AdjustmentID int
-	Weight       int
-}
-
-type adjustmentPriceImportRow struct {
-	RowNumber    int
-	AdjustmentID uint
-	Weight       float64
-}
-
-type validationIssue struct {
-	Row     int
-	Field   string
-	Message string
-}
-
-func (i validationIssue) Error() 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)
-}
-
-type adjustmentResolver interface {
-	ResolveExistingAdjustmentIDs(ctx context.Context, adjustmentIDs []uint) (map[uint]struct{}, error)
-}
-
-type dbAdjustmentResolver struct {
-	db *gorm.DB
-}
-
-type adjustmentPriceStore interface {
-	UpdatePrice(ctx context.Context, adjustmentID uint, price float64) (bool, error)
-}
-
-type txRunner interface {
-	InTx(ctx context.Context, fn func(store adjustmentPriceStore) error) error
-}
-
-type dbTxRunner struct {
-	db *gorm.DB
-}
-
-type dbAdjustmentPriceStore struct {
-	db *gorm.DB
-}
-
-type applyRowResult struct {
-	RowNumber    int
-	AdjustmentID uint
-	Price        float64
-	Changed      bool
-}
-
-func main() {
-	var opts importOptions
-	flag.StringVar(&opts.FilePath, "file", "", "Path to .xlsx file (required)")
-	flag.StringVar(&opts.Sheet, "sheet", "", "Sheet name (optional, default: first sheet)")
-	flag.BoolVar(&opts.Apply, "apply", false, "Apply changes. If false, run as dry-run")
-	flag.Parse()
-
-	opts.FilePath = strings.TrimSpace(opts.FilePath)
-	opts.Sheet = strings.TrimSpace(opts.Sheet)
-
-	if opts.FilePath == "" {
-		log.Fatal("--file is required")
-	}
-
-	sheetName, rows, parseIssues, err := parseAdjustmentPriceFile(opts.FilePath, opts.Sheet)
-	if err != nil {
-		log.Fatalf("failed reading excel: %v", err)
-	}
-
-	ctx := context.Background()
-	db := database.Connect(config.DBHost, config.DBName)
-	resolver := dbAdjustmentResolver{db: db}
-
-	existingAdjustmentIDs, err := resolver.ResolveExistingAdjustmentIDs(ctx, collectAdjustmentIDs(rows))
-	if err != nil {
-		log.Fatalf("failed checking adjustment_id against adjustment_stocks: %v", err)
-	}
-
-	processableRows, skippedRows := splitRowsByExistingIDs(rows, existingAdjustmentIDs)
-	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("Rows parsed: %d\n", len(rows))
-	fmt.Printf("Rows invalid: %d\n", len(issues))
-	fmt.Printf("Rows processable: %d\n", len(processableRows))
-	fmt.Printf("Rows skipped_missing: %d\n", len(skippedRows))
-	fmt.Println()
-
-	if len(processableRows) > 0 {
-		printPlanRows(processableRows)
-	}
-	if len(skippedRows) > 0 {
-		printSkippedRows(skippedRows)
-	}
-	if len(processableRows) > 0 || len(skippedRows) > 0 {
-		fmt.Println()
-	}
-
-	if len(issues) > 0 {
-		fmt.Println("Validation errors:")
-		for _, issue := range issues {
-			fmt.Printf("ERROR %s\n", issue.Error())
-		}
-		fmt.Println()
-		fmt.Printf(
-			"Summary: planned=%d processable=%d skipped_missing=%d applied=0 failed=%d\n",
-			len(rows),
-			len(processableRows),
-			len(skippedRows),
-			len(issues),
-		)
-		os.Exit(1)
-	}
-
-	if !opts.Apply {
-		fmt.Printf(
-			"Summary: planned=%d processable=%d skipped_missing=%d applied=0 failed=0\n",
-			len(rows),
-			len(processableRows),
-			len(skippedRows),
-		)
-		return
-	}
-
-	results, err := applyIfRequested(ctx, true, dbTxRunner{db: db}, processableRows)
-	if err != nil {
-		log.Fatalf("apply failed: %v", err)
-	}
-
-	for _, result := range results {
-		fmt.Printf(
-			"DONE row=%d adjustment_id=%d price=%.3f status=%s\n",
-			result.RowNumber,
-			result.AdjustmentID,
-			result.Price,
-			applyStatus(result.Changed),
-		)
-	}
-
-	appliedCount := countChangedRows(results)
-	if len(results) > 0 {
-		fmt.Println()
-	}
-	fmt.Printf(
-		"Summary: planned=%d processable=%d skipped_missing=%d applied=%d failed=0\n",
-		len(rows),
-		len(processableRows),
-		len(skippedRows),
-		appliedCount,
-	)
-}
-
-func parseAdjustmentPriceFile(
-	filePath string,
-	requestedSheet string,
-) (string, []adjustmentPriceImportRow, []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: "header", Message: "sheet is empty"}}, nil
-	}
-
-	indexes, headerIssues := parseHeaderIndexes(allRows[0])
-	if len(headerIssues) > 0 {
-		return sheetName, nil, headerIssues, nil
-	}
-
-	rowsByAdjustmentID := make(map[uint]adjustmentPriceImportRow)
-	issues := make([]validationIssue, 0)
-
-	for idx := 1; idx < len(allRows); idx++ {
-		rowNumber := idx + 1
-		rawRow := allRows[idx]
-
-		if isRowEmpty(rawRow) {
-			continue
-		}
-
-		parsed, rowIssues := parseDataRow(rawRow, rowNumber, indexes)
-		if len(rowIssues) > 0 {
-			issues = append(issues, rowIssues...)
-			continue
-		}
-
-		rowsByAdjustmentID[parsed.AdjustmentID] = *parsed
-	}
-
-	rows := make([]adjustmentPriceImportRow, 0, len(rowsByAdjustmentID))
-	for _, row := range rowsByAdjustmentID {
-		rows = append(rows, row)
-	}
-	sort.Slice(rows, func(i, j int) bool {
-		return rows[i].RowNumber < rows[j].RowNumber
-	})
-
-	if len(rows) == 0 && len(issues) == 0 {
-		issues = append(issues, validationIssue{Field: "rows", Message: "no data rows found"})
-	}
-
-	return sheetName, rows, issues, nil
-}
-
-func resolveSheetName(workbook *excelize.File, requestedSheet string) (string, error) {
-	if workbook == nil {
-		return "", fmt.Errorf("workbook is nil")
-	}
-
-	sheets := workbook.GetSheetList()
-	if len(sheets) == 0 {
-		return "", fmt.Errorf("workbook has no sheets")
-	}
-
-	if 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 parseHeaderIndexes(headerRow []string) (headerIndexes, []validationIssue) {
-	indexes := headerIndexes{AdjustmentID: -1, Weight: -1}
-	issues := make([]validationIssue, 0)
-
-	for idx, raw := range headerRow {
-		header := normalizeHeader(raw)
-		if header == "" {
-			continue
-		}
-
-		switch header {
-		case "adjustment_id":
-			if indexes.AdjustmentID >= 0 {
-				issues = append(issues, validationIssue{Field: "header", Message: "duplicate header adjustment_id"})
-			}
-			indexes.AdjustmentID = idx
-		case "weight":
-			if indexes.Weight >= 0 {
-				issues = append(issues, validationIssue{Field: "header", Message: "duplicate header weight"})
-			}
-			indexes.Weight = idx
-		}
-	}
-
-	if indexes.AdjustmentID < 0 {
-		issues = append(issues, validationIssue{Field: "adjustment_id", Message: "required header is missing"})
-	}
-	if indexes.Weight < 0 {
-		issues = append(issues, validationIssue{Field: "weight", Message: "required header is missing"})
-	}
-
-	return indexes, issues
-}
-
-func parseDataRow(
-	rawRow []string,
-	rowNumber int,
-	indexes headerIndexes,
-) (*adjustmentPriceImportRow, []validationIssue) {
-	issues := make([]validationIssue, 0)
-
-	adjustmentIDRaw := strings.TrimSpace(cellValue(rawRow, indexes.AdjustmentID))
-	adjustmentID, err := parsePositiveUint(adjustmentIDRaw)
-	if err != nil {
-		issues = append(issues, validationIssue{Row: rowNumber, Field: "adjustment_id", Message: err.Error()})
-	}
-
-	weightRaw := strings.TrimSpace(cellValue(rawRow, indexes.Weight))
-	weight, err := parseNonNegativeFloat(weightRaw)
-	if err != nil {
-		issues = append(issues, validationIssue{Row: rowNumber, Field: "weight", Message: err.Error()})
-	}
-
-	if len(issues) > 0 {
-		return nil, issues
-	}
-
-	return &adjustmentPriceImportRow{
-		RowNumber:    rowNumber,
-		AdjustmentID: adjustmentID,
-		Weight:       weight,
-	}, nil
-}
-
-func parsePositiveUint(raw string) (uint, error) {
-	if raw == "" {
-		return 0, fmt.Errorf("is required")
-	}
-
-	uintValue, err := strconv.ParseUint(raw, 10, 64)
-	if err == nil {
-		if uintValue == 0 {
-			return 0, fmt.Errorf("must be greater than 0")
-		}
-		return uint(uintValue), nil
-	}
-
-	floatValue, floatErr := strconv.ParseFloat(raw, 64)
-	if floatErr != nil {
-		return 0, fmt.Errorf("must be a positive integer")
-	}
-	if floatValue <= 0 {
-		return 0, fmt.Errorf("must be greater than 0")
-	}
-	if floatValue != float64(uint(floatValue)) {
-		return 0, fmt.Errorf("must be a positive integer")
-	}
-
-	return uint(floatValue), nil
-}
-
-func parseNonNegativeFloat(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 {
-		return 0, fmt.Errorf("must be greater than or equal to 0")
-	}
-
-	return value, nil
-}
-
-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 collectAdjustmentIDs(rows []adjustmentPriceImportRow) []uint {
-	ids := make([]uint, 0, len(rows))
-	seen := make(map[uint]struct{}, len(rows))
-	for _, row := range rows {
-		if row.AdjustmentID == 0 {
-			continue
-		}
-		if _, exists := seen[row.AdjustmentID]; exists {
-			continue
-		}
-		seen[row.AdjustmentID] = struct{}{}
-		ids = append(ids, row.AdjustmentID)
-	}
-	sort.Slice(ids, func(i, j int) bool {
-		return ids[i] < ids[j]
-	})
-	return ids
-}
-
-func (r dbAdjustmentResolver) ResolveExistingAdjustmentIDs(
-	ctx context.Context,
-	adjustmentIDs []uint,
-) (map[uint]struct{}, error) {
-	result := make(map[uint]struct{})
-	if len(adjustmentIDs) == 0 {
-		return result, nil
-	}
-
-	type adjustmentIDRow struct {
-		ID uint `gorm:"column:id"`
-	}
-
-	rows := make([]adjustmentIDRow, 0, len(adjustmentIDs))
-	if err := r.db.WithContext(ctx).
-		Table("adjustment_stocks").
-		Select("id").
-		Where("id IN ?", adjustmentIDs).
-		Scan(&rows).Error; err != nil {
-		return nil, err
-	}
-
-	for _, row := range rows {
-		result[row.ID] = struct{}{}
-	}
-
-	return result, nil
-}
-
-func splitRowsByExistingIDs(
-	rows []adjustmentPriceImportRow,
-	existing map[uint]struct{},
-) ([]adjustmentPriceImportRow, []adjustmentPriceImportRow) {
-	processable := make([]adjustmentPriceImportRow, 0, len(rows))
-	skipped := make([]adjustmentPriceImportRow, 0)
-
-	for _, row := range rows {
-		if _, exists := existing[row.AdjustmentID]; exists {
-			processable = append(processable, row)
-			continue
-		}
-		skipped = append(skipped, row)
-	}
-
-	return processable, skipped
-}
-
-func printPlanRows(rows []adjustmentPriceImportRow) {
-	for _, row := range rows {
-		fmt.Printf(
-			"PLAN row=%d adjustment_id=%d price=%.3f\n",
-			row.RowNumber,
-			row.AdjustmentID,
-			row.Weight,
-		)
-	}
-}
-
-func printSkippedRows(rows []adjustmentPriceImportRow) {
-	for _, row := range rows {
-		fmt.Printf(
-			"SKIP row=%d adjustment_id=%d reason=adjustment_id not found\n",
-			row.RowNumber,
-			row.AdjustmentID,
-		)
-	}
-}
-
-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 applyIfRequested(
-	ctx context.Context,
-	apply bool,
-	runner txRunner,
-	rows []adjustmentPriceImportRow,
-) ([]applyRowResult, error) {
-	if !apply || len(rows) == 0 {
-		return nil, nil
-	}
-	return applyImportRows(ctx, runner, rows)
-}
-
-func applyImportRows(
-	ctx context.Context,
-	runner txRunner,
-	rows []adjustmentPriceImportRow,
-) ([]applyRowResult, error) {
-	results := make([]applyRowResult, 0, len(rows))
-
-	err := runner.InTx(ctx, func(store adjustmentPriceStore) error {
-		for _, row := range rows {
-			changed, err := store.UpdatePrice(ctx, row.AdjustmentID, row.Weight)
-			if err != nil {
-				return fmt.Errorf("row %d adjustment_id=%d update failed: %w", row.RowNumber, row.AdjustmentID, err)
-			}
-
-			results = append(results, applyRowResult{
-				RowNumber:    row.RowNumber,
-				AdjustmentID: row.AdjustmentID,
-				Price:        row.Weight,
-				Changed:      changed,
-			})
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return results, nil
-}
-
-func (r dbTxRunner) InTx(ctx context.Context, fn func(store adjustmentPriceStore) error) error {
-	return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		return fn(dbAdjustmentPriceStore{db: tx})
-	})
-}
-
-func (s dbAdjustmentPriceStore) UpdatePrice(
-	ctx context.Context,
-	adjustmentID uint,
-	price float64,
-) (bool, error) {
-	result := s.db.WithContext(ctx).Exec(`
-		UPDATE adjustment_stocks
-		SET price = ?,
-		    updated_at = NOW()
-		WHERE id = ?
-		  AND price IS DISTINCT FROM ?
-	`, price, adjustmentID, price)
-	if result.Error != nil {
-		return false, result.Error
-	}
-	return result.RowsAffected > 0, nil
-}
-
-func modeLabel(apply bool) string {
-	if apply {
-		return "APPLY"
-	}
-	return "DRY-RUN"
-}
-
-func applyStatus(changed bool) string {
-	if changed {
-		return "UPDATED"
-	}
-	return "UNCHANGED"
-}
-
-func countChangedRows(results []applyRowResult) int {
-	count := 0
-	for _, result := range results {
-		if result.Changed {
-			count++
-		}
-	}
-	return count
-}

cmd/import-adjustment-stock-prices/main_test.go

@@ -1,362 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/xuri/excelize/v2"
-)
-
-func TestParseAdjustmentPriceFile_ValidSingleRow(t *testing.T) {
-	filePath := createWorkbook(
-		t,
-		"adjustment_prices",
-		[]string{"adjustment_id", "weight"},
-		[][]string{{"101", "12.345"}},
-	)
-
-	sheet, rows, issues, err := parseAdjustmentPriceFile(filePath, "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if sheet != "adjustment_prices" {
-		t.Fatalf("expected selected sheet adjustment_prices, got %q", sheet)
-	}
-	if len(issues) != 0 {
-		t.Fatalf("expected no issues, got %+v", issues)
-	}
-	if len(rows) != 1 {
-		t.Fatalf("expected 1 row, got %d", len(rows))
-	}
-	if rows[0].AdjustmentID != 101 {
-		t.Fatalf("expected adjustment_id 101, got %d", rows[0].AdjustmentID)
-	}
-	if rows[0].Weight != 12.345 {
-		t.Fatalf("expected weight 12.345, got %v", rows[0].Weight)
-	}
-}
-
-func TestParseAdjustmentPriceFile_ValidMultiRow(t *testing.T) {
-	filePath := createWorkbook(
-		t,
-		"adjustment_prices",
-		[]string{" Adjustment_ID ", "WEIGHT"},
-		[][]string{{"101", "10"}, {"102", "11.5"}},
-	)
-
-	_, rows, issues, err := parseAdjustmentPriceFile(filePath, "adjustment_prices")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(issues) != 0 {
-		t.Fatalf("expected no issues, got %+v", issues)
-	}
-	if len(rows) != 2 {
-		t.Fatalf("expected 2 rows, got %d", len(rows))
-	}
-}
-
-func TestParseAdjustmentPriceFile_MissingRequiredHeader(t *testing.T) {
-	filePath := createWorkbook(
-		t,
-		"adjustment_prices",
-		[]string{"adjustment_id", "price"},
-		[][]string{{"101", "12"}},
-	)
-
-	_, rows, issues, err := parseAdjustmentPriceFile(filePath, "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(rows) != 0 {
-		t.Fatalf("expected 0 parsed rows when header invalid, got %d", len(rows))
-	}
-	if !hasIssue(issues, 0, "weight", "required header is missing") {
-		t.Fatalf("expected missing weight header issue, got %+v", issues)
-	}
-}
-
-func TestParseAdjustmentPriceFile_InvalidAdjustmentID(t *testing.T) {
-	filePath := createWorkbook(
-		t,
-		"adjustment_prices",
-		[]string{"adjustment_id", "weight"},
-		[][]string{{"abc", "10"}, {"0", "12"}},
-	)
-
-	_, rows, issues, err := parseAdjustmentPriceFile(filePath, "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(rows) != 0 {
-		t.Fatalf("expected no valid rows, got %d", len(rows))
-	}
-	if !hasIssue(issues, 2, "adjustment_id", "must be a positive integer") {
-		t.Fatalf("expected non numeric adjustment_id issue, got %+v", issues)
-	}
-	if !hasIssue(issues, 3, "adjustment_id", "must be greater than 0") {
-		t.Fatalf("expected adjustment_id >0 issue, got %+v", issues)
-	}
-}
-
-func TestParseAdjustmentPriceFile_InvalidWeight(t *testing.T) {
-	filePath := createWorkbook(
-		t,
-		"adjustment_prices",
-		[]string{"adjustment_id", "weight"},
-		[][]string{{"101", "abc"}, {"102", "-1"}},
-	)
-
-	_, rows, issues, err := parseAdjustmentPriceFile(filePath, "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(rows) != 0 {
-		t.Fatalf("expected no valid rows, got %d", len(rows))
-	}
-	if !hasIssue(issues, 2, "weight", "must be numeric") {
-		t.Fatalf("expected weight numeric issue, got %+v", issues)
-	}
-	if !hasIssue(issues, 3, "weight", "must be greater than or equal to 0") {
-		t.Fatalf("expected weight >=0 issue, got %+v", issues)
-	}
-}
-
-func TestParseAdjustmentPriceFile_DuplicateAdjustmentID_LastRowWins(t *testing.T) {
-	filePath := createWorkbook(
-		t,
-		"adjustment_prices",
-		[]string{"adjustment_id", "weight"},
-		[][]string{{"101", "10"}, {"102", "20"}, {"101", "30"}},
-	)
-
-	_, rows, issues, err := parseAdjustmentPriceFile(filePath, "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(issues) != 0 {
-		t.Fatalf("expected no issues, got %+v", issues)
-	}
-	if len(rows) != 2 {
-		t.Fatalf("expected 2 deduped rows, got %d", len(rows))
-	}
-
-	row101, ok := findRowByAdjustmentID(rows, 101)
-	if !ok {
-		t.Fatalf("expected adjustment_id 101 to exist, got %+v", rows)
-	}
-	if row101.Weight != 30 {
-		t.Fatalf("expected duplicate adjustment_id to keep last weight 30, got %v", row101.Weight)
-	}
-	if row101.RowNumber != 4 {
-		t.Fatalf("expected duplicate adjustment_id to keep last row number 4, got %d", row101.RowNumber)
-	}
-}
-
-func TestSplitRowsByExistingIDs_SkipMissing(t *testing.T) {
-	rows := []adjustmentPriceImportRow{
-		{RowNumber: 2, AdjustmentID: 101, Weight: 10},
-		{RowNumber: 3, AdjustmentID: 102, Weight: 11},
-		{RowNumber: 4, AdjustmentID: 103, Weight: 12},
-	}
-	existing := map[uint]struct{}{101: {}, 103: {}}
-
-	processable, skipped := splitRowsByExistingIDs(rows, existing)
-	if len(processable) != 2 {
-		t.Fatalf("expected 2 processable rows, got %d", len(processable))
-	}
-	if len(skipped) != 1 {
-		t.Fatalf("expected 1 skipped row, got %d", len(skipped))
-	}
-	if skipped[0].AdjustmentID != 102 {
-		t.Fatalf("expected adjustment_id 102 skipped, got %+v", skipped)
-	}
-}
-
-func TestApplyIfRequested_DryRunDoesNotWrite(t *testing.T) {
-	runner := &fakeTransactionRunner{}
-	rows := []adjustmentPriceImportRow{{RowNumber: 2, AdjustmentID: 101, Weight: 10}}
-
-	results, err := applyIfRequested(context.Background(), false, runner, rows)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if results != nil {
-		t.Fatalf("expected nil results on dry-run, got %+v", results)
-	}
-	if runner.txCalls != 0 {
-		t.Fatalf("expected no transaction call during dry-run, got %d", runner.txCalls)
-	}
-}
-
-func TestApplyImportRows_Success(t *testing.T) {
-	runner := &fakeTransactionRunner{
-		changedByID: map[uint]bool{101: true, 102: false},
-	}
-	rows := []adjustmentPriceImportRow{
-		{RowNumber: 2, AdjustmentID: 101, Weight: 10},
-		{RowNumber: 3, AdjustmentID: 102, Weight: 11},
-	}
-
-	results, err := applyImportRows(context.Background(), runner, rows)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if runner.txCalls != 1 {
-		t.Fatalf("expected 1 transaction call, got %d", runner.txCalls)
-	}
-	if len(runner.committedCalls) != 2 {
-		t.Fatalf("expected 2 committed updates, got %d", len(runner.committedCalls))
-	}
-	if len(results) != 2 {
-		t.Fatalf("expected 2 row results, got %d", len(results))
-	}
-	if !results[0].Changed || results[1].Changed {
-		t.Fatalf("unexpected changed flags: %+v", results)
-	}
-}
-
-func TestApplyImportRows_RollbackOnError(t *testing.T) {
-	runner := &fakeTransactionRunner{
-		errByID: map[uint]error{102: errors.New("boom")},
-	}
-	rows := []adjustmentPriceImportRow{
-		{RowNumber: 2, AdjustmentID: 101, Weight: 10},
-		{RowNumber: 3, AdjustmentID: 102, Weight: 11},
-	}
-
-	_, err := applyImportRows(context.Background(), runner, rows)
-	if err == nil {
-		t.Fatal("expected error due to update failure")
-	}
-	if !strings.Contains(err.Error(), "row 3 adjustment_id=102 update failed") {
-		t.Fatalf("unexpected error message: %v", err)
-	}
-	if runner.txCalls != 1 {
-		t.Fatalf("expected 1 transaction call, got %d", runner.txCalls)
-	}
-	if len(runner.committedCalls) != 0 {
-		t.Fatalf("expected no committed updates on rollback, got %d", len(runner.committedCalls))
-	}
-}
-
-func createWorkbook(t *testing.T, sheetName string, headers []string, rows [][]string) string {
-	t.Helper()
-
-	f := excelize.NewFile()
-	defaultSheet := f.GetSheetName(f.GetActiveSheetIndex())
-	if sheetName == "" {
-		sheetName = defaultSheet
-	} else if sheetName != defaultSheet {
-		f.SetSheetName(defaultSheet, sheetName)
-	}
-
-	for idx, header := range headers {
-		cell, err := excelize.CoordinatesToCellName(idx+1, 1)
-		if err != nil {
-			t.Fatalf("failed resolving header cell: %v", err)
-		}
-		if err := f.SetCellValue(sheetName, cell, header); err != nil {
-			t.Fatalf("failed setting header cell: %v", err)
-		}
-	}
-
-	for rowIdx, row := range rows {
-		for colIdx, value := range row {
-			cell, err := excelize.CoordinatesToCellName(colIdx+1, rowIdx+2)
-			if err != nil {
-				t.Fatalf("failed resolving data cell: %v", err)
-			}
-			if err := f.SetCellValue(sheetName, cell, value); err != nil {
-				t.Fatalf("failed setting data cell: %v", err)
-			}
-		}
-	}
-
-	path := filepath.Join(t.TempDir(), "adjustment_prices.xlsx")
-	if err := f.SaveAs(path); err != nil {
-		t.Fatalf("failed saving workbook: %v", err)
-	}
-	if err := f.Close(); err != nil {
-		t.Fatalf("failed closing workbook: %v", err)
-	}
-
-	return path
-}
-
-func hasIssue(issues []validationIssue, row int, field, messageContains string) bool {
-	for _, issue := range issues {
-		if issue.Row != row {
-			continue
-		}
-		if issue.Field != field {
-			continue
-		}
-		if strings.Contains(issue.Message, messageContains) {
-			return true
-		}
-	}
-	return false
-}
-
-func findRowByAdjustmentID(rows []adjustmentPriceImportRow, adjustmentID uint) (adjustmentPriceImportRow, bool) {
-	for _, row := range rows {
-		if row.AdjustmentID == adjustmentID {
-			return row, true
-		}
-	}
-	return adjustmentPriceImportRow{}, false
-}
-
-type updateCall struct {
-	adjustmentID uint
-	price        float64
-}
-
-type fakeAdjustmentPriceStore struct {
-	changedByID map[uint]bool
-	errByID     map[uint]error
-	calls       []updateCall
-}
-
-func (s *fakeAdjustmentPriceStore) UpdatePrice(_ context.Context, adjustmentID uint, price float64) (bool, error) {
-	s.calls = append(s.calls, updateCall{adjustmentID: adjustmentID, price: price})
-	if err, exists := s.errByID[adjustmentID]; exists {
-		return false, fmt.Errorf("forced update failure for adjustment_id=%d: %w", adjustmentID, err)
-	}
-	if changed, exists := s.changedByID[adjustmentID]; exists {
-		return changed, nil
-	}
-	return true, nil
-}
-
-type fakeTransactionRunner struct {
-	txCalls        int
-	changedByID    map[uint]bool
-	errByID        map[uint]error
-	committedCalls []updateCall
-}
-
-func (r *fakeTransactionRunner) InTx(ctx context.Context, fn func(store adjustmentPriceStore) error) error {
-	r.txCalls++
-
-	txStore := &fakeAdjustmentPriceStore{
-		changedByID: r.changedByID,
-		errByID:     r.errByID,
-		calls:       make([]updateCall, 0),
-	}
-
-	if err := fn(txStore); err != nil {
-		return err
-	}
-
-	r.committedCalls = append(r.committedCalls, txStore.calls...)
-	return nil
-}
-
-var _ txRunner = (*fakeTransactionRunner)(nil)
-var _ adjustmentPriceStore = (*fakeAdjustmentPriceStore)(nil)

cmd/import-farm-depreciation-manual-inputs/main.go

@@ -1,632 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"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"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	repportRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/repports/repositories"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils"
-	"gorm.io/gorm"
-)
-
-const dateLayout = "2006-01-02"
-
-type importOptions struct {
-	FilePath string
-	Sheet    string
-	Apply    bool
-}
-
-type headerIndexes struct {
-	ProjectFlockID int
-	TotalCost      int
-	CutoverDate    int
-	Note           int
-}
-
-type manualInputImportRow struct {
-	RowNumber      int
-	ProjectFlockID uint
-	TotalCost      float64
-	CutoverDate    time.Time
-	Note           *string
-}
-
-type validationIssue struct {
-	Row     int
-	Field   string
-	Message string
-}
-
-func (i validationIssue) Error() 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)
-}
-
-type farmResolver interface {
-	ResolveActiveLayingFarms(ctx context.Context, projectFlockIDs []uint) (map[uint]string, error)
-}
-
-type dbFarmResolver struct {
-	db *gorm.DB
-}
-
-type manualInputStore interface {
-	UpsertManualInput(ctx context.Context, row *entity.FarmDepreciationManualInput) error
-	DeleteSnapshotsFromDate(ctx context.Context, fromDate time.Time, farmIDs []uint) error
-}
-
-type txRunner interface {
-	InTx(ctx context.Context, fn func(store manualInputStore) error) error
-}
-
-type dbTxRunner struct {
-	db *gorm.DB
-}
-
-type expenseDepreciationStore struct {
-	repo repportRepo.ExpenseDepreciationRepository
-}
-
-type farmIdentityRow struct {
-	ID       uint   `gorm:"column:id"`
-	FarmName string `gorm:"column:farm_name"`
-}
-
-func main() {
-	var opts importOptions
-	flag.StringVar(&opts.FilePath, "file", "", "Path to .xlsx file (required)")
-	flag.StringVar(&opts.Sheet, "sheet", "", "Sheet name (optional, default: first sheet)")
-	flag.BoolVar(&opts.Apply, "apply", false, "Apply changes. If false, run as dry-run")
-	flag.Parse()
-
-	opts.FilePath = strings.TrimSpace(opts.FilePath)
-	opts.Sheet = strings.TrimSpace(opts.Sheet)
-
-	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)
-	}
-
-	sheetName, rows, parseIssues, err := parseManualInputFile(opts.FilePath, opts.Sheet, location)
-	if err != nil {
-		log.Fatalf("failed reading excel: %v", err)
-	}
-
-	ctx := context.Background()
-	db := database.Connect(config.DBHost, config.DBName)
-	resolver := dbFarmResolver{db: db}
-
-	farmNameByID, err := resolver.ResolveActiveLayingFarms(ctx, collectProjectFlockIDs(rows))
-	if err != nil {
-		log.Fatalf("failed validating project_flock_id against project_flocks: %v", err)
-	}
-
-	issues := append([]validationIssue{}, parseIssues...)
-	issues = append(issues, buildMissingFarmIssues(rows, farmNameByID)...)
-	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("Rows parsed: %d\n", len(rows))
-	fmt.Printf("Rows invalid: %d\n", len(issues))
-	fmt.Println()
-
-	if len(rows) > 0 {
-		printPlanRows(rows, farmNameByID)
-		fmt.Println()
-	}
-
-	if len(issues) > 0 {
-		fmt.Println("Validation errors:")
-		for _, issue := range issues {
-			fmt.Printf("ERROR %s\n", issue.Error())
-		}
-		fmt.Println()
-		fmt.Printf("Summary: planned=%d applied=0 failed=%d\n", len(rows), len(issues))
-		os.Exit(1)
-	}
-
-	if !opts.Apply {
-		fmt.Printf("Summary: planned=%d applied=0 failed=0\n", len(rows))
-		return
-	}
-
-	if len(rows) == 0 {
-		fmt.Println("Summary: planned=0 applied=0 failed=0")
-		return
-	}
-
-	if err := applyIfRequested(ctx, true, dbTxRunner{db: db}, rows); err != nil {
-		log.Fatalf("apply failed: %v", err)
-	}
-
-	for _, row := range rows {
-		fmt.Printf(
-			"DONE row=%d project_flock_id=%d cutover_date=%s\n",
-			row.RowNumber,
-			row.ProjectFlockID,
-			row.CutoverDate.In(location).Format(dateLayout),
-		)
-	}
-
-	fmt.Println()
-	fmt.Printf("Summary: planned=%d applied=%d failed=0\n", len(rows), len(rows))
-}
-
-func parseManualInputFile(
-	filePath string,
-	requestedSheet string,
-	location *time.Location,
-) (string, []manualInputImportRow, []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: "header", Message: "sheet is empty"},
-		}, nil
-	}
-
-	indexes, headerIssues := parseHeaderIndexes(allRows[0])
-	if len(headerIssues) > 0 {
-		return sheetName, nil, headerIssues, nil
-	}
-
-	rows := make([]manualInputImportRow, 0, len(allRows)-1)
-	issues := make([]validationIssue, 0)
-	seenProjectFlockIDs := make(map[uint]int)
-
-	for idx := 1; idx < len(allRows); idx++ {
-		rowNumber := idx + 1
-		rawRow := allRows[idx]
-
-		if isRowEmpty(rawRow) {
-			continue
-		}
-
-		parsed, rowIssues := parseDataRow(rawRow, rowNumber, indexes, location, seenProjectFlockIDs)
-		if len(rowIssues) > 0 {
-			issues = append(issues, rowIssues...)
-			continue
-		}
-
-		rows = append(rows, *parsed)
-	}
-
-	if len(rows) == 0 && len(issues) == 0 {
-		issues = append(issues, validationIssue{
-			Field:   "rows",
-			Message: "no data rows found",
-		})
-	}
-
-	return sheetName, rows, issues, nil
-}
-
-func resolveSheetName(workbook *excelize.File, requestedSheet string) (string, error) {
-	if workbook == nil {
-		return "", fmt.Errorf("workbook is nil")
-	}
-
-	sheets := workbook.GetSheetList()
-	if len(sheets) == 0 {
-		return "", fmt.Errorf("workbook has no sheets")
-	}
-
-	if 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 parseHeaderIndexes(headerRow []string) (headerIndexes, []validationIssue) {
-	indexes := headerIndexes{
-		ProjectFlockID: -1,
-		TotalCost:      -1,
-		CutoverDate:    -1,
-		Note:           -1,
-	}
-	issues := make([]validationIssue, 0)
-
-	for idx, raw := range headerRow {
-		header := normalizeHeader(raw)
-		if header == "" {
-			continue
-		}
-
-		switch header {
-		case "project_flock_id":
-			if indexes.ProjectFlockID >= 0 {
-				issues = append(issues, validationIssue{
-					Field:   "header",
-					Message: "duplicate header project_flock_id",
-				})
-			}
-			indexes.ProjectFlockID = idx
-		case "total_cost":
-			if indexes.TotalCost >= 0 {
-				issues = append(issues, validationIssue{
-					Field:   "header",
-					Message: "duplicate header total_cost",
-				})
-			}
-			indexes.TotalCost = idx
-		case "cutover_date":
-			if indexes.CutoverDate >= 0 {
-				issues = append(issues, validationIssue{
-					Field:   "header",
-					Message: "duplicate header cutover_date",
-				})
-			}
-			indexes.CutoverDate = idx
-		case "note":
-			if indexes.Note >= 0 {
-				issues = append(issues, validationIssue{
-					Field:   "header",
-					Message: "duplicate header note",
-				})
-			}
-			indexes.Note = idx
-		}
-	}
-
-	if indexes.ProjectFlockID < 0 {
-		issues = append(issues, validationIssue{
-			Field:   "project_flock_id",
-			Message: "required header is missing",
-		})
-	}
-	if indexes.TotalCost < 0 {
-		issues = append(issues, validationIssue{
-			Field:   "total_cost",
-			Message: "required header is missing",
-		})
-	}
-	if indexes.CutoverDate < 0 {
-		issues = append(issues, validationIssue{
-			Field:   "cutover_date",
-			Message: "required header is missing",
-		})
-	}
-
-	return indexes, issues
-}
-
-func parseDataRow(
-	rawRow []string,
-	rowNumber int,
-	indexes headerIndexes,
-	location *time.Location,
-	seenProjectFlockIDs map[uint]int,
-) (*manualInputImportRow, []validationIssue) {
-	issues := make([]validationIssue, 0)
-
-	projectFlockIDRaw := strings.TrimSpace(cellValue(rawRow, indexes.ProjectFlockID))
-	projectFlockID, err := parsePositiveUint(projectFlockIDRaw)
-	if err != nil {
-		issues = append(issues, validationIssue{
-			Row:     rowNumber,
-			Field:   "project_flock_id",
-			Message: err.Error(),
-		})
-	}
-
-	totalCostRaw := strings.TrimSpace(cellValue(rawRow, indexes.TotalCost))
-	totalCost, err := parseNonNegativeFloat(totalCostRaw)
-	if err != nil {
-		issues = append(issues, validationIssue{
-			Row:     rowNumber,
-			Field:   "total_cost",
-			Message: err.Error(),
-		})
-	}
-
-	cutoverDateRaw := strings.TrimSpace(cellValue(rawRow, indexes.CutoverDate))
-	cutoverDate, err := parseDateOnlyInLocation(cutoverDateRaw, location)
-	if err != nil {
-		issues = append(issues, validationIssue{
-			Row:     rowNumber,
-			Field:   "cutover_date",
-			Message: err.Error(),
-		})
-	}
-
-	var note *string
-	noteRaw := strings.TrimSpace(cellValue(rawRow, indexes.Note))
-	if noteRaw != "" {
-		if len([]rune(noteRaw)) > 1000 {
-			issues = append(issues, validationIssue{
-				Row:     rowNumber,
-				Field:   "note",
-				Message: "must have at most 1000 characters",
-			})
-		} else {
-			note = &noteRaw
-		}
-	}
-
-	if projectFlockID > 0 {
-		if previousRow, exists := seenProjectFlockIDs[projectFlockID]; exists {
-			issues = append(issues, validationIssue{
-				Row:     rowNumber,
-				Field:   "project_flock_id",
-				Message: fmt.Sprintf("duplicate value %d (already used in row %d)", projectFlockID, previousRow),
-			})
-		} else {
-			seenProjectFlockIDs[projectFlockID] = rowNumber
-		}
-	}
-
-	if len(issues) > 0 {
-		return nil, issues
-	}
-
-	return &manualInputImportRow{
-		RowNumber:      rowNumber,
-		ProjectFlockID: projectFlockID,
-		TotalCost:      totalCost,
-		CutoverDate:    cutoverDate,
-		Note:           note,
-	}, nil
-}
-
-func parsePositiveUint(raw string) (uint, error) {
-	if raw == "" {
-		return 0, fmt.Errorf("is required")
-	}
-
-	uintValue, err := strconv.ParseUint(raw, 10, 64)
-	if err == nil {
-		if uintValue == 0 {
-			return 0, fmt.Errorf("must be greater than 0")
-		}
-		return uint(uintValue), nil
-	}
-
-	floatValue, floatErr := strconv.ParseFloat(raw, 64)
-	if floatErr != nil {
-		return 0, fmt.Errorf("must be a positive integer")
-	}
-	if floatValue <= 0 {
-		return 0, fmt.Errorf("must be greater than 0")
-	}
-	if floatValue != float64(uint(floatValue)) {
-		return 0, fmt.Errorf("must be a positive integer")
-	}
-
-	return uint(floatValue), nil
-}
-
-func parseNonNegativeFloat(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 {
-		return 0, fmt.Errorf("must be greater than or equal to 0")
-	}
-
-	return value, nil
-}
-
-func parseDateOnlyInLocation(raw string, location *time.Location) (time.Time, error) {
-	if raw == "" {
-		return time.Time{}, fmt.Errorf("is required")
-	}
-	value, err := time.ParseInLocation(dateLayout, raw, location)
-	if err != nil {
-		return time.Time{}, fmt.Errorf("must follow format YYYY-MM-DD")
-	}
-	return value, nil
-}
-
-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 collectProjectFlockIDs(rows []manualInputImportRow) []uint {
-	ids := make([]uint, 0, len(rows))
-	seen := make(map[uint]struct{}, len(rows))
-	for _, row := range rows {
-		if row.ProjectFlockID == 0 {
-			continue
-		}
-		if _, exists := seen[row.ProjectFlockID]; exists {
-			continue
-		}
-		seen[row.ProjectFlockID] = struct{}{}
-		ids = append(ids, row.ProjectFlockID)
-	}
-	sort.Slice(ids, func(i, j int) bool {
-		return ids[i] < ids[j]
-	})
-	return ids
-}
-
-func (r dbFarmResolver) ResolveActiveLayingFarms(
-	ctx context.Context,
-	projectFlockIDs []uint,
-) (map[uint]string, error) {
-	result := make(map[uint]string)
-	if len(projectFlockIDs) == 0 {
-		return result, nil
-	}
-
-	rows := make([]farmIdentityRow, 0, len(projectFlockIDs))
-	if err := r.db.WithContext(ctx).
-		Table("project_flocks").
-		Select("id, flock_name AS farm_name").
-		Where("id IN ?", projectFlockIDs).
-		Where("deleted_at IS NULL").
-		Where("category = ?", utils.ProjectFlockCategoryLaying).
-		Scan(&rows).Error; err != nil {
-		return nil, err
-	}
-
-	for _, row := range rows {
-		result[row.ID] = row.FarmName
-	}
-
-	return result, nil
-}
-
-func buildMissingFarmIssues(rows []manualInputImportRow, farmNameByID map[uint]string) []validationIssue {
-	issues := make([]validationIssue, 0)
-	for _, row := range rows {
-		if _, exists := farmNameByID[row.ProjectFlockID]; exists {
-			continue
-		}
-		issues = append(issues, validationIssue{
-			Row:     row.RowNumber,
-			Field:   "project_flock_id",
-			Message: fmt.Sprintf("value %d must reference an active LAYING project_flock", row.ProjectFlockID),
-		})
-	}
-	return issues
-}
-
-func printPlanRows(rows []manualInputImportRow, farmNameByID map[uint]string) {
-	for _, row := range rows {
-		farmName := farmNameByID[row.ProjectFlockID]
-		fmt.Printf(
-			"PLAN row=%d project_flock_id=%d farm_name=%q total_cost=%.3f cutover_date=%s note=%q\n",
-			row.RowNumber,
-			row.ProjectFlockID,
-			farmName,
-			row.TotalCost,
-			row.CutoverDate.Format(dateLayout),
-			derefString(row.Note),
-		)
-	}
-}
-
-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 applyIfRequested(ctx context.Context, apply bool, runner txRunner, rows []manualInputImportRow) error {
-	if !apply || len(rows) == 0 {
-		return nil
-	}
-	return applyImportRows(ctx, runner, rows)
-}
-
-func applyImportRows(ctx context.Context, runner txRunner, rows []manualInputImportRow) error {
-	return runner.InTx(ctx, func(store manualInputStore) error {
-		for _, row := range rows {
-			payload := entity.FarmDepreciationManualInput{
-				ProjectFlockId: row.ProjectFlockID,
-				TotalCost:      row.TotalCost,
-				CutoverDate:    row.CutoverDate,
-				Note:           row.Note,
-			}
-
-			if err := store.UpsertManualInput(ctx, &payload); err != nil {
-				return fmt.Errorf("row %d project_flock_id=%d upsert failed: %w", row.RowNumber, row.ProjectFlockID, err)
-			}
-
-			if err := store.DeleteSnapshotsFromDate(ctx, row.CutoverDate, []uint{row.ProjectFlockID}); err != nil {
-				return fmt.Errorf("row %d project_flock_id=%d snapshot invalidation failed: %w", row.RowNumber, row.ProjectFlockID, err)
-			}
-		}
-		return nil
-	})
-}
-
-func (r dbTxRunner) InTx(ctx context.Context, fn func(store manualInputStore) error) error {
-	return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		repo := repportRepo.NewExpenseDepreciationRepository(tx)
-		store := expenseDepreciationStore{repo: repo}
-		return fn(store)
-	})
-}
-
-func (s expenseDepreciationStore) UpsertManualInput(ctx context.Context, row *entity.FarmDepreciationManualInput) error {
-	return s.repo.UpsertManualInput(ctx, row)
-}
-
-func (s expenseDepreciationStore) DeleteSnapshotsFromDate(ctx context.Context, fromDate time.Time, farmIDs []uint) error {
-	return s.repo.DeleteSnapshotsFromDate(ctx, fromDate, farmIDs)
-}
-
-func modeLabel(apply bool) string {
-	if apply {
-		return "APPLY"
-	}
-	return "DRY-RUN"
-}
-
-func derefString(value *string) string {
-	if value == nil {
-		return ""
-	}
-	return *value
-}

cmd/import-farm-depreciation-manual-inputs/main_test.go

@@ -1,563 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/xuri/excelize/v2"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-)
-
-func TestParseManualInputFile_ValidSingleRow(t *testing.T) {
-	filePath := createManualInputWorkbook(
-		t,
-		"manual_inputs",
-		[]string{"project_flock_id", "total_cost", "cutover_date", "note"},
-		[][]string{
-			{"101", "12345.678", "2026-06-01", "manual seed"},
-		},
-	)
-
-	location := mustJakartaLocation(t)
-	sheet, rows, issues, err := parseManualInputFile(filePath, "", location)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if sheet != "manual_inputs" {
-		t.Fatalf("expected selected sheet manual_inputs, got %q", sheet)
-	}
-	if len(issues) != 0 {
-		t.Fatalf("expected no issues, got %+v", issues)
-	}
-	if len(rows) != 1 {
-		t.Fatalf("expected 1 row, got %d", len(rows))
-	}
-	if rows[0].ProjectFlockID != 101 {
-		t.Fatalf("expected project_flock_id 101, got %d", rows[0].ProjectFlockID)
-	}
-	if rows[0].TotalCost != 12345.678 {
-		t.Fatalf("expected total_cost 12345.678, got %v", rows[0].TotalCost)
-	}
-	if rows[0].CutoverDate.Format(dateLayout) != "2026-06-01" {
-		t.Fatalf("expected cutover_date 2026-06-01, got %s", rows[0].CutoverDate.Format(dateLayout))
-	}
-	if rows[0].Note == nil || *rows[0].Note != "manual seed" {
-		t.Fatalf("expected note manual seed, got %+v", rows[0].Note)
-	}
-}
-
-func TestParseManualInputFile_ValidMultiRow(t *testing.T) {
-	filePath := createManualInputWorkbook(
-		t,
-		"manual_inputs",
-		[]string{" Project_Flock_ID ", "TOTAL_COST", "cutover_date", "NOTE"},
-		[][]string{
-			{"101", "1200", "2026-06-01", ""},
-			{"102", "1300.5", "2026-06-02", "second"},
-		},
-	)
-
-	location := mustJakartaLocation(t)
-	_, rows, issues, err := parseManualInputFile(filePath, "manual_inputs", location)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(issues) != 0 {
-		t.Fatalf("expected no issues, got %+v", issues)
-	}
-	if len(rows) != 2 {
-		t.Fatalf("expected 2 rows, got %d", len(rows))
-	}
-	if rows[0].Note != nil {
-		t.Fatalf("expected first row note nil, got %+v", rows[0].Note)
-	}
-	if rows[1].Note == nil || *rows[1].Note != "second" {
-		t.Fatalf("expected second row note second, got %+v", rows[1].Note)
-	}
-}
-
-func TestParseManualInputFile_MissingRequiredHeader(t *testing.T) {
-	filePath := createManualInputWorkbook(
-		t,
-		"manual_inputs",
-		[]string{"project_flock_id", "totalcost", "cutover_date", "note"},
-		[][]string{
-			{"101", "1200", "2026-06-01", ""},
-		},
-	)
-
-	location := mustJakartaLocation(t)
-	_, rows, issues, err := parseManualInputFile(filePath, "", location)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(rows) != 0 {
-		t.Fatalf("expected 0 parsed rows when header invalid, got %d", len(rows))
-	}
-	if !hasIssue(issues, 0, "total_cost", "required header is missing") {
-		t.Fatalf("expected missing total_cost header issue, got %+v", issues)
-	}
-}
-
-func TestParseManualInputFile_InvalidProjectFlockID(t *testing.T) {
-	filePath := createManualInputWorkbook(
-		t,
-		"manual_inputs",
-		[]string{"project_flock_id", "total_cost", "cutover_date", "note"},
-		[][]string{
-			{"abc", "1200", "2026-06-01", ""},
-			{"0", "1300", "2026-06-02", ""},
-		},
-	)
-
-	location := mustJakartaLocation(t)
-	_, rows, issues, err := parseManualInputFile(filePath, "", location)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(rows) != 0 {
-		t.Fatalf("expected no valid rows, got %d", len(rows))
-	}
-	if !hasIssue(issues, 2, "project_flock_id", "must be a positive integer") {
-		t.Fatalf("expected non numeric project_flock_id issue, got %+v", issues)
-	}
-	if !hasIssue(issues, 3, "project_flock_id", "must be greater than 0") {
-		t.Fatalf("expected project_flock_id >0 issue, got %+v", issues)
-	}
-}
-
-func TestParseManualInputFile_InvalidTotalCost(t *testing.T) {
-	filePath := createManualInputWorkbook(
-		t,
-		"manual_inputs",
-		[]string{"project_flock_id", "total_cost", "cutover_date", "note"},
-		[][]string{
-			{"101", "abc", "2026-06-01", ""},
-			{"102", "-1", "2026-06-02", ""},
-		},
-	)
-
-	location := mustJakartaLocation(t)
-	_, rows, issues, err := parseManualInputFile(filePath, "", location)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(rows) != 0 {
-		t.Fatalf("expected no valid rows, got %d", len(rows))
-	}
-	if !hasIssue(issues, 2, "total_cost", "must be numeric") {
-		t.Fatalf("expected total_cost numeric issue, got %+v", issues)
-	}
-	if !hasIssue(issues, 3, "total_cost", "must be greater than or equal to 0") {
-		t.Fatalf("expected total_cost >=0 issue, got %+v", issues)
-	}
-}
-
-func TestParseManualInputFile_InvalidCutoverDate(t *testing.T) {
-	filePath := createManualInputWorkbook(
-		t,
-		"manual_inputs",
-		[]string{"project_flock_id", "total_cost", "cutover_date", "note"},
-		[][]string{
-			{"101", "1200", "06-01-2026", ""},
-		},
-	)
-
-	location := mustJakartaLocation(t)
-	_, rows, issues, err := parseManualInputFile(filePath, "", location)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(rows) != 0 {
-		t.Fatalf("expected no valid rows, got %d", len(rows))
-	}
-	if !hasIssue(issues, 2, "cutover_date", "must follow format YYYY-MM-DD") {
-		t.Fatalf("expected cutover_date format issue, got %+v", issues)
-	}
-}
-
-func TestParseManualInputFile_DuplicateProjectFlockID(t *testing.T) {
-	filePath := createManualInputWorkbook(
-		t,
-		"manual_inputs",
-		[]string{"project_flock_id", "total_cost", "cutover_date", "note"},
-		[][]string{
-			{"101", "1200", "2026-06-01", ""},
-			{"101", "1300", "2026-06-02", ""},
-		},
-	)
-
-	location := mustJakartaLocation(t)
-	_, rows, issues, err := parseManualInputFile(filePath, "", location)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(rows) != 1 {
-		t.Fatalf("expected first row valid and second row invalid, got %d rows", len(rows))
-	}
-	if !hasIssue(issues, 3, "project_flock_id", "duplicate value 101") {
-		t.Fatalf("expected duplicate project_flock_id issue, got %+v", issues)
-	}
-}
-
-func TestParseManualInputFile_NoteValidation(t *testing.T) {
-	longNote := strings.Repeat("a", 1001)
-	filePath := createManualInputWorkbook(
-		t,
-		"manual_inputs",
-		[]string{"project_flock_id", "total_cost", "cutover_date", "note"},
-		[][]string{
-			{"101", "1200", "2026-06-01", ""},
-			{"102", "1300", "2026-06-02", longNote},
-		},
-	)
-
-	location := mustJakartaLocation(t)
-	_, rows, issues, err := parseManualInputFile(filePath, "", location)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(rows) != 1 {
-		t.Fatalf("expected only first row valid, got %d", len(rows))
-	}
-	if rows[0].Note != nil {
-		t.Fatalf("expected first row note nil, got %+v", rows[0].Note)
-	}
-	if !hasIssue(issues, 3, "note", "at most 1000 characters") {
-		t.Fatalf("expected note length issue, got %+v", issues)
-	}
-}
-
-func TestApplyImportRows_Success(t *testing.T) {
-	location := mustJakartaLocation(t)
-	runner := &fakeTransactionRunner{}
-	rows := []manualInputImportRow{
-		{
-			RowNumber:      2,
-			ProjectFlockID: 101,
-			TotalCost:      1000,
-			CutoverDate:    mustDateInLocation(t, "2026-06-01", location),
-		},
-		{
-			RowNumber:      3,
-			ProjectFlockID: 102,
-			TotalCost:      2000,
-			CutoverDate:    mustDateInLocation(t, "2026-06-02", location),
-		},
-	}
-
-	err := applyImportRows(context.Background(), runner, rows)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if runner.txCalls != 1 {
-		t.Fatalf("expected 1 transaction call, got %d", runner.txCalls)
-	}
-	if len(runner.committedUpserts) != 2 {
-		t.Fatalf("expected 2 committed upserts, got %d", len(runner.committedUpserts))
-	}
-	if len(runner.committedInvalidations) != 2 {
-		t.Fatalf("expected 2 committed invalidations, got %d", len(runner.committedInvalidations))
-	}
-	if runner.committedInvalidations[0].farmIDs[0] != 101 || runner.committedInvalidations[1].farmIDs[0] != 102 {
-		t.Fatalf("unexpected invalidation farm IDs: %+v", runner.committedInvalidations)
-	}
-}
-
-func TestApplyImportRows_RollbackOnError(t *testing.T) {
-	location := mustJakartaLocation(t)
-	runner := &fakeTransactionRunner{
-		failUpsertOnProjectFlockID: 102,
-	}
-	rows := []manualInputImportRow{
-		{
-			RowNumber:      2,
-			ProjectFlockID: 101,
-			TotalCost:      1000,
-			CutoverDate:    mustDateInLocation(t, "2026-06-01", location),
-		},
-		{
-			RowNumber:      3,
-			ProjectFlockID: 102,
-			TotalCost:      2000,
-			CutoverDate:    mustDateInLocation(t, "2026-06-02", location),
-		},
-	}
-
-	err := applyImportRows(context.Background(), runner, rows)
-	if err == nil {
-		t.Fatal("expected error due to upsert failure")
-	}
-	if runner.txCalls != 1 {
-		t.Fatalf("expected 1 transaction call, got %d", runner.txCalls)
-	}
-	if len(runner.committedUpserts) != 0 {
-		t.Fatalf("expected no committed upserts on rollback, got %d", len(runner.committedUpserts))
-	}
-	if len(runner.committedInvalidations) != 0 {
-		t.Fatalf("expected no committed invalidations on rollback, got %d", len(runner.committedInvalidations))
-	}
-}
-
-func TestApplyIfRequested_DryRunDoesNotWrite(t *testing.T) {
-	location := mustJakartaLocation(t)
-	runner := &fakeTransactionRunner{}
-	rows := []manualInputImportRow{
-		{
-			RowNumber:      2,
-			ProjectFlockID: 101,
-			TotalCost:      1000,
-			CutoverDate:    mustDateInLocation(t, "2026-06-01", location),
-		},
-	}
-
-	err := applyIfRequested(context.Background(), false, runner, rows)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if runner.txCalls != 0 {
-		t.Fatalf("expected no transaction call during dry-run, got %d", runner.txCalls)
-	}
-}
-
-func createManualInputWorkbook(t *testing.T, sheetName string, headers []string, rows [][]string) string {
-	t.Helper()
-
-	f := excelize.NewFile()
-	defaultSheet := f.GetSheetName(f.GetActiveSheetIndex())
-	if sheetName == "" {
-		sheetName = defaultSheet
-	} else if sheetName != defaultSheet {
-		f.SetSheetName(defaultSheet, sheetName)
-	}
-
-	for idx, header := range headers {
-		cell, err := excelize.CoordinatesToCellName(idx+1, 1)
-		if err != nil {
-			t.Fatalf("failed resolving header cell: %v", err)
-		}
-		if err := f.SetCellValue(sheetName, cell, header); err != nil {
-			t.Fatalf("failed setting header cell: %v", err)
-		}
-	}
-
-	for rowIdx, row := range rows {
-		for colIdx, value := range row {
-			cell, err := excelize.CoordinatesToCellName(colIdx+1, rowIdx+2)
-			if err != nil {
-				t.Fatalf("failed resolving data cell: %v", err)
-			}
-			if err := f.SetCellValue(sheetName, cell, value); err != nil {
-				t.Fatalf("failed setting data cell: %v", err)
-			}
-		}
-	}
-
-	path := filepath.Join(t.TempDir(), "manual_inputs.xlsx")
-	if err := f.SaveAs(path); err != nil {
-		t.Fatalf("failed saving workbook: %v", err)
-	}
-	if err := f.Close(); err != nil {
-		t.Fatalf("failed closing workbook: %v", err)
-	}
-
-	return path
-}
-
-func mustJakartaLocation(t *testing.T) *time.Location {
-	t.Helper()
-	location, err := time.LoadLocation("Asia/Jakarta")
-	if err != nil {
-		t.Fatalf("failed loading Asia/Jakarta location: %v", err)
-	}
-	return location
-}
-
-func mustDateInLocation(t *testing.T, raw string, location *time.Location) time.Time {
-	t.Helper()
-	value, err := time.ParseInLocation(dateLayout, raw, location)
-	if err != nil {
-		t.Fatalf("failed parsing date %q: %v", raw, err)
-	}
-	return value
-}
-
-func hasIssue(issues []validationIssue, row int, field, messageContains string) bool {
-	for _, issue := range issues {
-		if issue.Row != row {
-			continue
-		}
-		if issue.Field != field {
-			continue
-		}
-		if strings.Contains(issue.Message, messageContains) {
-			return true
-		}
-	}
-	return false
-}
-
-type fakeInvalidation struct {
-	fromDate time.Time
-	farmIDs  []uint
-}
-
-type fakeManualInputStore struct {
-	failUpsertOnProjectFlockID uint
-	failDeleteOnProjectFlockID uint
-	upserts                    []entity.FarmDepreciationManualInput
-	invalidations              []fakeInvalidation
-}
-
-func (s *fakeManualInputStore) UpsertManualInput(_ context.Context, row *entity.FarmDepreciationManualInput) error {
-	if row == nil {
-		return nil
-	}
-	if s.failUpsertOnProjectFlockID > 0 && row.ProjectFlockId == s.failUpsertOnProjectFlockID {
-		return fmt.Errorf("forced upsert failure for project_flock_id=%d", row.ProjectFlockId)
-	}
-	cloned := *row
-	s.upserts = append(s.upserts, cloned)
-	return nil
-}
-
-func (s *fakeManualInputStore) DeleteSnapshotsFromDate(_ context.Context, fromDate time.Time, farmIDs []uint) error {
-	if s.failDeleteOnProjectFlockID > 0 {
-		for _, farmID := range farmIDs {
-			if farmID == s.failDeleteOnProjectFlockID {
-				return fmt.Errorf("forced delete failure for project_flock_id=%d", farmID)
-			}
-		}
-	}
-	copiedFarmIDs := append([]uint{}, farmIDs...)
-	s.invalidations = append(s.invalidations, fakeInvalidation{
-		fromDate: fromDate,
-		farmIDs:  copiedFarmIDs,
-	})
-	return nil
-}
-
-type fakeTransactionRunner struct {
-	txCalls                    int
-	failUpsertOnProjectFlockID uint
-	failDeleteOnProjectFlockID uint
-	committedUpserts           []entity.FarmDepreciationManualInput
-	committedInvalidations     []fakeInvalidation
-}
-
-func (r *fakeTransactionRunner) InTx(ctx context.Context, fn func(store manualInputStore) error) error {
-	r.txCalls++
-
-	txStore := &fakeManualInputStore{
-		failUpsertOnProjectFlockID: r.failUpsertOnProjectFlockID,
-		failDeleteOnProjectFlockID: r.failDeleteOnProjectFlockID,
-	}
-
-	if err := fn(txStore); err != nil {
-		return err
-	}
-
-	r.committedUpserts = append(r.committedUpserts, txStore.upserts...)
-	r.committedInvalidations = append(r.committedInvalidations, txStore.invalidations...)
-	return nil
-}
-
-var _ txRunner = (*fakeTransactionRunner)(nil)
-var _ manualInputStore = (*fakeManualInputStore)(nil)
-
-func TestBuildMissingFarmIssues(t *testing.T) {
-	location := mustJakartaLocation(t)
-	rows := []manualInputImportRow{
-		{
-			RowNumber:      2,
-			ProjectFlockID: 101,
-			TotalCost:      1000,
-			CutoverDate:    mustDateInLocation(t, "2026-06-01", location),
-		},
-		{
-			RowNumber:      3,
-			ProjectFlockID: 102,
-			TotalCost:      1000,
-			CutoverDate:    mustDateInLocation(t, "2026-06-01", location),
-		},
-	}
-
-	issues := buildMissingFarmIssues(rows, map[uint]string{
-		101: "Farm A",
-	})
-	if len(issues) != 1 {
-		t.Fatalf("expected 1 issue, got %+v", issues)
-	}
-	if issues[0].Row != 3 || issues[0].Field != "project_flock_id" {
-		t.Fatalf("unexpected issue: %+v", issues[0])
-	}
-}
-
-func TestApplyImportRows_PropagatesDeleteError(t *testing.T) {
-	location := mustJakartaLocation(t)
-	runner := &fakeTransactionRunner{
-		failDeleteOnProjectFlockID: 101,
-	}
-	rows := []manualInputImportRow{
-		{
-			RowNumber:      2,
-			ProjectFlockID: 101,
-			TotalCost:      1000,
-			CutoverDate:    mustDateInLocation(t, "2026-06-01", location),
-		},
-	}
-
-	err := applyImportRows(context.Background(), runner, rows)
-	if err == nil {
-		t.Fatal("expected delete failure")
-	}
-	if !strings.Contains(err.Error(), "snapshot invalidation failed") {
-		t.Fatalf("expected snapshot invalidation error message, got %v", err)
-	}
-}
-
-func TestResolveSheetName_ErrorWhenSheetNotFound(t *testing.T) {
-	workbook := excelize.NewFile()
-	defer func() {
-		_ = workbook.Close()
-	}()
-
-	_, err := resolveSheetName(workbook, "unknown")
-	if err == nil {
-		t.Fatal("expected error when sheet is missing")
-	}
-}
-
-func TestApplyIfRequested_ApplyUsesRunnerError(t *testing.T) {
-	location := mustJakartaLocation(t)
-	rows := []manualInputImportRow{
-		{
-			RowNumber:      2,
-			ProjectFlockID: 101,
-			TotalCost:      1000,
-			CutoverDate:    mustDateInLocation(t, "2026-06-01", location),
-		},
-	}
-	runner := &errorTxRunner{err: errors.New("tx failed")}
-
-	err := applyIfRequested(context.Background(), true, runner, rows)
-	if err == nil {
-		t.Fatal("expected transaction error")
-	}
-	if err.Error() != "tx failed" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-type errorTxRunner struct {
-	err error
-}
-
-func (r *errorTxRunner) InTx(_ context.Context, _ func(store manualInputStore) error) error {
-	return r.err
-}

cmd/import-kandang-house-types/main.go

@@ -1,602 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"sort"
-	"strconv"
-	"strings"
-
-	"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"
-)
-
-type importOptions struct {
-	FilePath string
-	Sheet    string
-	Apply    bool
-}
-
-type headerIndexes struct {
-	KandangID   int
-	KandangName int
-	HouseType   int
-}
-
-type kandangHouseTypeImportRow struct {
-	RowNumber   int
-	KandangID   uint
-	KandangName string
-	HouseType   string
-}
-
-type validationIssue struct {
-	Row     int
-	Field   string
-	Message string
-}
-
-func (i validationIssue) Error() 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)
-}
-
-type kandangResolver interface {
-	ResolveActiveKandangs(ctx context.Context, kandangIDs []uint) (map[uint]string, error)
-}
-
-type dbKandangResolver struct {
-	db *gorm.DB
-}
-
-type txRunner interface {
-	InTx(ctx context.Context, fn func(store kandangHouseTypeStore) error) error
-}
-
-type dbTxRunner struct {
-	db *gorm.DB
-}
-
-type kandangHouseTypeStore interface {
-	UpdateKandangHouseType(ctx context.Context, kandangID uint, houseType string) (bool, error)
-	NormalizeNullHouseType(ctx context.Context) (int64, error)
-}
-
-type dbKandangHouseTypeStore struct {
-	db *gorm.DB
-}
-
-type kandangIdentityRow struct {
-	ID   uint   `gorm:"column:id"`
-	Name string `gorm:"column:name"`
-}
-
-type applyRowResult struct {
-	RowNumber int
-	KandangID uint
-	HouseType string
-	Changed   bool
-}
-
-func main() {
-	var opts importOptions
-	flag.StringVar(&opts.FilePath, "file", "", "Path to .xlsx file (required)")
-	flag.StringVar(&opts.Sheet, "sheet", "", "Sheet name (optional, default: first sheet)")
-	flag.BoolVar(&opts.Apply, "apply", false, "Apply changes. If false, run as dry-run")
-	flag.Parse()
-
-	opts.FilePath = strings.TrimSpace(opts.FilePath)
-	opts.Sheet = strings.TrimSpace(opts.Sheet)
-
-	if opts.FilePath == "" {
-		log.Fatal("--file is required")
-	}
-
-	sheetName, rows, parseIssues, err := parseKandangHouseTypeFile(opts.FilePath, opts.Sheet)
-	if err != nil {
-		log.Fatalf("failed reading excel: %v", err)
-	}
-
-	ctx := context.Background()
-	db := database.Connect(config.DBHost, config.DBName)
-	resolver := dbKandangResolver{db: db}
-
-	kandangNameByID, err := resolver.ResolveActiveKandangs(ctx, collectKandangIDs(rows))
-	if err != nil {
-		log.Fatalf("failed validating kandang_id against kandangs: %v", err)
-	}
-
-	issues := append([]validationIssue{}, parseIssues...)
-	issues = append(issues, buildMissingKandangIssues(rows, kandangNameByID)...)
-	issues = append(issues, buildNameMismatchIssues(rows, kandangNameByID)...)
-	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("Rows parsed: %d\n", len(rows))
-	fmt.Printf("Rows invalid: %d\n", len(issues))
-	fmt.Println()
-
-	if len(rows) > 0 {
-		printPlanRows(rows, kandangNameByID)
-		fmt.Println()
-	}
-
-	if len(issues) > 0 {
-		fmt.Println("Validation errors:")
-		for _, issue := range issues {
-			fmt.Printf("ERROR %s\n", issue.Error())
-		}
-		fmt.Println()
-		fmt.Printf("Summary: planned=%d applied=0 normalized_null_to_open_house=0 failed=%d\n", len(rows), len(issues))
-		os.Exit(1)
-	}
-
-	if !opts.Apply {
-		fmt.Printf("Summary: planned=%d applied=0 normalized_null_to_open_house=0 failed=0\n", len(rows))
-		return
-	}
-
-	rowResults, normalizedCount, err := applyImportRows(ctx, dbTxRunner{db: db}, rows)
-	if err != nil {
-		log.Fatalf("apply failed: %v", err)
-	}
-
-	for _, result := range rowResults {
-		fmt.Printf(
-			"DONE row=%d kandang_id=%d house_type=%s status=%s\n",
-			result.RowNumber,
-			result.KandangID,
-			result.HouseType,
-			applyStatus(result.Changed),
-		)
-	}
-
-	appliedCount := countChangedRows(rowResults)
-	fmt.Println()
-	fmt.Printf(
-		"Summary: planned=%d applied=%d normalized_null_to_open_house=%d failed=0\n",
-		len(rows),
-		appliedCount,
-		normalizedCount,
-	)
-}
-
-func parseKandangHouseTypeFile(
-	filePath string,
-	requestedSheet string,
-) (string, []kandangHouseTypeImportRow, []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: "header", Message: "sheet is empty"}}, nil
-	}
-
-	indexes, headerIssues := parseHeaderIndexes(allRows[0])
-	if len(headerIssues) > 0 {
-		return sheetName, nil, headerIssues, nil
-	}
-
-	rows := make([]kandangHouseTypeImportRow, 0, len(allRows)-1)
-	issues := make([]validationIssue, 0)
-	seenKandangIDs := make(map[uint]int)
-
-	for idx := 1; idx < len(allRows); idx++ {
-		rowNumber := idx + 1
-		rawRow := allRows[idx]
-
-		if isRowEmpty(rawRow) {
-			continue
-		}
-
-		parsed, rowIssues := parseDataRow(rawRow, rowNumber, indexes, seenKandangIDs)
-		if len(rowIssues) > 0 {
-			issues = append(issues, rowIssues...)
-			continue
-		}
-
-		rows = append(rows, *parsed)
-	}
-
-	if len(rows) == 0 && len(issues) == 0 {
-		issues = append(issues, validationIssue{Field: "rows", Message: "no data rows found"})
-	}
-
-	return sheetName, rows, issues, nil
-}
-
-func resolveSheetName(workbook *excelize.File, requestedSheet string) (string, error) {
-	if workbook == nil {
-		return "", fmt.Errorf("workbook is nil")
-	}
-
-	sheets := workbook.GetSheetList()
-	if len(sheets) == 0 {
-		return "", fmt.Errorf("workbook has no sheets")
-	}
-
-	if 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 parseHeaderIndexes(headerRow []string) (headerIndexes, []validationIssue) {
-	indexes := headerIndexes{KandangID: -1, KandangName: -1, HouseType: -1}
-	issues := make([]validationIssue, 0)
-
-	for idx, raw := range headerRow {
-		header := normalizeHeader(raw)
-		if header == "" {
-			continue
-		}
-
-		switch header {
-		case "kandang_id":
-			if indexes.KandangID >= 0 {
-				issues = append(issues, validationIssue{Field: "header", Message: "duplicate header kandang_id"})
-			}
-			indexes.KandangID = idx
-		case "kandang_name":
-			if indexes.KandangName >= 0 {
-				issues = append(issues, validationIssue{Field: "header", Message: "duplicate header kandang_name"})
-			}
-			indexes.KandangName = idx
-		case "house_type", "type_house":
-			if indexes.HouseType >= 0 {
-				issues = append(issues, validationIssue{Field: "header", Message: "duplicate header house_type"})
-			}
-			indexes.HouseType = idx
-		}
-	}
-
-	if indexes.KandangID < 0 {
-		issues = append(issues, validationIssue{Field: "kandang_id", Message: "required header is missing"})
-	}
-	if indexes.KandangName < 0 {
-		issues = append(issues, validationIssue{Field: "kandang_name", Message: "required header is missing"})
-	}
-	if indexes.HouseType < 0 {
-		issues = append(issues, validationIssue{Field: "house_type", Message: "required header is missing"})
-	}
-
-	return indexes, issues
-}
-
-func parseDataRow(
-	rawRow []string,
-	rowNumber int,
-	indexes headerIndexes,
-	seenKandangIDs map[uint]int,
-) (*kandangHouseTypeImportRow, []validationIssue) {
-	issues := make([]validationIssue, 0)
-
-	kandangIDRaw := strings.TrimSpace(cellValue(rawRow, indexes.KandangID))
-	kandangID, err := parsePositiveUint(kandangIDRaw)
-	if err != nil {
-		issues = append(issues, validationIssue{Row: rowNumber, Field: "kandang_id", Message: err.Error()})
-	}
-
-	kandangNameRaw := strings.TrimSpace(cellValue(rawRow, indexes.KandangName))
-	if kandangNameRaw == "" {
-		issues = append(issues, validationIssue{Row: rowNumber, Field: "kandang_name", Message: "is required"})
-	}
-
-	houseTypeRaw := strings.TrimSpace(cellValue(rawRow, indexes.HouseType))
-	houseType, err := normalizeHouseType(houseTypeRaw)
-	if err != nil {
-		issues = append(issues, validationIssue{Row: rowNumber, Field: "house_type", Message: err.Error()})
-	}
-
-	if kandangID > 0 {
-		if previousRow, exists := seenKandangIDs[kandangID]; exists {
-			issues = append(issues, validationIssue{
-				Row:     rowNumber,
-				Field:   "kandang_id",
-				Message: fmt.Sprintf("duplicate value %d (already used in row %d)", kandangID, previousRow),
-			})
-		} else {
-			seenKandangIDs[kandangID] = rowNumber
-		}
-	}
-
-	if len(issues) > 0 {
-		return nil, issues
-	}
-
-	return &kandangHouseTypeImportRow{
-		RowNumber:   rowNumber,
-		KandangID:   kandangID,
-		KandangName: kandangNameRaw,
-		HouseType:   houseType,
-	}, nil
-}
-
-func normalizeHouseType(raw string) (string, error) {
-	normalized := strings.ToLower(strings.TrimSpace(raw))
-	if normalized == "" {
-		return string(utils.HouseTypeOpenHouse), nil
-	}
-
-	switch normalized {
-	case string(utils.HouseTypeOpenHouse), string(utils.HouseTypeCloseHouse):
-		return normalized, nil
-	default:
-		return "", fmt.Errorf("must be one of: open_house, close_house (or empty for default open_house)")
-	}
-}
-
-func parsePositiveUint(raw string) (uint, error) {
-	if raw == "" {
-		return 0, fmt.Errorf("is required")
-	}
-
-	uintValue, err := strconv.ParseUint(raw, 10, 64)
-	if err == nil {
-		if uintValue == 0 {
-			return 0, fmt.Errorf("must be greater than 0")
-		}
-		return uint(uintValue), nil
-	}
-
-	floatValue, floatErr := strconv.ParseFloat(raw, 64)
-	if floatErr != nil {
-		return 0, fmt.Errorf("must be a positive integer")
-	}
-	if floatValue <= 0 {
-		return 0, fmt.Errorf("must be greater than 0")
-	}
-	if floatValue != float64(uint(floatValue)) {
-		return 0, fmt.Errorf("must be a positive integer")
-	}
-
-	return uint(floatValue), nil
-}
-
-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 collectKandangIDs(rows []kandangHouseTypeImportRow) []uint {
-	ids := make([]uint, 0, len(rows))
-	seen := make(map[uint]struct{}, len(rows))
-	for _, row := range rows {
-		if row.KandangID == 0 {
-			continue
-		}
-		if _, exists := seen[row.KandangID]; exists {
-			continue
-		}
-		seen[row.KandangID] = struct{}{}
-		ids = append(ids, row.KandangID)
-	}
-	sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
-	return ids
-}
-
-func (r dbKandangResolver) ResolveActiveKandangs(ctx context.Context, kandangIDs []uint) (map[uint]string, error) {
-	result := make(map[uint]string)
-	if len(kandangIDs) == 0 {
-		return result, nil
-	}
-
-	rows := make([]kandangIdentityRow, 0, len(kandangIDs))
-	if err := r.db.WithContext(ctx).
-		Table("kandangs").
-		Select("id, name").
-		Where("id IN ?", kandangIDs).
-		Where("deleted_at IS NULL").
-		Scan(&rows).Error; err != nil {
-		return nil, err
-	}
-
-	for _, row := range rows {
-		result[row.ID] = row.Name
-	}
-
-	return result, nil
-}
-
-func buildMissingKandangIssues(rows []kandangHouseTypeImportRow, kandangNameByID map[uint]string) []validationIssue {
-	issues := make([]validationIssue, 0)
-	for _, row := range rows {
-		if _, exists := kandangNameByID[row.KandangID]; exists {
-			continue
-		}
-		issues = append(issues, validationIssue{
-			Row:     row.RowNumber,
-			Field:   "kandang_id",
-			Message: fmt.Sprintf("value %d must reference an active kandang", row.KandangID),
-		})
-	}
-	return issues
-}
-
-func buildNameMismatchIssues(rows []kandangHouseTypeImportRow, kandangNameByID map[uint]string) []validationIssue {
-	issues := make([]validationIssue, 0)
-	for _, row := range rows {
-		dbName, exists := kandangNameByID[row.KandangID]
-		if !exists {
-			continue
-		}
-		if strings.EqualFold(strings.TrimSpace(row.KandangName), strings.TrimSpace(dbName)) {
-			continue
-		}
-
-		issues = append(issues, validationIssue{
-			Row:     row.RowNumber,
-			Field:   "kandang_name",
-			Message: fmt.Sprintf("value %q does not match kandang_id %d name %q", row.KandangName, row.KandangID, dbName),
-		})
-	}
-	return issues
-}
-
-func printPlanRows(rows []kandangHouseTypeImportRow, kandangNameByID map[uint]string) {
-	for _, row := range rows {
-		fmt.Printf(
-			"PLAN row=%d kandang_id=%d kandang_name_file=%q kandang_name_db=%q house_type=%q\n",
-			row.RowNumber,
-			row.KandangID,
-			row.KandangName,
-			kandangNameByID[row.KandangID],
-			row.HouseType,
-		)
-	}
-}
-
-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 applyImportRows(
-	ctx context.Context,
-	runner txRunner,
-	rows []kandangHouseTypeImportRow,
-) ([]applyRowResult, int64, error) {
-	results := make([]applyRowResult, 0, len(rows))
-	normalizedNullCount := int64(0)
-
-	err := runner.InTx(ctx, func(store kandangHouseTypeStore) error {
-		for _, row := range rows {
-			changed, err := store.UpdateKandangHouseType(ctx, row.KandangID, row.HouseType)
-			if err != nil {
-				return fmt.Errorf("row %d kandang_id=%d update failed: %w", row.RowNumber, row.KandangID, err)
-			}
-
-			results = append(results, applyRowResult{
-				RowNumber: row.RowNumber,
-				KandangID: row.KandangID,
-				HouseType: row.HouseType,
-				Changed:   changed,
-			})
-		}
-
-		normalized, err := store.NormalizeNullHouseType(ctx)
-		if err != nil {
-			return fmt.Errorf("normalize null house_type to open_house failed: %w", err)
-		}
-		normalizedNullCount = normalized
-
-		return nil
-	})
-	if err != nil {
-		return nil, 0, err
-	}
-
-	return results, normalizedNullCount, nil
-}
-
-func (r dbTxRunner) InTx(ctx context.Context, fn func(store kandangHouseTypeStore) error) error {
-	return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		return fn(dbKandangHouseTypeStore{db: tx})
-	})
-}
-
-func (s dbKandangHouseTypeStore) UpdateKandangHouseType(ctx context.Context, kandangID uint, houseType string) (bool, error) {
-	result := s.db.WithContext(ctx).Exec(`
-		UPDATE kandangs
-		SET house_type = ?::house_type_enum,
-		    updated_at = NOW()
-		WHERE id = ?
-		  AND deleted_at IS NULL
-		  AND house_type IS DISTINCT FROM ?::house_type_enum
-	`, houseType, kandangID, houseType)
-	if result.Error != nil {
-		return false, result.Error
-	}
-	return result.RowsAffected > 0, nil
-}
-
-func (s dbKandangHouseTypeStore) NormalizeNullHouseType(ctx context.Context) (int64, error) {
-	result := s.db.WithContext(ctx).Exec(`
-		UPDATE kandangs
-		SET house_type = 'open_house'::house_type_enum,
-		    updated_at = NOW()
-		WHERE deleted_at IS NULL
-		  AND house_type IS NULL
-	`)
-	if result.Error != nil {
-		return 0, result.Error
-	}
-	return result.RowsAffected, nil
-}
-
-func modeLabel(apply bool) string {
-	if apply {
-		return "APPLY"
-	}
-	return "DRY-RUN"
-}
-
-func applyStatus(changed bool) string {
-	if changed {
-		return "UPDATED"
-	}
-	return "UNCHANGED"
-}
-
-func countChangedRows(results []applyRowResult) int {
-	count := 0
-	for _, item := range results {
-		if item.Changed {
-			count++
-		}
-	}
-	return count
-}

cmd/import-kandang-house-types/main_test.go

@@ -1,280 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/xuri/excelize/v2"
-)
-
-func TestParseKandangHouseTypeFile_ValidSingleRowAndDefaultHouseType(t *testing.T) {
-	filePath := createWorkbook(
-		t,
-		"kandang_house_type",
-		[]string{"kandang_id", "kandang_name", "house_type"},
-		[][]string{{"101", "Kandang A1", ""}},
-	)
-
-	sheet, rows, issues, err := parseKandangHouseTypeFile(filePath, "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if sheet != "kandang_house_type" {
-		t.Fatalf("expected sheet kandang_house_type, got %q", sheet)
-	}
-	if len(issues) != 0 {
-		t.Fatalf("expected no issues, got %+v", issues)
-	}
-	if len(rows) != 1 {
-		t.Fatalf("expected 1 row, got %d", len(rows))
-	}
-	if rows[0].KandangID != 101 {
-		t.Fatalf("expected kandang_id 101, got %d", rows[0].KandangID)
-	}
-	if rows[0].KandangName != "Kandang A1" {
-		t.Fatalf("expected kandang_name Kandang A1, got %q", rows[0].KandangName)
-	}
-	if rows[0].HouseType != "open_house" {
-		t.Fatalf("expected default house_type open_house, got %q", rows[0].HouseType)
-	}
-}
-
-func TestParseKandangHouseTypeFile_TypeHouseHeaderAlias(t *testing.T) {
-	filePath := createWorkbook(
-		t,
-		"kandang_house_type",
-		[]string{"kandang_id", "kandang_name", "type_house"},
-		[][]string{{"101", "Kandang A1", "close_house"}},
-	)
-
-	_, rows, issues, err := parseKandangHouseTypeFile(filePath, "kandang_house_type")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(issues) != 0 {
-		t.Fatalf("expected no issues, got %+v", issues)
-	}
-	if len(rows) != 1 || rows[0].HouseType != "close_house" {
-		t.Fatalf("expected parsed close_house row, got %+v", rows)
-	}
-}
-
-func TestParseKandangHouseTypeFile_InvalidHouseType(t *testing.T) {
-	filePath := createWorkbook(
-		t,
-		"kandang_house_type",
-		[]string{"kandang_id", "kandang_name", "house_type"},
-		[][]string{{"101", "Kandang A1", "semi_house"}},
-	)
-
-	_, rows, issues, err := parseKandangHouseTypeFile(filePath, "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(rows) != 0 {
-		t.Fatalf("expected no valid rows, got %d", len(rows))
-	}
-	if !hasIssue(issues, 2, "house_type", "must be one of") {
-		t.Fatalf("expected invalid house_type issue, got %+v", issues)
-	}
-}
-
-func TestParseKandangHouseTypeFile_DuplicateKandangID(t *testing.T) {
-	filePath := createWorkbook(
-		t,
-		"kandang_house_type",
-		[]string{"kandang_id", "kandang_name", "house_type"},
-		[][]string{
-			{"101", "Kandang A1", "open_house"},
-			{"101", "Kandang A2", "close_house"},
-		},
-	)
-
-	_, rows, issues, err := parseKandangHouseTypeFile(filePath, "")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if len(rows) != 1 {
-		t.Fatalf("expected first row valid and second invalid, got %d", len(rows))
-	}
-	if !hasIssue(issues, 3, "kandang_id", "duplicate value 101") {
-		t.Fatalf("expected duplicate kandang_id issue, got %+v", issues)
-	}
-}
-
-func TestBuildNameMismatchIssues(t *testing.T) {
-	rows := []kandangHouseTypeImportRow{{
-		RowNumber:   2,
-		KandangID:   10,
-		KandangName: "Kandang Salah",
-		HouseType:   "open_house",
-	}}
-
-	issues := buildNameMismatchIssues(rows, map[uint]string{10: "Kandang Benar"})
-	if !hasIssue(issues, 2, "kandang_name", "does not match") {
-		t.Fatalf("expected name mismatch issue, got %+v", issues)
-	}
-}
-
-func TestApplyImportRows_Success(t *testing.T) {
-	store := &fakeStore{
-		changedByID:     map[uint]bool{101: true, 102: false},
-		normalizeResult: 3,
-	}
-	runner := &fakeTransactionRunner{store: store}
-
-	rows := []kandangHouseTypeImportRow{
-		{RowNumber: 2, KandangID: 101, HouseType: "open_house"},
-		{RowNumber: 3, KandangID: 102, HouseType: "close_house"},
-	}
-
-	results, normalized, err := applyImportRows(context.Background(), runner, rows)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if runner.txCalls != 1 {
-		t.Fatalf("expected 1 tx call, got %d", runner.txCalls)
-	}
-	if len(results) != 2 {
-		t.Fatalf("expected 2 row results, got %d", len(results))
-	}
-	if normalized != 3 {
-		t.Fatalf("expected normalized count 3, got %d", normalized)
-	}
-	if !results[0].Changed || results[1].Changed {
-		t.Fatalf("unexpected changed flags: %+v", results)
-	}
-	if len(store.updateCalls) != 2 {
-		t.Fatalf("expected 2 update calls, got %d", len(store.updateCalls))
-	}
-}
-
-func TestApplyImportRows_FailOnUpdate(t *testing.T) {
-	store := &fakeStore{
-		updateErrByID: map[uint]error{101: errors.New("boom")},
-	}
-	runner := &fakeTransactionRunner{store: store}
-
-	rows := []kandangHouseTypeImportRow{{RowNumber: 2, KandangID: 101, HouseType: "open_house"}}
-
-	_, _, err := applyImportRows(context.Background(), runner, rows)
-	if err == nil {
-		t.Fatalf("expected error, got nil")
-	}
-	if !strings.Contains(err.Error(), "update failed") {
-		t.Fatalf("expected update failed error, got %v", err)
-	}
-}
-
-func TestCountChangedRows(t *testing.T) {
-	count := countChangedRows([]applyRowResult{{Changed: true}, {Changed: false}, {Changed: true}})
-	if count != 2 {
-		t.Fatalf("expected 2 changed rows, got %d", count)
-	}
-}
-
-type fakeTransactionRunner struct {
-	store   *fakeStore
-	txCalls int
-}
-
-func (f *fakeTransactionRunner) InTx(_ context.Context, fn func(store kandangHouseTypeStore) error) error {
-	f.txCalls++
-	return fn(f.store)
-}
-
-type updateCall struct {
-	kandangID uint
-	houseType string
-}
-
-type fakeStore struct {
-	updateCalls     []updateCall
-	changedByID     map[uint]bool
-	updateErrByID   map[uint]error
-	normalizeResult int64
-	normalizeErr    error
-}
-
-func (f *fakeStore) UpdateKandangHouseType(_ context.Context, kandangID uint, houseType string) (bool, error) {
-	f.updateCalls = append(f.updateCalls, updateCall{kandangID: kandangID, houseType: houseType})
-	if err, exists := f.updateErrByID[kandangID]; exists {
-		return false, err
-	}
-	if changed, exists := f.changedByID[kandangID]; exists {
-		return changed, nil
-	}
-	return true, nil
-}
-
-func (f *fakeStore) NormalizeNullHouseType(_ context.Context) (int64, error) {
-	if f.normalizeErr != nil {
-		return 0, f.normalizeErr
-	}
-	return f.normalizeResult, nil
-}
-
-func createWorkbook(t *testing.T, sheetName string, headers []string, rows [][]string) string {
-	t.Helper()
-
-	f := excelize.NewFile()
-	if sheetName == "" {
-		sheetName = "Sheet1"
-	}
-	defaultSheet := f.GetSheetName(0)
-	if defaultSheet != sheetName {
-		idx, err := f.NewSheet(sheetName)
-		if err != nil {
-			t.Fatalf("failed creating sheet: %v", err)
-		}
-		f.SetActiveSheet(idx)
-		_ = f.DeleteSheet(defaultSheet)
-	}
-
-	for idx, header := range headers {
-		cell, err := excelize.CoordinatesToCellName(idx+1, 1)
-		if err != nil {
-			t.Fatalf("failed computing header cell: %v", err)
-		}
-		if err := f.SetCellValue(sheetName, cell, header); err != nil {
-			t.Fatalf("failed setting header cell: %v", err)
-		}
-	}
-
-	for rowIdx, row := range rows {
-		for colIdx, value := range row {
-			cell, err := excelize.CoordinatesToCellName(colIdx+1, rowIdx+2)
-			if err != nil {
-				t.Fatalf("failed computing row cell: %v", err)
-			}
-			if err := f.SetCellValue(sheetName, cell, value); err != nil {
-				t.Fatalf("failed setting row cell: %v", err)
-			}
-		}
-	}
-
-	path := filepath.Join(t.TempDir(), "kandang_house_type.xlsx")
-	if err := f.SaveAs(path); err != nil {
-		t.Fatalf("failed saving workbook: %v", err)
-	}
-
-	return path
-}
-
-func hasIssue(issues []validationIssue, row int, field string, contains string) bool {
-	for _, issue := range issues {
-		if issue.Row != row {
-			continue
-		}
-		if issue.Field != field {
-			continue
-		}
-		if strings.Contains(issue.Message, contains) {
-			return true
-		}
-	}
-	return false
-}

cmd/migrate-legacy-egg-adjustment-stock-to-farm/main_test.go

@@ -1,212 +0,0 @@
-package main
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
-	fifoStockV2 "gitlab.com/mbugroup/lti-api.git/internal/common/service/fifo_stock_v2"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	transferSvc "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/transfers/services"
-)
-
-func TestValidateAdjustmentGatherAgainstAllowedIDsEligible(t *testing.T) {
-	result := validateAdjustmentGatherAgainstAllowedIDs(100, []uint{11, 12}, []commonSvc.FifoStockV2GatherRow{
-		{SourceTable: "adjustment_stocks", SourceID: 11, AvailableQuantity: 70},
-		{SourceTable: "adjustment_stocks", SourceID: 12, AvailableQuantity: 40},
-	})
-
-	if result.Status != "eligible" {
-		t.Fatalf("expected eligible, got %+v", result)
-	}
-	if result.VerifiedQty != 100 {
-		t.Fatalf("expected verified qty 100, got %v", result.VerifiedQty)
-	}
-}
-
-func TestValidateAdjustmentGatherAgainstAllowedIDsRejectsMixedSource(t *testing.T) {
-	result := validateAdjustmentGatherAgainstAllowedIDs(100, []uint{11}, []commonSvc.FifoStockV2GatherRow{
-		{SourceTable: "adjustment_stocks", SourceID: 11, AvailableQuantity: 60},
-		{SourceTable: "recording_eggs", SourceID: 21, AvailableQuantity: 50},
-	})
-
-	if result.Status != "skipped" {
-		t.Fatalf("expected skipped, got %+v", result)
-	}
-	if result.Reason != "mixed_fifo_source_recording_eggs" {
-		t.Fatalf("unexpected reason: %+v", result)
-	}
-}
-
-func TestBuildAdjustmentMigrationPlanUsesValidator(t *testing.T) {
-	opts := &adjustmentCommandOptions{RunID: "egg-adjustment-cutover-test"}
-	farmID := uint(25)
-	farmName := "Gudang Farm Jamali"
-	rows := []adjustmentLegacyEggRow{
-		{
-			LocationID:          16,
-			LocationName:        "Jamali",
-			SourceWarehouseID:   46,
-			SourceWarehouseName: "Gudang Jamali 1",
-			FarmWarehouseID:     &farmID,
-			FarmWarehouseName:   &farmName,
-			ProductWarehouseID:  101,
-			ProductID:           8,
-			ProductName:         "Telur Utuh",
-			RemainingQty:        120,
-			CurrentPWQty:        150,
-			AdjustmentIDs:       []uint{1},
-		},
-		{
-			LocationID:          16,
-			LocationName:        "Jamali",
-			SourceWarehouseID:   46,
-			SourceWarehouseName: "Gudang Jamali 1",
-			FarmWarehouseID:     &farmID,
-			FarmWarehouseName:   &farmName,
-			ProductWarehouseID:  102,
-			ProductID:           9,
-			ProductName:         "Telur Putih",
-			RemainingQty:        20,
-			CurrentPWQty:        40,
-			AdjustmentIDs:       []uint{2},
-		},
-		{
-			LocationID:          16,
-			LocationName:        "Jamali",
-			SourceWarehouseID:   46,
-			SourceWarehouseName: "Gudang Jamali 1",
-			ProductWarehouseID:  103,
-			ProductID:           10,
-			ProductName:         "Telur Pecah",
-			RemainingQty:        10,
-			CurrentPWQty:        10,
-			AdjustmentIDs:       []uint{3},
-		},
-	}
-	validator := &fakeAdjustmentCandidateValidator{
-		byProduct: map[string]adjustmentCandidateValidation{
-			"Telur Utuh":  {Status: "eligible", VerifiedQty: 120},
-			"Telur Putih": {Status: "skipped", Reason: "mixed_fifo_source_recording_eggs", VerifiedQty: 10},
-		},
-	}
-
-	reportRows, groups := buildAdjustmentMigrationPlan(context.Background(), opts, map[uint]adjustmentLocationTiming{
-		16: {LocationID: 16, LocationName: "Jamali", Status: "CLEAN_CUTOVER"},
-	}, rows, validator)
-
-	if len(reportRows) != 3 {
-		t.Fatalf("expected 3 report rows, got %d", len(reportRows))
-	}
-	if len(groups) != 1 || len(groups[0].Rows) != 1 {
-		t.Fatalf("expected only one eligible grouped row, got %+v", groups)
-	}
-	if reportRows[0].Status != "eligible" || reportRows[0].VerifiedQty != 120 {
-		t.Fatalf("unexpected first row: %+v", reportRows[0])
-	}
-	if reportRows[1].Reason != "mixed_fifo_source_recording_eggs" {
-		t.Fatalf("unexpected second row reason: %+v", reportRows[1])
-	}
-	if reportRows[2].Reason != "missing_farm_warehouse" {
-		t.Fatalf("expected missing farm warehouse skip, got %+v", reportRows[2])
-	}
-}
-
-func TestExecuteAdjustmentApplyRevalidatesRowsAndAppliesSubset(t *testing.T) {
-	opts := &adjustmentCommandOptions{
-		RunID:       "egg-adjustment-cutover-apply",
-		CutoverDate: time.Date(2026, 4, 7, 0, 0, 0, 0, time.UTC),
-		ActorID:     99,
-	}
-	group := adjustmentTransferGroup{
-		LocationID:          16,
-		LocationName:        "Jamali",
-		SourceWarehouseID:   46,
-		SourceWarehouseName: "Gudang Jamali 1",
-		FarmWarehouseID:     25,
-		FarmWarehouseName:   "Gudang Farm Jamali",
-		Rows: []*adjustmentMigrationReportRow{
-			{LocationID: 16, LocationName: "Jamali", SourceWarehouseID: 46, SourceWarehouseName: "Gudang Jamali 1", FarmWarehouseID: uintPtr(25), FarmWarehouseName: strPtr("Gudang Farm Jamali"), ProductWarehouseID: 101, ProductID: 8, ProductName: "Telur Utuh", RemainingQty: 120, CurrentPWQty: 150, AdjustmentIDs: []uint{1}, Status: "eligible"},
-			{LocationID: 16, LocationName: "Jamali", SourceWarehouseID: 46, SourceWarehouseName: "Gudang Jamali 1", FarmWarehouseID: uintPtr(25), FarmWarehouseName: strPtr("Gudang Farm Jamali"), ProductWarehouseID: 102, ProductID: 9, ProductName: "Telur Putih", RemainingQty: 20, CurrentPWQty: 40, AdjustmentIDs: []uint{2}, Status: "eligible"},
-		},
-	}
-	validator := &fakeAdjustmentCandidateValidator{
-		byProduct: map[string]adjustmentCandidateValidation{
-			"Telur Utuh":  {Status: "eligible", VerifiedQty: 120},
-			"Telur Putih": {Status: "skipped", Reason: "mixed_fifo_source_recording_eggs", VerifiedQty: 10},
-		},
-	}
-	executor := &fakeAdjustmentSystemTransferExecutor{
-		createResponses: []*entity.StockTransfer{
-			{Id: 1001, MovementNumber: "PND-LTI-1001"},
-		},
-	}
-
-	summary, err := executeAdjustmentApply(context.Background(), executor, validator, opts, []adjustmentTransferGroup{group})
-	if err != nil {
-		t.Fatalf("expected no fatal apply error, got %v", err)
-	}
-	if summary.GroupsApplied != 1 {
-		t.Fatalf("expected 1 applied group, got %+v", summary)
-	}
-	if summary.RowsApplied != 1 || summary.RowsFailed != 1 {
-		t.Fatalf("unexpected summary: %+v", summary)
-	}
-	if len(executor.createRequests) != 1 {
-		t.Fatalf("expected 1 create request, got %d", len(executor.createRequests))
-	}
-	if len(executor.createRequests[0].Products) != 1 || executor.createRequests[0].Products[0].ProductID != 8 {
-		t.Fatalf("expected only Telur Utuh to be transferred, got %+v", executor.createRequests[0].Products)
-	}
-}
-
-type fakeAdjustmentCandidateValidator struct {
-	byProduct    map[string]adjustmentCandidateValidation
-	errByProduct map[string]error
-}
-
-func (f *fakeAdjustmentCandidateValidator) ValidateCandidate(ctx context.Context, row adjustmentLegacyEggRow) (adjustmentCandidateValidation, error) {
-	if err, ok := f.errByProduct[row.ProductName]; ok {
-		return adjustmentCandidateValidation{}, err
-	}
-	if result, ok := f.byProduct[row.ProductName]; ok {
-		return result, nil
-	}
-	return adjustmentCandidateValidation{Status: "eligible", VerifiedQty: row.RemainingQty}, nil
-}
-
-type fakeAdjustmentSystemTransferExecutor struct {
-	createRequests     []*transferSvc.SystemTransferRequest
-	createResponses    []*entity.StockTransfer
-	createErrors       []error
-	deletedTransferIDs []uint
-	deleteErrors       map[uint]error
-}
-
-func (f *fakeAdjustmentSystemTransferExecutor) CreateSystemTransfer(ctx context.Context, req *transferSvc.SystemTransferRequest) (*entity.StockTransfer, error) {
-	f.createRequests = append(f.createRequests, req)
-	idx := len(f.createRequests) - 1
-	if idx < len(f.createErrors) && f.createErrors[idx] != nil {
-		return nil, f.createErrors[idx]
-	}
-	if idx < len(f.createResponses) && f.createResponses[idx] != nil {
-		return f.createResponses[idx], nil
-	}
-	return &entity.StockTransfer{Id: uint64(1000 + idx), MovementNumber: "PND-LTI-DEFAULT"}, nil
-}
-
-func (f *fakeAdjustmentSystemTransferExecutor) DeleteSystemTransfer(ctx context.Context, id uint, actorID uint) error {
-	f.deletedTransferIDs = append(f.deletedTransferIDs, id)
-	if f.deleteErrors == nil {
-		return nil
-	}
-	return f.deleteErrors[id]
-}
-
-func uintPtr(v uint) *uint    { return &v }
-func strPtr(v string) *string { return &v }
-
-var _ adjustmentCandidateValidator = (*fakeAdjustmentCandidateValidator)(nil)
-var _ adjustmentSystemTransferExecutor = (*fakeAdjustmentSystemTransferExecutor)(nil)
-var _ commonSvc.FifoStockV2Lane = fifoStockV2.LaneStockable

cmd/migrate-legacy-egg-stock-to-farm/main.go

@@ -1,825 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"sort"
-	"strings"
-	"text/tabwriter"
-	"time"
-
-	"github.com/go-playground/validator/v10"
-	"github.com/sirupsen/logrus"
-	"gitlab.com/mbugroup/lti-api.git/internal/common/service"
-	"gitlab.com/mbugroup/lti-api.git/internal/config"
-	"gitlab.com/mbugroup/lti-api.git/internal/database"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	pwRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
-	transferRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/transfers/repositories"
-	transferSvc "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/transfers/services"
-	warehouseRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/master/warehouses/repositories"
-	pfkRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
-	stockLogRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
-	"gorm.io/gorm"
-)
-
-const (
-	cutoverReasonPrefix = "EGG_FARM_CUTOVER"
-	outputModeTable     = "table"
-	outputModeJSON      = "json"
-)
-
-type commandOptions struct {
-	Apply          bool
-	DryRun         bool
-	RollbackRunID  string
-	LocationID     uint
-	LocationName   string
-	CutoverDate    time.Time
-	CutoverDateRaw string
-	IncludeOverlap bool
-	Output         string
-	ActorID        uint
-	RunID          string
-}
-
-type locationTiming struct {
-	LocationID       uint
-	LocationName     string
-	FirstKandangDate *time.Time
-	LastKandangDate  *time.Time
-	FirstFarmDate    *time.Time
-	LastFarmDate     *time.Time
-	Status           string
-}
-
-type legacyEggStockRow struct {
-	LocationID          uint
-	LocationName        string
-	SourceWarehouseID   uint
-	SourceWarehouseName string
-	FarmWarehouseID     *uint
-	FarmWarehouseName   *string
-	ProductWarehouseID  uint
-	ProductID           uint
-	ProductName         string
-	OnHandQty           float64
-}
-
-type migrationReportRow struct {
-	RunID               string  `json:"run_id"`
-	LocationID          uint    `json:"location_id"`
-	LocationName        string  `json:"location_name"`
-	SourceWarehouseID   uint    `json:"source_warehouse_id"`
-	SourceWarehouseName string  `json:"source_warehouse_name"`
-	FarmWarehouseID     *uint   `json:"farm_warehouse_id,omitempty"`
-	FarmWarehouseName   *string `json:"farm_warehouse_name,omitempty"`
-	ProductWarehouseID  uint    `json:"product_warehouse_id"`
-	ProductID           uint    `json:"product_id"`
-	ProductName         string  `json:"product_name"`
-	Qty                 float64 `json:"qty"`
-	LocationStatus      string  `json:"location_status"`
-	Status              string  `json:"status"`
-	Reason              string  `json:"reason,omitempty"`
-	TransferID          *uint64 `json:"transfer_id,omitempty"`
-	MovementNumber      *string `json:"movement_number,omitempty"`
-}
-
-type applySummary struct {
-	RowsPlanned   int `json:"rows_planned"`
-	RowsApplied   int `json:"rows_applied"`
-	RowsSkipped   int `json:"rows_skipped"`
-	RowsFailed    int `json:"rows_failed"`
-	GroupsPlanned int `json:"groups_planned"`
-	GroupsApplied int `json:"groups_applied"`
-}
-
-type rollbackDetailRow struct {
-	RunID               string  `json:"run_id"`
-	TransferID          uint64  `json:"transfer_id"`
-	MovementNumber      string  `json:"movement_number"`
-	LocationName        string  `json:"location_name"`
-	SourceWarehouseName string  `json:"source_warehouse_name"`
-	FarmWarehouseName   string  `json:"farm_warehouse_name"`
-	ProductName         string  `json:"product_name"`
-	Qty                 float64 `json:"qty"`
-	Status              string  `json:"status"`
-	Reason              string  `json:"reason,omitempty"`
-}
-
-type systemTransferExecutor interface {
-	CreateSystemTransfer(ctx context.Context, req *transferSvc.SystemTransferRequest) (*entity.StockTransfer, error)
-	DeleteSystemTransfer(ctx context.Context, id uint, actorID uint) error
-}
-
-type transferGroup struct {
-	LocationID          uint
-	LocationName        string
-	SourceWarehouseID   uint
-	SourceWarehouseName string
-	FarmWarehouseID     uint
-	FarmWarehouseName   string
-	Rows                []*migrationReportRow
-}
-
-func main() {
-	opts, err := parseFlags()
-	if err != nil {
-		log.Fatalf("invalid flags: %v", err)
-	}
-
-	db := database.Connect(config.DBHost, config.DBName)
-	ctx := context.Background()
-
-	if strings.TrimSpace(opts.RollbackRunID) != "" {
-		rows, err := loadRollbackDetails(ctx, db, opts.RollbackRunID)
-		if err != nil {
-			log.Fatalf("failed to load rollback details: %v", err)
-		}
-		if !opts.Apply {
-			for i := range rows {
-				rows[i].Status = "eligible"
-			}
-			renderRollbackReport(opts.Output, rows)
-			return
-		}
-		if err := executeRollback(ctx, newSystemTransferService(db), rows, opts.ActorID); err != nil {
-			log.Fatalf("rollback failed: %v", err)
-		}
-		renderRollbackReport(opts.Output, rows)
-		return
-	}
-
-	timings, err := loadLocationTimings(ctx, db, opts)
-	if err != nil {
-		log.Fatalf("failed to load location timings: %v", err)
-	}
-	legacyRows, err := loadLegacyEggStocks(ctx, db, opts)
-	if err != nil {
-		log.Fatalf("failed to load legacy egg stocks: %v", err)
-	}
-
-	reportRows, groups := buildMigrationPlan(opts, timings, legacyRows)
-	if !opts.Apply {
-		renderMigrationReport(opts.Output, reportRows, summarizeApply(reportRows, groups, 0))
-		return
-	}
-
-	summary, err := executeApply(ctx, newSystemTransferService(db), opts, groups)
-	if err != nil {
-		log.Fatalf("apply failed: %v", err)
-	}
-	finalRows := flattenGroups(groups, reportRows)
-	summary = summarizeApply(finalRows, groups, summary.GroupsApplied)
-	renderMigrationReport(opts.Output, finalRows, summary)
-}
-
-func parseFlags() (*commandOptions, error) {
-	var opts commandOptions
-	flag.BoolVar(&opts.Apply, "apply", false, "Apply migration. If false, run as dry-run")
-	flag.BoolVar(&opts.DryRun, "dry-run", true, "Run as dry-run")
-	flag.StringVar(&opts.RollbackRunID, "rollback-run-id", "", "Rollback all transfers created by the provided run id")
-	flag.UintVar(&opts.LocationID, "location-id", 0, "Filter by location id")
-	flag.StringVar(&opts.LocationName, "location-name", "", "Filter by exact location name")
-	flag.StringVar(&opts.CutoverDateRaw, "cutover-date", "", "Cutover date in YYYY-MM-DD format")
-	flag.BoolVar(&opts.IncludeOverlap, "include-overlap", false, "Include overlap locations in plan/apply")
-	flag.StringVar(&opts.Output, "output", outputModeTable, "Output format: table or json")
-	flag.UintVar(&opts.ActorID, "actor-id", 1, "Actor id used for created/deleted transfers")
-	flag.Parse()
-
-	opts.LocationName = strings.TrimSpace(opts.LocationName)
-	opts.RollbackRunID = strings.TrimSpace(opts.RollbackRunID)
-	opts.Output = strings.ToLower(strings.TrimSpace(opts.Output))
-	if opts.Output == "" {
-		opts.Output = outputModeTable
-	}
-	if opts.Output != outputModeTable && opts.Output != outputModeJSON {
-		return nil, fmt.Errorf("unsupported --output=%s", opts.Output)
-	}
-	if opts.Apply {
-		opts.DryRun = false
-	}
-	if opts.LocationID > 0 && opts.LocationName != "" {
-		return nil, errors.New("use either --location-id or --location-name, not both")
-	}
-	if opts.RollbackRunID != "" {
-		if opts.LocationID > 0 || opts.LocationName != "" {
-			return nil, errors.New("location filters are not supported with --rollback-run-id")
-		}
-		if opts.CutoverDateRaw != "" {
-			return nil, errors.New("--cutover-date is not used with --rollback-run-id")
-		}
-	} else if opts.Apply {
-		if opts.LocationID == 0 && opts.LocationName == "" {
-			return nil, errors.New("apply mode requires --location-id or --location-name for safety")
-		}
-		if strings.TrimSpace(opts.CutoverDateRaw) == "" {
-			return nil, errors.New("--cutover-date is required in apply mode")
-		}
-	}
-
-	if strings.TrimSpace(opts.CutoverDateRaw) == "" {
-		opts.CutoverDate = normalizeDateOnly(time.Now().In(time.FixedZone("Asia/Jakarta", 7*3600)))
-	} else {
-		t, err := time.Parse("2006-01-02", opts.CutoverDateRaw)
-		if err != nil {
-			return nil, fmt.Errorf("invalid --cutover-date: %w", err)
-		}
-		opts.CutoverDate = normalizeDateOnly(t)
-	}
-
-	opts.RunID = buildRunID()
-	return &opts, nil
-}
-
-func newSystemTransferService(db *gorm.DB) systemTransferExecutor {
-	validate := validator.New()
-	stockTransferRepo := transferRepo.NewStockTransferRepository(db)
-	stockTransferDetailRepo := transferRepo.NewStockTransferDetailRepository(db)
-	stockTransferDeliveryRepo := transferRepo.NewStockTransferDeliveryRepository(db)
-	stockTransferDeliveryItemRepo := transferRepo.NewStockTransferDeliveryItemRepository(db)
-	stockLogsRepo := stockLogRepo.NewStockLogRepository(db)
-	productWarehouseRepo := pwRepo.NewProductWarehouseRepository(db)
-	warehouseRepository := warehouseRepo.NewWarehouseRepository(db)
-	projectFlockKandangRepo := pfkRepo.NewProjectFlockKandangRepository(db)
-	projectFlockPopulationRepo := pfkRepo.NewProjectFlockPopulationRepository(db)
-	fifoSvc := service.NewFifoStockV2Service(db, logrus.StandardLogger())
-
-	return transferSvc.NewTransferService(
-		validate,
-		stockTransferRepo,
-		stockTransferDetailRepo,
-		stockTransferDeliveryRepo,
-		stockTransferDeliveryItemRepo,
-		stockLogsRepo,
-		productWarehouseRepo,
-		nil,
-		warehouseRepository,
-		projectFlockKandangRepo,
-		projectFlockPopulationRepo,
-		nil,
-		fifoSvc,
-		nil,
-	)
-}
-
-func loadLocationTimings(ctx context.Context, db *gorm.DB, opts *commandOptions) (map[uint]locationTiming, error) {
-	type row struct {
-		LocationID       uint       `gorm:"column:location_id"`
-		LocationName     string     `gorm:"column:location_name"`
-		FirstKandangDate *time.Time `gorm:"column:first_kandang_date"`
-		LastKandangDate  *time.Time `gorm:"column:last_kandang_date"`
-		FirstFarmDate    *time.Time `gorm:"column:first_farm_date"`
-		LastFarmDate     *time.Time `gorm:"column:last_farm_date"`
-	}
-
-	query := db.WithContext(ctx).
-		Table("recording_eggs re").
-		Select(`
-			pf.location_id AS location_id,
-			l.name AS location_name,
-			MIN(CASE WHEN w.type = 'KANDANG' THEN DATE(r.record_datetime) END) AS first_kandang_date,
-			MAX(CASE WHEN w.type = 'KANDANG' THEN DATE(r.record_datetime) END) AS last_kandang_date,
-			MIN(CASE WHEN w.type = 'LOKASI' THEN DATE(r.record_datetime) END) AS first_farm_date,
-			MAX(CASE WHEN w.type = 'LOKASI' THEN DATE(r.record_datetime) END) AS last_farm_date
-		`).
-		Joins("JOIN recordings r ON r.id = re.recording_id").
-		Joins("JOIN project_flock_kandangs pk ON pk.id = COALESCE(re.project_flock_kandang_id, r.project_flock_kandangs_id)").
-		Joins("JOIN project_flocks pf ON pf.id = pk.project_flock_id").
-		Joins("JOIN locations l ON l.id = pf.location_id").
-		Joins("JOIN product_warehouses pw ON pw.id = re.product_warehouse_id").
-		Joins("JOIN warehouses w ON w.id = pw.warehouse_id").
-		Group("pf.location_id, l.name")
-	query = applyTimingLocationFilter(query, opts)
-
-	var rows []row
-	if err := query.Scan(&rows).Error; err != nil {
-		return nil, err
-	}
-
-	result := make(map[uint]locationTiming, len(rows))
-	for _, row := range rows {
-		status := "KANDANG_ONLY"
-		if row.FirstFarmDate != nil {
-			status = "OVERLAP"
-			if row.LastKandangDate == nil || row.FirstFarmDate.After(normalizeDateOnly(*row.LastKandangDate)) {
-				status = "CLEAN_CUTOVER"
-			}
-		}
-		result[row.LocationID] = locationTiming{
-			LocationID:       row.LocationID,
-			LocationName:     row.LocationName,
-			FirstKandangDate: normalizeDatePtr(row.FirstKandangDate),
-			LastKandangDate:  normalizeDatePtr(row.LastKandangDate),
-			FirstFarmDate:    normalizeDatePtr(row.FirstFarmDate),
-			LastFarmDate:     normalizeDatePtr(row.LastFarmDate),
-			Status:           status,
-		}
-	}
-
-	return result, nil
-}
-
-func loadLegacyEggStocks(ctx context.Context, db *gorm.DB, opts *commandOptions) ([]legacyEggStockRow, error) {
-	type row struct {
-		LocationID          uint    `gorm:"column:location_id"`
-		LocationName        string  `gorm:"column:location_name"`
-		SourceWarehouseID   uint    `gorm:"column:source_warehouse_id"`
-		SourceWarehouseName string  `gorm:"column:source_warehouse_name"`
-		FarmWarehouseID     *uint   `gorm:"column:farm_warehouse_id"`
-		FarmWarehouseName   *string `gorm:"column:farm_warehouse_name"`
-		ProductWarehouseID  uint    `gorm:"column:product_warehouse_id"`
-		ProductID           uint    `gorm:"column:product_id"`
-		ProductName         string  `gorm:"column:product_name"`
-		OnHandQty           float64 `gorm:"column:on_hand_qty"`
-	}
-
-	firstFarmSub := db.WithContext(ctx).
-		Table("warehouses fw").
-		Select("fw.location_id AS location_id, MIN(fw.id) AS farm_warehouse_id").
-		Where("fw.deleted_at IS NULL").
-		Where("fw.type = ?", "LOKASI").
-		Group("fw.location_id")
-
-	query := db.WithContext(ctx).
-		Table("product_warehouses pw").
-		Select(`
-			kw.location_id AS location_id,
-			l.name AS location_name,
-			kw.id AS source_warehouse_id,
-			kw.name AS source_warehouse_name,
-			fw.id AS farm_warehouse_id,
-			fw.name AS farm_warehouse_name,
-			pw.id AS product_warehouse_id,
-			pw.product_id AS product_id,
-			p.name AS product_name,
-			COALESCE(pw.qty, 0) AS on_hand_qty
-		`).
-		Joins("JOIN warehouses kw ON kw.id = pw.warehouse_id AND kw.deleted_at IS NULL").
-		Joins("JOIN locations l ON l.id = kw.location_id").
-		Joins("JOIN products p ON p.id = pw.product_id").
-		Joins("LEFT JOIN product_categories pc ON pc.id = p.product_category_id").
-		Joins("LEFT JOIN (?) ff ON ff.location_id = kw.location_id", firstFarmSub).
-		Joins("LEFT JOIN warehouses fw ON fw.id = ff.farm_warehouse_id").
-		Where("kw.type = ?", "KANDANG").
-		Where(`
-			EXISTS (
-				SELECT 1
-				FROM recording_eggs re
-				WHERE re.product_warehouse_id = pw.id
-			)
-		`).
-		Where(`
-			EXISTS (
-				SELECT 1
-				FROM flags f
-				WHERE f.flagable_type = ?
-				  AND f.flagable_id = p.id
-				  AND (UPPER(f.name) = 'TELUR' OR UPPER(f.name) LIKE 'TELUR-%')
-			)
-			OR (
-				NOT EXISTS (
-					SELECT 1
-					FROM flags f_any
-					WHERE f_any.flagable_type = ?
-					  AND f_any.flagable_id = p.id
-				)
-				AND UPPER(COALESCE(pc.code, '')) = 'EGG'
-			)
-		`, entity.FlagableTypeProduct, entity.FlagableTypeProduct).
-		Order("l.name ASC, kw.name ASC, p.name ASC")
-	query = applyLegacyStockLocationFilter(query, opts)
-
-	var rows []row
-	if err := query.Scan(&rows).Error; err != nil {
-		return nil, err
-	}
-
-	result := make([]legacyEggStockRow, 0, len(rows))
-	for _, row := range rows {
-		result = append(result, legacyEggStockRow{
-			LocationID:          row.LocationID,
-			LocationName:        row.LocationName,
-			SourceWarehouseID:   row.SourceWarehouseID,
-			SourceWarehouseName: row.SourceWarehouseName,
-			FarmWarehouseID:     row.FarmWarehouseID,
-			FarmWarehouseName:   row.FarmWarehouseName,
-			ProductWarehouseID:  row.ProductWarehouseID,
-			ProductID:           row.ProductID,
-			ProductName:         row.ProductName,
-			OnHandQty:           row.OnHandQty,
-		})
-	}
-
-	return result, nil
-}
-
-func buildMigrationPlan(
-	opts *commandOptions,
-	timings map[uint]locationTiming,
-	rows []legacyEggStockRow,
-) ([]migrationReportRow, []transferGroup) {
-	reportRows := make([]migrationReportRow, 0, len(rows))
-	groupMap := make(map[string]*transferGroup)
-
-	for _, row := range rows {
-		locationStatus := "UNKNOWN"
-		if timing, ok := timings[row.LocationID]; ok {
-			locationStatus = timing.Status
-		}
-
-		report := migrationReportRow{
-			RunID:               opts.RunID,
-			LocationID:          row.LocationID,
-			LocationName:        row.LocationName,
-			SourceWarehouseID:   row.SourceWarehouseID,
-			SourceWarehouseName: row.SourceWarehouseName,
-			FarmWarehouseID:     row.FarmWarehouseID,
-			FarmWarehouseName:   row.FarmWarehouseName,
-			ProductWarehouseID:  row.ProductWarehouseID,
-			ProductID:           row.ProductID,
-			ProductName:         row.ProductName,
-			Qty:                 row.OnHandQty,
-			LocationStatus:      locationStatus,
-			Status:              "eligible",
-		}
-
-		switch {
-		case row.FarmWarehouseID == nil || row.FarmWarehouseName == nil:
-			report.Status = "skipped"
-			report.Reason = "missing_farm_warehouse"
-		case row.OnHandQty <= 0:
-			report.Status = "skipped"
-			report.Reason = "non_positive_qty"
-		case locationStatus == "OVERLAP" && !opts.IncludeOverlap:
-			report.Status = "skipped"
-			report.Reason = "overlap_location"
-		}
-
-		reportRows = append(reportRows, report)
-		if report.Status != "eligible" {
-			continue
-		}
-
-		groupKey := fmt.Sprintf("%d:%d", row.SourceWarehouseID, *row.FarmWarehouseID)
-		group := groupMap[groupKey]
-		if group == nil {
-			group = &transferGroup{
-				LocationID:          row.LocationID,
-				LocationName:        row.LocationName,
-				SourceWarehouseID:   row.SourceWarehouseID,
-				SourceWarehouseName: row.SourceWarehouseName,
-				FarmWarehouseID:     *row.FarmWarehouseID,
-				FarmWarehouseName:   derefString(row.FarmWarehouseName),
-			}
-			groupMap[groupKey] = group
-		}
-		group.Rows = append(group.Rows, &reportRows[len(reportRows)-1])
-	}
-
-	groups := make([]transferGroup, 0, len(groupMap))
-	for _, group := range groupMap {
-		sort.Slice(group.Rows, func(i, j int) bool {
-			return group.Rows[i].ProductName < group.Rows[j].ProductName
-		})
-		groups = append(groups, *group)
-	}
-	sort.Slice(groups, func(i, j int) bool {
-		if groups[i].LocationName == groups[j].LocationName {
-			return groups[i].SourceWarehouseName < groups[j].SourceWarehouseName
-		}
-		return groups[i].LocationName < groups[j].LocationName
-	})
-
-	return reportRows, groups
-}
-
-func executeApply(
-	ctx context.Context,
-	svc systemTransferExecutor,
-	opts *commandOptions,
-	groups []transferGroup,
-) (applySummary, error) {
-	summary := applySummary{GroupsPlanned: len(groups)}
-	for _, group := range groups {
-		products := make([]transferSvc.SystemTransferProduct, 0, len(group.Rows))
-		for _, row := range group.Rows {
-			products = append(products, transferSvc.SystemTransferProduct{
-				ProductID:  row.ProductID,
-				ProductQty: row.Qty,
-			})
-		}
-		reason := buildCutoverReason(opts.RunID, group.LocationName, opts.CutoverDate)
-		transfer, err := svc.CreateSystemTransfer(ctx, &transferSvc.SystemTransferRequest{
-			TransferReason:         reason,
-			TransferDate:           opts.CutoverDate,
-			SourceWarehouseID:      group.SourceWarehouseID,
-			DestinationWarehouseID: group.FarmWarehouseID,
-			Products:               products,
-			ActorID:                opts.ActorID,
-			StockLogNotes:          reason,
-		})
-		if err != nil {
-			for _, row := range group.Rows {
-				row.Status = "failed"
-				row.Reason = err.Error()
-				summary.RowsFailed++
-			}
-			continue
-		}
-
-		summary.GroupsApplied++
-		for _, row := range group.Rows {
-			row.Status = "applied"
-			row.TransferID = &transfer.Id
-			row.MovementNumber = &transfer.MovementNumber
-			summary.RowsApplied++
-		}
-	}
-
-	for _, group := range groups {
-		summary.RowsPlanned += len(group.Rows)
-	}
-	return summary, nil
-}
-
-func executeRollback(
-	ctx context.Context,
-	svc systemTransferExecutor,
-	rows []rollbackDetailRow,
-	actorID uint,
-) error {
-	if actorID == 0 {
-		return fmt.Errorf("actor id is required for rollback")
-	}
-
-	byTransfer := make(map[uint64][]int)
-	for idx, row := range rows {
-		byTransfer[row.TransferID] = append(byTransfer[row.TransferID], idx)
-	}
-
-	transferIDs := make([]uint64, 0, len(byTransfer))
-	for transferID := range byTransfer {
-		transferIDs = append(transferIDs, transferID)
-	}
-	sort.Slice(transferIDs, func(i, j int) bool { return transferIDs[i] > transferIDs[j] })
-
-	var firstErr error
-	for _, transferID := range transferIDs {
-		err := svc.DeleteSystemTransfer(ctx, uint(transferID), actorID)
-		for _, idx := range byTransfer[transferID] {
-			if err != nil {
-				rows[idx].Status = "failed"
-				rows[idx].Reason = err.Error()
-			} else {
-				rows[idx].Status = "rolled_back"
-			}
-		}
-		if err != nil && firstErr == nil {
-			firstErr = err
-		}
-	}
-
-	return firstErr
-}
-
-func loadRollbackDetails(ctx context.Context, db *gorm.DB, runID string) ([]rollbackDetailRow, error) {
-	type row struct {
-		TransferID          uint64  `gorm:"column:transfer_id"`
-		MovementNumber      string  `gorm:"column:movement_number"`
-		LocationName        string  `gorm:"column:location_name"`
-		SourceWarehouseName string  `gorm:"column:source_warehouse_name"`
-		FarmWarehouseName   string  `gorm:"column:farm_warehouse_name"`
-		ProductName         string  `gorm:"column:product_name"`
-		Qty                 float64 `gorm:"column:qty"`
-	}
-
-	needle := buildRunReasonMatcher(runID)
-	var dbRows []row
-	err := db.WithContext(ctx).
-		Table("stock_transfers st").
-		Select(`
-			st.id AS transfer_id,
-			st.movement_number AS movement_number,
-			COALESCE(loc.name, '') AS location_name,
-			ws.name AS source_warehouse_name,
-			wd.name AS farm_warehouse_name,
-			p.name AS product_name,
-			COALESCE(std.total_qty, std.usage_qty, 0) AS qty
-		`).
-		Joins("JOIN warehouses ws ON ws.id = st.from_warehouse_id").
-		Joins("JOIN warehouses wd ON wd.id = st.to_warehouse_id").
-		Joins("LEFT JOIN locations loc ON loc.id = COALESCE(ws.location_id, wd.location_id)").
-		Joins("JOIN stock_transfer_details std ON std.stock_transfer_id = st.id AND std.deleted_at IS NULL").
-		Joins("JOIN products p ON p.id = std.product_id").
-		Where("st.deleted_at IS NULL").
-		Where("st.reason LIKE ?", needle).
-		Order("st.id DESC, std.id ASC").
-		Scan(&dbRows).Error
-	if err != nil {
-		return nil, err
-	}
-
-	rows := make([]rollbackDetailRow, 0, len(dbRows))
-	for _, row := range dbRows {
-		rows = append(rows, rollbackDetailRow{
-			RunID:               runID,
-			TransferID:          row.TransferID,
-			MovementNumber:      row.MovementNumber,
-			LocationName:        row.LocationName,
-			SourceWarehouseName: row.SourceWarehouseName,
-			FarmWarehouseName:   row.FarmWarehouseName,
-			ProductName:         row.ProductName,
-			Qty:                 row.Qty,
-		})
-	}
-
-	return rows, nil
-}
-
-func applyTimingLocationFilter(db *gorm.DB, opts *commandOptions) *gorm.DB {
-	if opts == nil {
-		return db
-	}
-	switch {
-	case opts.LocationID > 0:
-		return db.Where("pf.location_id = ?", opts.LocationID)
-	case opts.LocationName != "":
-		return db.Where("LOWER(l.name) = LOWER(?)", opts.LocationName)
-	default:
-		return db
-	}
-}
-
-func applyLegacyStockLocationFilter(db *gorm.DB, opts *commandOptions) *gorm.DB {
-	if opts == nil {
-		return db
-	}
-	switch {
-	case opts.LocationID > 0:
-		return db.Where("kw.location_id = ?", opts.LocationID)
-	case opts.LocationName != "":
-		return db.Where("LOWER(l.name) = LOWER(?)", opts.LocationName)
-	default:
-		return db
-	}
-}
-
-func buildCutoverReason(runID, locationName string, cutoverDate time.Time) string {
-	locationName = strings.ReplaceAll(strings.TrimSpace(locationName), "|", "/")
-	return fmt.Sprintf("%s|run_id=%s|location=%s|cutover_date=%s", cutoverReasonPrefix, runID, locationName, cutoverDate.Format("2006-01-02"))
-}
-
-func buildRunReasonMatcher(runID string) string {
-	return fmt.Sprintf("%s|run_id=%s|%%", cutoverReasonPrefix, strings.TrimSpace(runID))
-}
-
-func buildRunID() string {
-	return fmt.Sprintf("egg-cutover-%s", time.Now().UTC().Format("20060102T150405.000000000Z"))
-}
-
-func normalizeDateOnly(value time.Time) time.Time {
-	return time.Date(value.Year(), value.Month(), value.Day(), 0, 0, 0, 0, time.UTC)
-}
-
-func normalizeDatePtr(value *time.Time) *time.Time {
-	if value == nil {
-		return nil
-	}
-	normalized := normalizeDateOnly(*value)
-	return &normalized
-}
-
-func derefString(value *string) string {
-	if value == nil {
-		return ""
-	}
-	return *value
-}
-
-func summarizeApply(rows []migrationReportRow, groups []transferGroup, appliedGroups int) applySummary {
-	summary := applySummary{
-		GroupsPlanned: len(groups),
-		GroupsApplied: appliedGroups,
-	}
-	for _, row := range rows {
-		switch row.Status {
-		case "eligible":
-			summary.RowsPlanned++
-		case "applied":
-			summary.RowsPlanned++
-			summary.RowsApplied++
-		case "failed":
-			summary.RowsPlanned++
-			summary.RowsFailed++
-		case "skipped":
-			summary.RowsSkipped++
-		}
-	}
-	return summary
-}
-
-func flattenGroups(groups []transferGroup, fallback []migrationReportRow) []migrationReportRow {
-	if len(groups) == 0 {
-		return fallback
-	}
-	rows := make([]migrationReportRow, 0, len(fallback))
-	for _, group := range groups {
-		for _, row := range group.Rows {
-			rows = append(rows, *row)
-		}
-	}
-	for _, row := range fallback {
-		if row.Status == "skipped" {
-			rows = append(rows, row)
-		}
-	}
-	sort.Slice(rows, func(i, j int) bool {
-		if rows[i].LocationName == rows[j].LocationName {
-			if rows[i].SourceWarehouseName == rows[j].SourceWarehouseName {
-				return rows[i].ProductName < rows[j].ProductName
-			}
-			return rows[i].SourceWarehouseName < rows[j].SourceWarehouseName
-		}
-		return rows[i].LocationName < rows[j].LocationName
-	})
-	return rows
-}
-
-func renderMigrationReport(mode string, rows []migrationReportRow, summary applySummary) {
-	if mode == outputModeJSON {
-		payload := map[string]any{
-			"rows":    rows,
-			"summary": summary,
-		}
-		enc := json.NewEncoder(os.Stdout)
-		enc.SetIndent("", "  ")
-		_ = enc.Encode(payload)
-		return
-	}
-
-	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
-	fmt.Fprintln(w, "RUN_ID\tLOCATION\tSOURCE_WAREHOUSE\tFARM_WAREHOUSE\tPRODUCT\tQTY\tLOCATION_STATUS\tSTATUS\tREASON\tTRANSFER_ID\tMOVEMENT_NUMBER")
-	for _, row := range rows {
-		transferID := "-"
-		if row.TransferID != nil {
-			transferID = fmt.Sprintf("%d", *row.TransferID)
-		}
-		movementNumber := "-"
-		if row.MovementNumber != nil {
-			movementNumber = *row.MovementNumber
-		}
-		fmt.Fprintf(
-			w,
-			"%s\t%s\t%s\t%s\t%s\t%.3f\t%s\t%s\t%s\t%s\t%s\n",
-			row.RunID,
-			row.LocationName,
-			row.SourceWarehouseName,
-			derefString(row.FarmWarehouseName),
-			row.ProductName,
-			row.Qty,
-			row.LocationStatus,
-			row.Status,
-			row.Reason,
-			transferID,
-			movementNumber,
-		)
-	}
-	_ = w.Flush()
-	fmt.Printf("\nSummary: rows_planned=%d rows_applied=%d rows_skipped=%d rows_failed=%d groups_planned=%d groups_applied=%d\n",
-		summary.RowsPlanned, summary.RowsApplied, summary.RowsSkipped, summary.RowsFailed, summary.GroupsPlanned, summary.GroupsApplied)
-}
-
-func renderRollbackReport(mode string, rows []rollbackDetailRow) {
-	if mode == outputModeJSON {
-		enc := json.NewEncoder(os.Stdout)
-		enc.SetIndent("", "  ")
-		_ = enc.Encode(map[string]any{"rows": rows})
-		return
-	}
-
-	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
-	fmt.Fprintln(w, "RUN_ID\tTRANSFER_ID\tMOVEMENT_NUMBER\tLOCATION\tSOURCE_WAREHOUSE\tFARM_WAREHOUSE\tPRODUCT\tQTY\tSTATUS\tREASON")
-	for _, row := range rows {
-		fmt.Fprintf(
-			w,
-			"%s\t%d\t%s\t%s\t%s\t%s\t%s\t%.3f\t%s\t%s\n",
-			row.RunID,
-			row.TransferID,
-			row.MovementNumber,
-			row.LocationName,
-			row.SourceWarehouseName,
-			row.FarmWarehouseName,
-			row.ProductName,
-			row.Qty,
-			row.Status,
-			row.Reason,
-		)
-	}
-	_ = w.Flush()
-}

cmd/migrate-legacy-egg-stock-to-farm/main_test.go

@@ -1,251 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"strings"
-	"testing"
-	"time"
-
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	transferSvc "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/transfers/services"
-)
-
-func TestBuildMigrationPlanSkipsOverlapAndGroupsEligibleRows(t *testing.T) {
-	opts := &commandOptions{
-		RunID:          "egg-cutover-test",
-		IncludeOverlap: false,
-	}
-	timings := map[uint]locationTiming{
-		16: {LocationID: 16, LocationName: "Jamali", Status: "CLEAN_CUTOVER"},
-		17: {LocationID: 17, LocationName: "Cijangkar", Status: "OVERLAP"},
-	}
-	farmID := uint(25)
-	farmName := "Gudang Farm Jamali"
-
-	rows := []legacyEggStockRow{
-		{
-			LocationID:          16,
-			LocationName:        "Jamali",
-			SourceWarehouseID:   46,
-			SourceWarehouseName: "Gudang Jamali 1",
-			FarmWarehouseID:     &farmID,
-			FarmWarehouseName:   &farmName,
-			ProductWarehouseID:  101,
-			ProductID:           8,
-			ProductName:         "Telur Utuh",
-			OnHandQty:           120,
-		},
-		{
-			LocationID:          16,
-			LocationName:        "Jamali",
-			SourceWarehouseID:   46,
-			SourceWarehouseName: "Gudang Jamali 1",
-			FarmWarehouseID:     &farmID,
-			FarmWarehouseName:   &farmName,
-			ProductWarehouseID:  102,
-			ProductID:           9,
-			ProductName:         "Telur Putih",
-			OnHandQty:           20,
-		},
-		{
-			LocationID:          17,
-			LocationName:        "Cijangkar",
-			SourceWarehouseID:   51,
-			SourceWarehouseName: "Gudang Cijangkar 1",
-			FarmWarehouseID:     &farmID,
-			FarmWarehouseName:   &farmName,
-			ProductWarehouseID:  103,
-			ProductID:           10,
-			ProductName:         "Telur Jumbo",
-			OnHandQty:           10,
-		},
-		{
-			LocationID:          16,
-			LocationName:        "Jamali",
-			SourceWarehouseID:   46,
-			SourceWarehouseName: "Gudang Jamali 1",
-			ProductWarehouseID:  104,
-			ProductID:           11,
-			ProductName:         "Telur Papacal",
-			OnHandQty:           50,
-		},
-		{
-			LocationID:          16,
-			LocationName:        "Jamali",
-			SourceWarehouseID:   46,
-			SourceWarehouseName: "Gudang Jamali 1",
-			FarmWarehouseID:     &farmID,
-			FarmWarehouseName:   &farmName,
-			ProductWarehouseID:  105,
-			ProductID:           12,
-			ProductName:         "Telur Retak",
-			OnHandQty:           0,
-		},
-	}
-
-	reportRows, groups := buildMigrationPlan(opts, timings, rows)
-
-	if len(reportRows) != 5 {
-		t.Fatalf("expected 5 report rows, got %d", len(reportRows))
-	}
-	if len(groups) != 1 {
-		t.Fatalf("expected 1 eligible transfer group, got %d", len(groups))
-	}
-	if len(groups[0].Rows) != 2 {
-		t.Fatalf("expected 2 eligible products in the transfer group, got %d", len(groups[0].Rows))
-	}
-
-	statusByProduct := make(map[string]string, len(reportRows))
-	reasonByProduct := make(map[string]string, len(reportRows))
-	for _, row := range reportRows {
-		statusByProduct[row.ProductName] = row.Status
-		reasonByProduct[row.ProductName] = row.Reason
-	}
-
-	if statusByProduct["Telur Utuh"] != "eligible" || statusByProduct["Telur Putih"] != "eligible" {
-		t.Fatalf("expected Jamali egg rows to stay eligible, got statuses %+v", statusByProduct)
-	}
-	if reasonByProduct["Telur Jumbo"] != "overlap_location" {
-		t.Fatalf("expected overlap location skip, got %q", reasonByProduct["Telur Jumbo"])
-	}
-	if reasonByProduct["Telur Papacal"] != "missing_farm_warehouse" {
-		t.Fatalf("expected missing farm warehouse skip, got %q", reasonByProduct["Telur Papacal"])
-	}
-	if reasonByProduct["Telur Retak"] != "non_positive_qty" {
-		t.Fatalf("expected non positive qty skip, got %q", reasonByProduct["Telur Retak"])
-	}
-}
-
-func TestExecuteApplyBuildsTaggedSystemTransfersAndSummaries(t *testing.T) {
-	opts := &commandOptions{
-		RunID:       "egg-cutover-apply",
-		CutoverDate: time.Date(2026, 4, 7, 0, 0, 0, 0, time.UTC),
-		ActorID:     99,
-	}
-	groups := []transferGroup{
-		{
-			LocationID:          16,
-			LocationName:        "Jamali",
-			SourceWarehouseID:   46,
-			SourceWarehouseName: "Gudang Jamali 1",
-			FarmWarehouseID:     25,
-			FarmWarehouseName:   "Gudang Farm Jamali",
-			Rows: []*migrationReportRow{
-				{ProductID: 8, ProductName: "Telur Utuh", Qty: 120},
-				{ProductID: 9, ProductName: "Telur Putih", Qty: 20},
-			},
-		},
-		{
-			LocationID:          18,
-			LocationName:        "Tamansari",
-			SourceWarehouseID:   91,
-			SourceWarehouseName: "Gudang Tamansari 1",
-			FarmWarehouseID:     31,
-			FarmWarehouseName:   "Gudang Farm Tamansari",
-			Rows: []*migrationReportRow{
-				{ProductID: 10, ProductName: "Telur Jumbo", Qty: 10},
-			},
-		},
-	}
-
-	executor := &fakeSystemTransferExecutor{
-		createResponses: []*entity.StockTransfer{
-			{Id: 1001, MovementNumber: "PND-LTI-1001"},
-		},
-		createErrors: []error{
-			nil,
-			errors.New("destination warehouse locked"),
-		},
-	}
-
-	summary, err := executeApply(context.Background(), executor, opts, groups)
-	if err != nil {
-		t.Fatalf("expected no fatal apply error, got %v", err)
-	}
-	if summary.GroupsPlanned != 2 || summary.GroupsApplied != 1 {
-		t.Fatalf("unexpected group summary: %+v", summary)
-	}
-	if summary.RowsApplied != 2 || summary.RowsFailed != 1 {
-		t.Fatalf("unexpected row summary: %+v", summary)
-	}
-	if len(executor.createRequests) != 2 {
-		t.Fatalf("expected 2 create requests, got %d", len(executor.createRequests))
-	}
-	if !strings.Contains(executor.createRequests[0].TransferReason, "EGG_FARM_CUTOVER|run_id=egg-cutover-apply|location=Jamali|cutover_date=2026-04-07") {
-		t.Fatalf("unexpected transfer reason: %s", executor.createRequests[0].TransferReason)
-	}
-	if executor.createRequests[0].MovementNumber != "" {
-		t.Fatalf("apply path should let transfer service generate movement number, got %q", executor.createRequests[0].MovementNumber)
-	}
-	if groups[0].Rows[0].Status != "applied" || groups[0].Rows[1].Status != "applied" {
-		t.Fatalf("expected first group rows to be applied, got %+v", groups[0].Rows)
-	}
-	if groups[1].Rows[0].Status != "failed" {
-		t.Fatalf("expected second group row to fail, got %+v", groups[1].Rows[0])
-	}
-	if groups[0].Rows[0].TransferID == nil || *groups[0].Rows[0].TransferID != 1001 {
-		t.Fatalf("expected first row to keep created transfer id, got %+v", groups[0].Rows[0].TransferID)
-	}
-}
-
-func TestExecuteRollbackDeletesTransfersDescendingAndMarksFailures(t *testing.T) {
-	executor := &fakeSystemTransferExecutor{
-		deleteErrors: map[uint]error{
-			101: errors.New("already consumed downstream"),
-		},
-	}
-	rows := []rollbackDetailRow{
-		{TransferID: 100, ProductName: "Telur Utuh"},
-		{TransferID: 101, ProductName: "Telur Jumbo"},
-		{TransferID: 100, ProductName: "Telur Putih"},
-	}
-
-	err := executeRollback(context.Background(), executor, rows, 99)
-	if err == nil {
-		t.Fatal("expected rollback to return the first transfer error")
-	}
-	if err.Error() != "already consumed downstream" {
-		t.Fatalf("unexpected rollback error: %v", err)
-	}
-	if len(executor.deletedTransferIDs) != 2 {
-		t.Fatalf("expected 2 delete calls, got %d", len(executor.deletedTransferIDs))
-	}
-	if executor.deletedTransferIDs[0] != 101 || executor.deletedTransferIDs[1] != 100 {
-		t.Fatalf("expected delete order [101 100], got %v", executor.deletedTransferIDs)
-	}
-	if rows[0].Status != "rolled_back" || rows[2].Status != "rolled_back" {
-		t.Fatalf("expected transfer 100 rows to be rolled back, got %+v", rows)
-	}
-	if rows[1].Status != "failed" {
-		t.Fatalf("expected transfer 101 row to fail, got %+v", rows[1])
-	}
-}
-
-type fakeSystemTransferExecutor struct {
-	createRequests     []*transferSvc.SystemTransferRequest
-	createResponses    []*entity.StockTransfer
-	createErrors       []error
-	deletedTransferIDs []uint
-	deleteErrors       map[uint]error
-}
-
-func (f *fakeSystemTransferExecutor) CreateSystemTransfer(ctx context.Context, req *transferSvc.SystemTransferRequest) (*entity.StockTransfer, error) {
-	f.createRequests = append(f.createRequests, req)
-	idx := len(f.createRequests) - 1
-	if idx < len(f.createErrors) && f.createErrors[idx] != nil {
-		return nil, f.createErrors[idx]
-	}
-	if idx < len(f.createResponses) && f.createResponses[idx] != nil {
-		return f.createResponses[idx], nil
-	}
-	return &entity.StockTransfer{Id: uint64(1000 + idx), MovementNumber: "PND-LTI-DEFAULT"}, nil
-}
-
-func (f *fakeSystemTransferExecutor) DeleteSystemTransfer(ctx context.Context, id uint, actorID uint) error {
-	f.deletedTransferIDs = append(f.deletedTransferIDs, id)
-	if f.deleteErrors == nil {
-		return nil
-	}
-	return f.deleteErrors[id]
-}

cmd/normalize-data-egg-mass-and-hen-house/main.go

@@ -1,380 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"log"
-	"math"
-	"os"
-	"strings"
-	"time"
-
-	"gitlab.com/mbugroup/lti-api.git/internal/config"
-	"gitlab.com/mbugroup/lti-api.git/internal/database"
-	recordingRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/repositories"
-	"gorm.io/gorm"
-)
-
-const metricEpsilon = 1e-9
-
-type normalizeOptions struct {
-	Apply                 bool
-	RecordingID           uint
-	ProjectFlockKandangID uint
-	From                  *time.Time
-	To                    *time.Time
-	BatchSize             int
-	Limit                 int
-}
-
-type normalizeStats struct {
-	Processed int
-	Changed   int
-	Updated   int
-	Skipped   int
-	Failed    int
-}
-
-type recordingMetricRow struct {
-	ID                    uint      `gorm:"column:id"`
-	ProjectFlockKandangID uint      `gorm:"column:project_flock_kandangs_id"`
-	RecordDatetime        time.Time `gorm:"column:record_datetime"`
-	HenHouse              *float64  `gorm:"column:hen_house"`
-	EggMass               *float64  `gorm:"column:egg_mass"`
-}
-
-func main() {
-	var (
-		apply                 bool
-		recordingID           uint
-		projectFlockKandangID uint
-		fromRaw               string
-		toRaw                 string
-		batchSize             int
-		limit                 int
-	)
-
-	flag.BoolVar(&apply, "apply", false, "Apply update. If false, run as dry-run")
-	flag.UintVar(&recordingID, "recording-id", 0, "Target a single recording ID")
-	flag.UintVar(&projectFlockKandangID, "project-flock-kandang-id", 0, "Filter by project_flock_kandangs_id")
-	flag.StringVar(&fromRaw, "from", "", "Lower bound record_datetime (RFC3339 / YYYY-MM-DD)")
-	flag.StringVar(&toRaw, "to", "", "Upper bound record_datetime (RFC3339 / YYYY-MM-DD)")
-	flag.IntVar(&batchSize, "batch-size", 200, "Batch size when scanning recordings")
-	flag.IntVar(&limit, "limit", 0, "Max recordings to process (0 = no limit)")
-	flag.Parse()
-
-	if batchSize <= 0 {
-		log.Fatal("--batch-size must be > 0")
-	}
-	if limit < 0 {
-		log.Fatal("--limit cannot be negative")
-	}
-
-	from, err := parseTimeBound(strings.TrimSpace(fromRaw), false)
-	if err != nil {
-		log.Fatalf("invalid --from: %v", err)
-	}
-	to, err := parseTimeBound(strings.TrimSpace(toRaw), true)
-	if err != nil {
-		log.Fatalf("invalid --to: %v", err)
-	}
-	if from != nil && to != nil && to.Before(*from) {
-		log.Fatal("--to cannot be before --from")
-	}
-
-	opts := normalizeOptions{
-		Apply:                 apply,
-		RecordingID:           recordingID,
-		ProjectFlockKandangID: projectFlockKandangID,
-		From:                  from,
-		To:                    to,
-		BatchSize:             batchSize,
-		Limit:                 limit,
-	}
-
-	ctx := context.Background()
-	db := database.Connect(config.DBHost, config.DBName)
-	repo := recordingRepo.NewRecordingRepository(db)
-
-	fmt.Printf("Mode: %s\n", modeLabel(opts.Apply))
-	fmt.Printf("Filter recording_id: %s\n", displayUint(opts.RecordingID))
-	fmt.Printf("Filter project_flock_kandangs_id: %s\n", displayUint(opts.ProjectFlockKandangID))
-	fmt.Printf("Filter from: %s\n", displayTime(opts.From))
-	fmt.Printf("Filter to: %s\n", displayTime(opts.To))
-	fmt.Printf("Batch size: %d\n", opts.BatchSize)
-	fmt.Printf("Limit: %d\n\n", opts.Limit)
-
-	stats, err := normalizeRecordings(ctx, db, repo, opts)
-	if err != nil {
-		log.Fatalf("normalize failed: %v", err)
-	}
-
-	fmt.Println()
-	fmt.Printf(
-		"Summary: processed=%d changed=%d updated=%d skipped=%d failed=%d\n",
-		stats.Processed,
-		stats.Changed,
-		stats.Updated,
-		stats.Skipped,
-		stats.Failed,
-	)
-
-	if stats.Failed > 0 {
-		os.Exit(1)
-	}
-}
-
-func normalizeRecordings(
-	ctx context.Context,
-	db *gorm.DB,
-	repo recordingRepo.RecordingRepository,
-	opts normalizeOptions,
-) (normalizeStats, error) {
-	stats := normalizeStats{}
-	lastID := uint(0)
-	initialChickCache := make(map[uint]float64)
-
-	for {
-		batchLimit := opts.BatchSize
-		if opts.Limit > 0 {
-			remaining := opts.Limit - stats.Processed
-			if remaining <= 0 {
-				break
-			}
-			if remaining < batchLimit {
-				batchLimit = remaining
-			}
-		}
-
-		rows, err := loadRecordingBatch(ctx, db, opts, lastID, batchLimit)
-		if err != nil {
-			return stats, err
-		}
-		if len(rows) == 0 {
-			break
-		}
-
-		for _, row := range rows {
-			stats.Processed++
-			lastID = row.ID
-
-			initialChick, ok := initialChickCache[row.ProjectFlockKandangID]
-			if !ok {
-				initialChick, err = repo.GetTotalChickinByProjectFlockKandang(db.WithContext(ctx), row.ProjectFlockKandangID)
-				if err != nil {
-					fmt.Printf("FAIL rec=%d error=getTotalChickinByProjectFlockKandang: %v\n", row.ID, err)
-					stats.Failed++
-					continue
-				}
-				initialChickCache[row.ProjectFlockKandangID] = initialChick
-			}
-
-			_, totalEggWeightGrams, err := repo.GetEggSummaryByRecording(db.WithContext(ctx), row.ID)
-			if err != nil {
-				fmt.Printf("FAIL rec=%d error=getEggSummaryByRecording: %v\n", row.ID, err)
-				stats.Failed++
-				continue
-			}
-
-			cumulativeEggQty, err := repo.GetCumulativeEggQtyByProjectFlockKandang(db.WithContext(ctx), row.ProjectFlockKandangID, row.RecordDatetime)
-			if err != nil {
-				fmt.Printf("FAIL rec=%d error=getCumulativeEggQtyByProjectFlockKandang: %v\n", row.ID, err)
-				stats.Failed++
-				continue
-			}
-
-			newHenHouse, newEggMass := computeNormalizedMetrics(initialChick, cumulativeEggQty, totalEggWeightGrams)
-			henHouseChanged := metricChanged(row.HenHouse, newHenHouse)
-			eggMassChanged := metricChanged(row.EggMass, newEggMass)
-
-			if !henHouseChanged && !eggMassChanged {
-				stats.Skipped++
-				continue
-			}
-
-			stats.Changed++
-			fmt.Printf(
-				"PLAN rec=%d pfk=%d at=%s hen_house:%s->%s egg_mass:%s->%s\n",
-				row.ID,
-				row.ProjectFlockKandangID,
-				row.RecordDatetime.UTC().Format(time.RFC3339),
-				displayFloat(row.HenHouse),
-				displayFloat(newHenHouse),
-				displayFloat(row.EggMass),
-				displayFloat(newEggMass),
-			)
-
-			if !opts.Apply {
-				continue
-			}
-
-			if err := updateRecordingMetrics(ctx, db, row.ID, newHenHouse, newEggMass); err != nil {
-				fmt.Printf("FAIL rec=%d error=updateRecordingMetrics: %v\n", row.ID, err)
-				stats.Failed++
-				continue
-			}
-
-			fmt.Printf(
-				"DONE rec=%d hen_house=%s egg_mass=%s\n",
-				row.ID,
-				displayFloat(newHenHouse),
-				displayFloat(newEggMass),
-			)
-			stats.Updated++
-		}
-
-		if opts.RecordingID > 0 {
-			break
-		}
-	}
-
-	return stats, nil
-}
-
-func loadRecordingBatch(
-	ctx context.Context,
-	db *gorm.DB,
-	opts normalizeOptions,
-	lastID uint,
-	limit int,
-) ([]recordingMetricRow, error) {
-	query := db.WithContext(ctx).
-		Table("recordings").
-		Select("id, project_flock_kandangs_id, record_datetime, hen_house, egg_mass").
-		Where("recordings.deleted_at IS NULL")
-
-	if opts.RecordingID > 0 {
-		query = query.Where("recordings.id = ?", opts.RecordingID)
-	}
-	if opts.ProjectFlockKandangID > 0 {
-		query = query.Where("recordings.project_flock_kandangs_id = ?", opts.ProjectFlockKandangID)
-	}
-	if opts.From != nil {
-		query = query.Where("recordings.record_datetime >= ?", *opts.From)
-	}
-	if opts.To != nil {
-		query = query.Where("recordings.record_datetime <= ?", *opts.To)
-	}
-	if opts.RecordingID == 0 && lastID > 0 {
-		query = query.Where("recordings.id > ?", lastID)
-	}
-
-	var rows []recordingMetricRow
-	err := query.
-		Order("recordings.id ASC").
-		Limit(limit).
-		Scan(&rows).Error
-	return rows, err
-}
-
-func computeNormalizedMetrics(initialChick, cumulativeEggQty, totalEggWeightGrams float64) (*float64, *float64) {
-	var henHouse *float64
-	if initialChick > 0 && cumulativeEggQty >= 0 {
-		value := cumulativeEggQty / initialChick
-		henHouse = &value
-	}
-
-	var eggMass *float64
-	if initialChick > 0 && totalEggWeightGrams > 0 {
-		value := totalEggWeightGrams / initialChick
-		eggMass = &value
-	}
-
-	return henHouse, eggMass
-}
-
-func updateRecordingMetrics(ctx context.Context, db *gorm.DB, recordingID uint, henHouse, eggMass *float64) error {
-	updates := map[string]any{}
-	if henHouse == nil {
-		updates["hen_house"] = gorm.Expr("NULL")
-	} else {
-		updates["hen_house"] = *henHouse
-	}
-	if eggMass == nil {
-		updates["egg_mass"] = gorm.Expr("NULL")
-	} else {
-		updates["egg_mass"] = *eggMass
-	}
-
-	return db.WithContext(ctx).
-		Table("recordings").
-		Where("id = ?", recordingID).
-		Updates(updates).Error
-}
-
-func metricChanged(oldValue, newValue *float64) bool {
-	if oldValue == nil && newValue == nil {
-		return false
-	}
-	if oldValue == nil || newValue == nil {
-		return true
-	}
-	return !nearlyEqual(*oldValue, *newValue)
-}
-
-func nearlyEqual(a, b float64) bool {
-	scale := math.Max(1, math.Max(math.Abs(a), math.Abs(b)))
-	return math.Abs(a-b) <= metricEpsilon*scale
-}
-
-func parseTimeBound(raw string, isUpper bool) (*time.Time, error) {
-	if raw == "" {
-		return nil, nil
-	}
-
-	layouts := []string{
-		time.RFC3339Nano,
-		time.RFC3339,
-		"2006-01-02 15:04:05",
-		"2006-01-02",
-	}
-
-	for _, layout := range layouts {
-		parsed, err := time.Parse(layout, raw)
-		if err != nil {
-			continue
-		}
-		if layout == "2006-01-02" {
-			if isUpper {
-				endOfDay := time.Date(parsed.Year(), parsed.Month(), parsed.Day(), 23, 59, 59, int(time.Second-time.Nanosecond), time.UTC)
-				return &endOfDay, nil
-			}
-			startOfDay := time.Date(parsed.Year(), parsed.Month(), parsed.Day(), 0, 0, 0, 0, time.UTC)
-			return &startOfDay, nil
-		}
-
-		t := parsed.UTC()
-		return &t, nil
-	}
-
-	return nil, fmt.Errorf("unsupported format %q", raw)
-}
-
-func modeLabel(apply bool) string {
-	if apply {
-		return "APPLY"
-	}
-	return "DRY-RUN"
-}
-
-func displayFloat(v *float64) string {
-	if v == nil {
-		return "NULL"
-	}
-	return fmt.Sprintf("%.6f", *v)
-}
-
-func displayTime(v *time.Time) string {
-	if v == nil {
-		return "<nil>"
-	}
-	return v.UTC().Format(time.RFC3339)
-}
-
-func displayUint(v uint) string {
-	if v == 0 {
-		return "<all>"
-	}
-	return fmt.Sprintf("%d", v)
-}

cmd/reflow-adjustments/main.go

@@ -1,333 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
-	"gitlab.com/mbugroup/lti-api.git/internal/config"
-	"gitlab.com/mbugroup/lti-api.git/internal/database"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
-	"gorm.io/gorm"
-)
-
-type adjustmentRow struct {
-	ID                 uint      `gorm:"column:id"`
-	ProductWarehouseID uint      `gorm:"column:product_warehouse_id"`
-	ProductID          uint      `gorm:"column:product_id"`
-	FunctionCode       string    `gorm:"column:function_code"`
-	UsageQty           float64   `gorm:"column:usage_qty"`
-	PendingQty         float64   `gorm:"column:pending_qty"`
-	StockLogIncrease   float64   `gorm:"column:stock_log_increase"`
-	StockLogDecrease   float64   `gorm:"column:stock_log_decrease"`
-	CreatedAt          time.Time `gorm:"column:created_at"`
-}
-
-type routeResolution struct {
-	FlagGroupCode string `gorm:"column:flag_group_code"`
-	Lane          string `gorm:"column:lane"`
-	FunctionCode  string `gorm:"column:function_code"`
-	SourceTable   string `gorm:"column:source_table"`
-	LegacyTypeKey string `gorm:"column:legacy_type_key"`
-}
-
-func main() {
-	var (
-		idsRaw                 string
-		apply                  bool
-		asOfCreatedAt          bool
-		compensateMissingAlloc bool
-	)
-
-	flag.StringVar(&idsRaw, "ids", "", "Comma-separated adjustment IDs (required), example: 1,2")
-	flag.BoolVar(&apply, "apply", false, "Apply changes. If false, run as dry-run")
-	flag.BoolVar(&asOfCreatedAt, "as-of-created-at", true, "Use adjustment created_at as reflow AsOf boundary")
-	flag.BoolVar(&compensateMissingAlloc, "compensate-missing-alloc", true, "When active allocations are missing and usage_qty > 0, temporarily add back usage_qty before reflow")
-	flag.Parse()
-
-	ids, err := parseIDs(idsRaw)
-	if err != nil {
-		log.Fatalf("invalid --ids: %v", err)
-	}
-	if len(ids) == 0 {
-		log.Fatal("--ids is required")
-	}
-
-	ctx := context.Background()
-	db := database.Connect(config.DBHost, config.DBName)
-	fifoStockV2Svc := commonSvc.NewFifoStockV2Service(db, nil)
-
-	adjustments, err := loadAdjustments(ctx, db, ids)
-	if err != nil {
-		log.Fatalf("failed to load adjustments: %v", err)
-	}
-	if len(adjustments) == 0 {
-		log.Fatal("no adjustments found for provided IDs")
-	}
-
-	sort.Slice(adjustments, func(i, j int) bool {
-		return adjustments[i].ID < adjustments[j].ID
-	})
-
-	fmt.Printf("Mode: %s\n", modeLabel(apply))
-	fmt.Printf("Adjustments loaded: %d\n\n", len(adjustments))
-
-	success := 0
-	failed := 0
-	skipped := 0
-
-	for _, adj := range adjustments {
-		if strings.TrimSpace(adj.FunctionCode) == "" {
-			fmt.Printf("SKIP adj=%d reason=function_code empty\n", adj.ID)
-			skipped++
-			continue
-		}
-
-		route, err := resolveRouteByFunctionCode(ctx, db, adj.ProductID, strings.ToUpper(strings.TrimSpace(adj.FunctionCode)))
-		if err != nil {
-			fmt.Printf("FAIL adj=%d error=resolve route: %v\n", adj.ID, err)
-			failed++
-			continue
-		}
-		if route.Lane != "USABLE" {
-			fmt.Printf("SKIP adj=%d reason=lane=%s (not USABLE)\n", adj.ID, route.Lane)
-			skipped++
-			continue
-		}
-
-		desiredQty := adj.UsageQty + adj.PendingQty
-		desiredQtySource := "usage+pending"
-		if desiredQty <= 0 && adj.StockLogDecrease > 0 {
-			desiredQty = adj.StockLogDecrease
-			desiredQtySource = "stock_log.decrease"
-		}
-		if desiredQty <= 0 {
-			fmt.Printf(
-				"SKIP adj=%d reason=no usable qty (usage=%.3f pending=%.3f stock_log.decrease=%.3f)\n",
-				adj.ID,
-				adj.UsageQty,
-				adj.PendingQty,
-				adj.StockLogDecrease,
-			)
-			skipped++
-			continue
-		}
-
-		activeAllocationCount, err := countActiveAllocations(ctx, db, fifo.UsableKeyAdjustmentOut.String(), adj.ID)
-		if err != nil {
-			fmt.Printf("FAIL adj=%d error=count allocations: %v\n", adj.ID, err)
-			failed++
-			continue
-		}
-
-		compensateQty := adj.UsageQty
-		if compensateQty <= 0 && desiredQtySource == "stock_log.decrease" {
-			compensateQty = adj.StockLogDecrease
-		}
-		shouldCompensate := compensateMissingAlloc && activeAllocationCount == 0 && compensateQty > 0
-
-		reflowReq := commonSvc.FifoStockV2ReflowRequest{
-			FlagGroupCode:      route.FlagGroupCode,
-			ProductWarehouseID: adj.ProductWarehouseID,
-			IdempotencyKey:     fmt.Sprintf("manual-adjustment-reflow-%d-%d", adj.ID, time.Now().UnixNano()),
-		}
-		if asOfCreatedAt {
-			asOf := adj.CreatedAt
-			reflowReq.AsOf = &asOf
-		}
-
-		fmt.Printf(
-			"PLAN adj=%d pw=%d product=%d function=%s group=%s desired=%.3f source=%s active_alloc=%d compensate=%t\n",
-			adj.ID,
-			adj.ProductWarehouseID,
-			adj.ProductID,
-			route.FunctionCode,
-			route.FlagGroupCode,
-			desiredQty,
-			desiredQtySource,
-			activeAllocationCount,
-			shouldCompensate,
-		)
-
-		if !apply {
-			skipped++
-			continue
-		}
-
-		err = db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-			if shouldCompensate {
-				if err := tx.Table("product_warehouses").
-					Where("id = ?", adj.ProductWarehouseID).
-					Update("qty", gorm.Expr("COALESCE(qty,0) + ?", compensateQty)).Error; err != nil {
-					return fmt.Errorf("compensate product_warehouse qty: %w", err)
-				}
-			}
-
-			reflowReq.Tx = tx
-			res, err := fifoStockV2Svc.Reflow(ctx, reflowReq)
-			if err != nil {
-				return err
-			}
-
-			fmt.Printf(
-				"DONE adj=%d rollback=%.3f allocate=%.3f pending=%.3f\n",
-				adj.ID,
-				res.Rollback.ReleasedQty,
-				res.Allocate.AllocatedQty,
-				res.Allocate.PendingQty,
-			)
-			return nil
-		})
-		if err != nil {
-			fmt.Printf("FAIL adj=%d error=%v\n", adj.ID, err)
-			failed++
-			continue
-		}
-
-		success++
-	}
-
-	fmt.Println()
-	fmt.Printf("Summary: success=%d failed=%d skipped=%d\n", success, failed, skipped)
-	if failed > 0 {
-		os.Exit(1)
-	}
-}
-
-func modeLabel(apply bool) string {
-	if apply {
-		return "APPLY"
-	}
-	return "DRY-RUN"
-}
-
-func parseIDs(raw string) ([]uint, error) {
-	raw = strings.TrimSpace(raw)
-	if raw == "" {
-		return nil, nil
-	}
-	parts := strings.Split(raw, ",")
-	ids := make([]uint, 0, len(parts))
-	seen := map[uint]struct{}{}
-
-	for _, part := range parts {
-		part = strings.TrimSpace(part)
-		if part == "" {
-			continue
-		}
-		value, err := strconv.ParseUint(part, 10, 64)
-		if err != nil {
-			return nil, fmt.Errorf("invalid id %q", part)
-		}
-		if value == 0 {
-			return nil, fmt.Errorf("id must be > 0: %q", part)
-		}
-		id := uint(value)
-		if _, ok := seen[id]; ok {
-			continue
-		}
-		seen[id] = struct{}{}
-		ids = append(ids, id)
-	}
-
-	return ids, nil
-}
-
-func loadAdjustments(ctx context.Context, db *gorm.DB, ids []uint) ([]adjustmentRow, error) {
-	var rows []adjustmentRow
-	err := db.WithContext(ctx).
-		Table("adjustment_stocks a").
-		Select(`
-				a.id,
-				a.product_warehouse_id,
-				pw.product_id,
-				a.function_code,
-				COALESCE(a.usage_qty, 0) AS usage_qty,
-				COALESCE(a.pending_qty, 0) AS pending_qty,
-				COALESCE((
-					SELECT sl.increase
-					FROM stock_logs sl
-					WHERE sl.loggable_type = 'ADJUSTMENT'
-						AND sl.loggable_id = a.id
-					ORDER BY sl.id DESC
-					LIMIT 1
-				), 0) AS stock_log_increase,
-				COALESCE((
-					SELECT sl.decrease
-					FROM stock_logs sl
-					WHERE sl.loggable_type = 'ADJUSTMENT'
-						AND sl.loggable_id = a.id
-					ORDER BY sl.id DESC
-					LIMIT 1
-				), 0) AS stock_log_decrease,
-				a.created_at
-			`).
-		Joins("JOIN product_warehouses pw ON pw.id = a.product_warehouse_id").
-		Where("a.id IN ?", ids).
-		Find(&rows).Error
-	if err != nil {
-		return nil, err
-	}
-	return rows, nil
-}
-
-func resolveRouteByFunctionCode(ctx context.Context, db *gorm.DB, productID uint, functionCode string) (*routeResolution, error) {
-	var rows []routeResolution
-	err := db.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules rr").
-		Select("rr.flag_group_code, rr.lane, rr.function_code, rr.source_table, rr.legacy_type_key").
-		Joins("JOIN fifo_stock_v2_flag_groups fg ON fg.code = rr.flag_group_code AND fg.is_active = TRUE").
-		Where("rr.is_active = TRUE").
-		Where("rr.function_code = ?", functionCode).
-		Where(`
-			EXISTS (
-				SELECT 1
-				FROM flags f
-				JOIN fifo_stock_v2_flag_members fm ON fm.flag_name = f.name AND fm.is_active = TRUE
-				WHERE f.flagable_type = ?
-					AND f.flagable_id = ?
-					AND fm.flag_group_code = rr.flag_group_code
-			)
-		`, entity.FlagableTypeProduct, productID).
-		Order("CASE WHEN rr.source_table = 'adjustment_stocks' THEN 0 ELSE 1 END ASC").
-		Order("rr.id ASC").
-		Find(&rows).Error
-	if err != nil {
-		return nil, err
-	}
-	if len(rows) == 0 {
-		return nil, fmt.Errorf("no route found for product_id=%d function_code=%s", productID, functionCode)
-	}
-
-	selected := rows[0]
-	for _, row := range rows {
-		if row.Lane != selected.Lane {
-			return nil, fmt.Errorf("ambiguous lane for product_id=%d function_code=%s", productID, functionCode)
-		}
-	}
-
-	selected.FunctionCode = functionCode
-	return &selected, nil
-}
-
-func countActiveAllocations(ctx context.Context, db *gorm.DB, usableType string, usableID uint) (int64, error) {
-	var count int64
-	err := db.WithContext(ctx).
-		Table("stock_allocations").
-		Where("usable_type = ? AND usable_id = ?", usableType, usableID).
-		Where("status = ?", entity.StockAllocationStatusActive).
-		Where("allocation_purpose = ?", entity.StockAllocationPurposeConsume).
-		Count(&count).Error
-	if err != nil {
-		return 0, err
-	}
-	return count, nil
-}

cmd/reflow-project-flock-kandang/main.go

@@ -1,648 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"log"
-	"math"
-	"os"
-	"sort"
-	"strings"
-	"time"
-
-	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
-	"gitlab.com/mbugroup/lti-api.git/internal/config"
-	"gitlab.com/mbugroup/lti-api.git/internal/database"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
-	"gorm.io/gorm"
-)
-
-type productWarehouseScopeRow struct {
-	ProductWarehouseID    uint  `gorm:"column:product_warehouse_id"`
-	ProductID             uint  `gorm:"column:product_id"`
-	WarehouseID           uint  `gorm:"column:warehouse_id"`
-	ProjectFlockKandangID *uint `gorm:"column:project_flock_kandang_id"`
-}
-
-type reflowTarget struct {
-	ProductWarehouseID    uint
-	ProductID             uint
-	WarehouseID           uint
-	ProjectFlockKandangID *uint
-	FlagGroupCode         string
-}
-
-func main() {
-	var (
-		projectFlockKandangID uint
-		apply                 bool
-		asOfRaw               string
-		includeShared         bool
-	)
-
-	flag.UintVar(&projectFlockKandangID, "project-flock-kandang-id", 0, "Project flock kandang ID (required)")
-	flag.BoolVar(&apply, "apply", false, "Apply reflow. If false, run as dry-run")
-	flag.StringVar(&asOfRaw, "as-of", "", "Optional AsOf boundary. Format: RFC3339 or YYYY-MM-DD")
-	flag.BoolVar(&includeShared, "include-shared", true, "Include product warehouses referenced by transactions in this PFK scope (including shared/non-bound product warehouses)")
-	flag.Parse()
-
-	if projectFlockKandangID == 0 {
-		log.Fatal("--project-flock-kandang-id is required")
-	}
-
-	asOf, err := parseAsOf(asOfRaw)
-	if err != nil {
-		log.Fatalf("invalid --as-of: %v", err)
-	}
-
-	ctx := context.Background()
-	db := database.Connect(config.DBHost, config.DBName)
-	fifoStockV2Svc := commonSvc.NewFifoStockV2Service(db, nil)
-
-	exists, err := projectFlockKandangExists(ctx, db, projectFlockKandangID)
-	if err != nil {
-		log.Fatalf("failed to check project flock kandang: %v", err)
-	}
-	if !exists {
-		log.Fatalf("project_flock_kandang_id %d not found", projectFlockKandangID)
-	}
-
-	scopedPWs, err := loadScopedProductWarehouses(ctx, db, projectFlockKandangID, includeShared)
-	if err != nil {
-		log.Fatalf("failed to load scoped product warehouses: %v", err)
-	}
-	if len(scopedPWs) == 0 {
-		fmt.Printf("Mode: %s\n", modeLabel(apply))
-		fmt.Printf("Scope: project_flock_kandang_id=%d\n", projectFlockKandangID)
-		fmt.Println("No product warehouse found in scope")
-		return
-	}
-
-	targets := make([]reflowTarget, 0, len(scopedPWs))
-	skippedPW := 0
-	failedResolve := 0
-
-	for _, pw := range scopedPWs {
-		flagGroups, err := resolveFlagGroupsByProductWarehouse(ctx, db, pw.ProductWarehouseID)
-		if err != nil {
-			fmt.Printf("FAIL pw=%d error=resolve flag groups: %v\n", pw.ProductWarehouseID, err)
-			failedResolve++
-			continue
-		}
-		if len(flagGroups) == 0 {
-			fmt.Printf("SKIP pw=%d reason=no active fifo v2 route by product flag\n", pw.ProductWarehouseID)
-			skippedPW++
-			continue
-		}
-		for _, group := range flagGroups {
-			targets = append(targets, reflowTarget{
-				ProductWarehouseID:    pw.ProductWarehouseID,
-				ProductID:             pw.ProductID,
-				WarehouseID:           pw.WarehouseID,
-				ProjectFlockKandangID: pw.ProjectFlockKandangID,
-				FlagGroupCode:         group,
-			})
-		}
-	}
-
-	sort.Slice(targets, func(i, j int) bool {
-		if targets[i].ProductWarehouseID == targets[j].ProductWarehouseID {
-			return targets[i].FlagGroupCode < targets[j].FlagGroupCode
-		}
-		return targets[i].ProductWarehouseID < targets[j].ProductWarehouseID
-	})
-
-	fmt.Printf("Mode: %s\n", modeLabel(apply))
-	fmt.Printf("Scope: project_flock_kandang_id=%d include_shared=%t\n", projectFlockKandangID, includeShared)
-	if asOf != nil {
-		fmt.Printf("AsOf: %s\n", asOf.UTC().Format(time.RFC3339))
-	} else {
-		fmt.Println("AsOf: <nil> (full timeline)")
-	}
-	fmt.Printf("Product warehouses in scope: %d\n", len(scopedPWs))
-	fmt.Printf("Planned reflow targets: %d\n\n", len(targets))
-
-	for _, target := range targets {
-		fmt.Printf(
-			"PLAN pw=%d product=%d warehouse=%d pw_pfk=%s flag_group=%s\n",
-			target.ProductWarehouseID,
-			target.ProductID,
-			target.WarehouseID,
-			displayOptionalUint(target.ProjectFlockKandangID),
-			target.FlagGroupCode,
-		)
-	}
-
-	if !apply {
-		fmt.Println()
-		fmt.Printf("Summary: planned=%d skipped_pw=%d failed_resolve=%d applied=0 failed_apply=0\n", len(targets), skippedPW, failedResolve)
-		if failedResolve > 0 {
-			os.Exit(1)
-		}
-		return
-	}
-
-	successApply := 0
-	failedApply := 0
-	for idx, target := range targets {
-		req := commonSvc.FifoStockV2ReflowRequest{
-			FlagGroupCode:      target.FlagGroupCode,
-			ProductWarehouseID: target.ProductWarehouseID,
-			AsOf:               asOf,
-			IdempotencyKey: fmt.Sprintf(
-				"manual-pfk-reflow-%d-%d-%s-%d-%d",
-				projectFlockKandangID,
-				target.ProductWarehouseID,
-				strings.ToUpper(strings.TrimSpace(target.FlagGroupCode)),
-				time.Now().UnixNano(),
-				idx,
-			),
-		}
-
-		res, err := fifoStockV2Svc.Reflow(ctx, req)
-		if err != nil {
-			fmt.Printf("FAIL pw=%d flag_group=%s error=%v\n", target.ProductWarehouseID, target.FlagGroupCode, err)
-			failedApply++
-			continue
-		}
-
-		fmt.Printf(
-			"DONE pw=%d flag_group=%s rollback=%.3f allocate=%.3f pending=%.3f processed_usable=%d\n",
-			target.ProductWarehouseID,
-			target.FlagGroupCode,
-			res.Rollback.ReleasedQty,
-			res.Allocate.AllocatedQty,
-			res.Allocate.PendingQty,
-			res.ProcessedUsables,
-		)
-		successApply++
-	}
-
-	orphanPopulationRows := int64(0)
-	syncedPopulationQtyRows := int64(0)
-	syncedPopulationUsedRows := int64(0)
-	traceReleasedRows := int64(0)
-	traceInsertedRows := int64(0)
-	if rowsOrphan, rowsQty, rowsUsed, err := resyncProjectFlockPopulation(ctx, db, projectFlockKandangID); err != nil {
-		fmt.Printf("FAIL population_resync project_flock_kandang_id=%d error=%v\n", projectFlockKandangID, err)
-		failedApply++
-	} else {
-		orphanPopulationRows = rowsOrphan
-		syncedPopulationQtyRows = rowsQty
-		syncedPopulationUsedRows = rowsUsed
-		fmt.Printf(
-			"SYNC project_flock_populations orphan_marked=%d qty_synced=%d used_synced=%d\n",
-			orphanPopulationRows,
-			syncedPopulationQtyRows,
-			syncedPopulationUsedRows,
-		)
-	}
-
-	if released, inserted, err := resyncChickinTraceByProjectFlockKandang(ctx, db, fifoStockV2Svc, projectFlockKandangID); err != nil {
-		fmt.Printf("FAIL chickin_trace_resync project_flock_kandang_id=%d error=%v\n", projectFlockKandangID, err)
-		failedApply++
-	} else {
-		traceReleasedRows = released
-		traceInsertedRows = inserted
-		fmt.Printf(
-			"SYNC chickin_trace released=%d inserted=%d\n",
-			traceReleasedRows,
-			traceInsertedRows,
-		)
-	}
-
-	fmt.Println()
-	fmt.Printf(
-		"Summary: planned=%d skipped_pw=%d failed_resolve=%d applied=%d failed_apply=%d population_orphan=%d population_qty_synced=%d population_used_synced=%d trace_released=%d trace_inserted=%d\n",
-		len(targets),
-		skippedPW,
-		failedResolve,
-		successApply,
-		failedApply,
-		orphanPopulationRows,
-		syncedPopulationQtyRows,
-		syncedPopulationUsedRows,
-		traceReleasedRows,
-		traceInsertedRows,
-	)
-	if failedResolve > 0 || failedApply > 0 {
-		os.Exit(1)
-	}
-}
-
-func parseAsOf(raw string) (*time.Time, error) {
-	raw = strings.TrimSpace(raw)
-	if raw == "" {
-		return nil, nil
-	}
-
-	layouts := []string{
-		time.RFC3339Nano,
-		time.RFC3339,
-		"2006-01-02 15:04:05",
-		"2006-01-02",
-	}
-
-	for _, layout := range layouts {
-		parsed, err := time.Parse(layout, raw)
-		if err != nil {
-			continue
-		}
-		if layout == "2006-01-02" {
-			endOfDay := time.Date(parsed.Year(), parsed.Month(), parsed.Day(), 23, 59, 59, int(time.Second-time.Nanosecond), time.UTC)
-			return &endOfDay, nil
-		}
-		asOf := parsed.UTC()
-		return &asOf, nil
-	}
-
-	return nil, fmt.Errorf("unsupported format %q", raw)
-}
-
-func modeLabel(apply bool) string {
-	if apply {
-		return "APPLY"
-	}
-	return "DRY-RUN"
-}
-
-func displayOptionalUint(v *uint) string {
-	if v == nil {
-		return "NULL"
-	}
-	return fmt.Sprintf("%d", *v)
-}
-
-func projectFlockKandangExists(ctx context.Context, db *gorm.DB, projectFlockKandangID uint) (bool, error) {
-	var count int64
-	err := db.WithContext(ctx).
-		Table("project_flock_kandangs").
-		Where("id = ?", projectFlockKandangID).
-		Count(&count).Error
-	if err != nil {
-		return false, err
-	}
-	return count > 0, nil
-}
-
-func loadScopedProductWarehouses(ctx context.Context, db *gorm.DB, projectFlockKandangID uint, includeShared bool) ([]productWarehouseScopeRow, error) {
-	if !includeShared {
-		var rows []productWarehouseScopeRow
-		err := db.WithContext(ctx).
-			Table("product_warehouses").
-			Select("id AS product_warehouse_id, product_id, warehouse_id, project_flock_kandang_id").
-			Where("project_flock_kandang_id = ?", projectFlockKandangID).
-			Order("id ASC").
-			Scan(&rows).Error
-		if err != nil {
-			return nil, err
-		}
-		return rows, nil
-	}
-
-	query := `
-		WITH scoped_pw AS (
-			SELECT pw.id AS product_warehouse_id
-			FROM product_warehouses pw
-			WHERE pw.project_flock_kandang_id = ?
-
-			UNION
-			SELECT pc.product_warehouse_id
-			FROM project_chickins pc
-			WHERE pc.project_flock_kandang_id = ?
-				AND pc.deleted_at IS NULL
-
-			UNION
-			SELECT rs.product_warehouse_id
-			FROM recordings r
-			JOIN recording_stocks rs ON rs.recording_id = r.id
-			WHERE r.project_flock_kandangs_id = ?
-				AND r.deleted_at IS NULL
-
-			UNION
-			SELECT rd.product_warehouse_id
-			FROM recordings r
-			JOIN recording_depletions rd ON rd.recording_id = r.id
-			WHERE r.project_flock_kandangs_id = ?
-				AND r.deleted_at IS NULL
-
-			UNION
-			SELECT rd.source_product_warehouse_id
-			FROM recordings r
-			JOIN recording_depletions rd ON rd.recording_id = r.id
-			WHERE r.project_flock_kandangs_id = ?
-				AND r.deleted_at IS NULL
-				AND rd.source_product_warehouse_id IS NOT NULL
-
-			UNION
-			SELECT re.product_warehouse_id
-			FROM recordings r
-			JOIN recording_eggs re ON re.recording_id = r.id
-			WHERE r.project_flock_kandangs_id = ?
-				AND r.deleted_at IS NULL
-
-			UNION
-			SELECT lts.product_warehouse_id
-			FROM laying_transfer_sources lts
-			WHERE lts.source_project_flock_kandang_id = ?
-				AND lts.deleted_at IS NULL
-				AND lts.product_warehouse_id IS NOT NULL
-
-			UNION
-			SELECT ltt.product_warehouse_id
-			FROM laying_transfer_targets ltt
-			WHERE ltt.target_project_flock_kandang_id = ?
-				AND ltt.deleted_at IS NULL
-				AND ltt.product_warehouse_id IS NOT NULL
-
-			UNION
-			SELECT pi.product_warehouse_id
-			FROM purchase_items pi
-			WHERE pi.project_flock_kandang_id = ?
-				AND pi.product_warehouse_id IS NOT NULL
-		)
-		SELECT DISTINCT
-			pw.id AS product_warehouse_id,
-			pw.product_id,
-			pw.warehouse_id,
-			pw.project_flock_kandang_id
-		FROM scoped_pw s
-		JOIN product_warehouses pw ON pw.id = s.product_warehouse_id
-		ORDER BY pw.id ASC
-	`
-
-	var rows []productWarehouseScopeRow
-	err := db.WithContext(ctx).
-		Raw(
-			query,
-			projectFlockKandangID,
-			projectFlockKandangID,
-			projectFlockKandangID,
-			projectFlockKandangID,
-			projectFlockKandangID,
-			projectFlockKandangID,
-			projectFlockKandangID,
-			projectFlockKandangID,
-			projectFlockKandangID,
-		).
-		Scan(&rows).Error
-	if err != nil {
-		return nil, err
-	}
-	return rows, nil
-}
-
-func resolveFlagGroupsByProductWarehouse(ctx context.Context, db *gorm.DB, productWarehouseID uint) ([]string, error) {
-	var groups []string
-	err := db.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules rr").
-		Select("DISTINCT rr.flag_group_code").
-		Joins("JOIN fifo_stock_v2_flag_groups fg ON fg.code = rr.flag_group_code AND fg.is_active = TRUE").
-		Where("rr.is_active = TRUE").
-		Where(`
-			EXISTS (
-				SELECT 1
-				FROM product_warehouses pw
-				JOIN flags f ON f.flagable_id = pw.product_id
-				JOIN fifo_stock_v2_flag_members fm ON fm.flag_name = f.name AND fm.is_active = TRUE
-				WHERE pw.id = ?
-					AND f.flagable_type = ?
-					AND fm.flag_group_code = rr.flag_group_code
-			)
-		`, productWarehouseID, entity.FlagableTypeProduct).
-		Order("rr.flag_group_code ASC").
-		Scan(&groups).Error
-	if err != nil {
-		return nil, err
-	}
-	return groups, nil
-}
-
-func resyncProjectFlockPopulation(ctx context.Context, db *gorm.DB, projectFlockKandangID uint) (int64, int64, int64, error) {
-	if projectFlockKandangID == 0 {
-		return 0, 0, 0, nil
-	}
-
-	orphanResult := db.WithContext(ctx).Exec(`
-		UPDATE project_flock_populations pfp
-		SET deleted_at = NOW(),
-			updated_at = NOW()
-		FROM project_chickins pc
-		WHERE pfp.project_chickin_id = pc.id
-		  AND pc.project_flock_kandang_id = ?
-		  AND pc.deleted_at IS NOT NULL
-		  AND pfp.deleted_at IS NULL
-	`, projectFlockKandangID)
-	if orphanResult.Error != nil {
-		return 0, 0, 0, orphanResult.Error
-	}
-
-	qtyResult := db.WithContext(ctx).Exec(`
-		UPDATE project_flock_populations p
-		SET total_qty = GREATEST(COALESCE(pc.usage_qty, 0), 0),
-			updated_at = NOW()
-		FROM project_chickins pc
-		WHERE p.project_chickin_id = pc.id
-		  AND pc.project_flock_kandang_id = ?
-		  AND pc.deleted_at IS NULL
-		  AND p.deleted_at IS NULL
-	`, projectFlockKandangID)
-	if qtyResult.Error != nil {
-		return 0, 0, 0, qtyResult.Error
-	}
-
-	usedResult := db.WithContext(ctx).Exec(`
-		WITH scoped AS (
-			SELECT pfp.id, pfp.total_qty
-			FROM project_flock_populations pfp
-			JOIN project_chickins pc ON pc.id = pfp.project_chickin_id
-			WHERE pc.project_flock_kandang_id = ?
-			  AND pc.deleted_at IS NULL
-			  AND pfp.deleted_at IS NULL
-		),
-		alloc AS (
-			SELECT sa.stockable_id, SUM(sa.qty) AS used_qty
-			FROM stock_allocations sa
-			WHERE sa.stockable_type = 'PROJECT_FLOCK_POPULATION'
-			  AND sa.status = 'ACTIVE'
-				  AND sa.allocation_purpose = 'CONSUME'
-				GROUP BY sa.stockable_id
-			)
-		UPDATE project_flock_populations p
-		SET total_used_qty = LEAST(COALESCE(a.used_qty, 0), GREATEST(s.total_qty, 0)),
-			updated_at = NOW()
-		FROM scoped s
-		LEFT JOIN alloc a ON a.stockable_id = s.id
-		WHERE p.id = s.id
-	`, projectFlockKandangID)
-	if usedResult.Error != nil {
-		return 0, 0, 0, usedResult.Error
-	}
-
-	return orphanResult.RowsAffected, qtyResult.RowsAffected, usedResult.RowsAffected, nil
-}
-func resyncChickinTraceByProjectFlockKandang(
-	ctx context.Context,
-	db *gorm.DB,
-	fifoStockV2Svc commonSvc.FifoStockV2Service,
-	projectFlockKandangID uint,
-) (int64, int64, error) {
-	if projectFlockKandangID == 0 {
-		return 0, 0, nil
-	}
-
-	var productWarehouseIDs []uint
-	if err := db.WithContext(ctx).
-		Table("project_chickins").
-		Distinct("product_warehouse_id").
-		Where("project_flock_kandang_id = ?", projectFlockKandangID).
-		Where("deleted_at IS NULL").
-		Order("product_warehouse_id ASC").
-		Pluck("product_warehouse_id", &productWarehouseIDs).Error; err != nil {
-		return 0, 0, err
-	}
-	if len(productWarehouseIDs) == 0 {
-		return 0, 0, nil
-	}
-
-	totalReleased := int64(0)
-	totalInserted := int64(0)
-
-	for _, productWarehouseID := range productWarehouseIDs {
-		var releasedRows int64
-		var insertedRows int64
-
-		err := db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-			flagGroups, err := resolveFlagGroupsByProductWarehouse(ctx, tx, productWarehouseID)
-			if err != nil {
-				return err
-			}
-			if len(flagGroups) == 0 {
-				return nil
-			}
-			flagGroupCode := strings.TrimSpace(flagGroups[0])
-			if flagGroupCode == "" {
-				return nil
-			}
-
-			released := tx.WithContext(ctx).
-				Table("stock_allocations").
-				Where("product_warehouse_id = ?", productWarehouseID).
-				Where("usable_type = ?", fifo.UsableKeyProjectChickin.String()).
-				Where("allocation_purpose = ?", entity.StockAllocationPurposeTraceChickin).
-				Where("status = ?", entity.StockAllocationStatusActive).
-				Updates(map[string]any{
-					"status":      entity.StockAllocationStatusReleased,
-					"released_at": time.Now(),
-					"updated_at":  time.Now(),
-					"note":        "chickin_trace_reflow_reset",
-				})
-			if released.Error != nil {
-				return released.Error
-			}
-			releasedRows = released.RowsAffected
-
-			type chickinRow struct {
-				ID       uint      `gorm:"column:id"`
-				UsageQty float64   `gorm:"column:usage_qty"`
-				ChickIn  time.Time `gorm:"column:chick_in_date"`
-			}
-			chickins := make([]chickinRow, 0)
-			if err := tx.WithContext(ctx).
-				Table("project_chickins").
-				Select("id, usage_qty, chick_in_date").
-				Where("product_warehouse_id = ?", productWarehouseID).
-				Where("deleted_at IS NULL").
-				Where("usage_qty > 0").
-				Order("chick_in_date ASC, id ASC").
-				Scan(&chickins).Error; err != nil {
-				return err
-			}
-			if len(chickins) == 0 {
-				return nil
-			}
-
-			gatherRows, err := fifoStockV2Svc.Gather(ctx, commonSvc.FifoStockV2GatherRequest{
-				FlagGroupCode:      flagGroupCode,
-				Lane:               "STOCKABLE",
-				AllocationPurpose:  entity.StockAllocationPurposeTraceChickin,
-				IgnoreSourceUsed:   true,
-				ProductWarehouseID: productWarehouseID,
-				Limit:              50000,
-				Tx:                 tx,
-			})
-			if err != nil {
-				return err
-			}
-			if len(gatherRows) == 0 {
-				return nil
-			}
-
-			type lotKey struct {
-				StockableType string
-				StockableID   uint
-			}
-			remainingByLot := make(map[lotKey]float64, len(gatherRows))
-			for _, row := range gatherRows {
-				key := lotKey{StockableType: row.Ref.LegacyTypeKey, StockableID: row.Ref.ID}
-				remainingByLot[key] = row.AvailableQuantity
-			}
-
-			now := time.Now()
-			lotIndex := 0
-			for _, chickinRow := range chickins {
-				remaining := chickinRow.UsageQty
-				for remaining > 1e-6 && lotIndex < len(gatherRows) {
-					lot := gatherRows[lotIndex]
-					key := lotKey{StockableType: lot.Ref.LegacyTypeKey, StockableID: lot.Ref.ID}
-					available := remainingByLot[key]
-					if available <= 1e-6 {
-						lotIndex++
-						continue
-					}
-
-					portion := math.Min(remaining, available)
-					if portion <= 1e-6 {
-						lotIndex++
-						continue
-					}
-
-					insert := map[string]any{
-						"product_warehouse_id": productWarehouseID,
-						"stockable_type":       lot.Ref.LegacyTypeKey,
-						"stockable_id":         lot.Ref.ID,
-						"usable_type":          fifo.UsableKeyProjectChickin.String(),
-						"usable_id":            chickinRow.ID,
-						"qty":                  portion,
-						"status":               entity.StockAllocationStatusActive,
-						"allocation_purpose":   entity.StockAllocationPurposeTraceChickin,
-						"engine_version":       "v2",
-						"flag_group_code":      flagGroupCode,
-						"function_code":        "CHICKIN_TRACE",
-						"created_at":           now,
-						"updated_at":           now,
-					}
-					if err := tx.WithContext(ctx).Table("stock_allocations").Create(insert).Error; err != nil {
-						return err
-					}
-
-					insertedRows++
-					remaining -= portion
-					remainingByLot[key] = available - portion
-				}
-			}
-
-			return nil
-		})
-		if err != nil {
-			return totalReleased, totalInserted, err
-		}
-
-		totalReleased += releasedRows
-		totalInserted += insertedRows
-	}
-
-	return totalReleased, totalInserted, nil
-}

cmd/reflow-quantity-product-warehouse-from-stock-allocation/main.go

@@ -1,282 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"flag"
-	"fmt"
-	"log"
-	"math"
-	"os"
-	"strings"
-
-	"gitlab.com/mbugroup/lti-api.git/internal/config"
-	"gitlab.com/mbugroup/lti-api.git/internal/database"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
-	"gorm.io/gorm"
-)
-
-const qtyEpsilon = 1e-6
-
-const (
-	levelAll                = 1
-	levelByProductName      = 2
-	levelByProductWarehouse = 3
-)
-
-type reflowRow struct {
-	ProductWarehouseID uint    `gorm:"column:product_warehouse_id"`
-	ProductID          uint    `gorm:"column:product_id"`
-	ProductName        string  `gorm:"column:product_name"`
-	CurrentQty         float64 `gorm:"column:current_qty"`
-	SumTotalQty        float64 `gorm:"column:sum_total_qty"`
-	SumAllocatedQty    float64 `gorm:"column:sum_allocated_qty"`
-	ComputedQty        float64 `gorm:"column:computed_qty"`
-}
-
-func main() {
-	var (
-		apply              bool
-		level              int
-		productName        string
-		productWarehouseID uint
-	)
-
-	flag.BoolVar(&apply, "apply", false, "Apply changes. If false, run as dry-run")
-	flag.IntVar(&level, "level", levelAll, "CLI level: 1=all product_warehouse scope, 2=product name scope, 3=product_warehouse_id scope")
-	flag.StringVar(&productName, "product-name", "", "Product name (required for level 2)")
-	flag.UintVar(&productWarehouseID, "product-warehouse-id", 0, "Product warehouse id (required for level 3)")
-	flag.Parse()
-
-	productName = strings.TrimSpace(productName)
-	if err := validateFlags(level, productName, productWarehouseID); err != nil {
-		log.Fatalf("invalid flags: %v", err)
-	}
-
-	ctx := context.Background()
-	db := database.Connect(config.DBHost, config.DBName)
-
-	rows, err := loadReflowRows(ctx, db, level, productName, productWarehouseID)
-	if err != nil {
-		log.Fatalf("failed to calculate reflow qty: %v", err)
-	}
-
-	fmt.Printf("Mode: %s\n", modeLabel(apply))
-	fmt.Printf("Level: %d (%s)\n", level, levelLabel(level))
-	if productName != "" {
-		fmt.Printf("Filter product_name: %s\n", productName)
-	}
-	if productWarehouseID > 0 {
-		fmt.Printf("Filter product_warehouse_id: %d\n", productWarehouseID)
-	}
-	fmt.Printf("Targets found: %d\n\n", len(rows))
-
-	if len(rows) == 0 {
-		fmt.Println("No product warehouse found from purchase_items scope")
-		return
-	}
-
-	negativePlan := 0
-	for _, row := range rows {
-		if row.ComputedQty < 0 {
-			negativePlan++
-		}
-
-		fmt.Printf(
-			"PLAN pw=%d product_id=%d product=%q current_qty=%.3f total_qty=%.3f allocated_qty=%.3f computed_qty=%.3f delta=%.3f\n",
-			row.ProductWarehouseID,
-			row.ProductID,
-			row.ProductName,
-			row.CurrentQty,
-			row.SumTotalQty,
-			row.SumAllocatedQty,
-			row.ComputedQty,
-			row.ComputedQty-row.CurrentQty,
-		)
-	}
-
-	if !apply {
-		fmt.Println()
-		fmt.Printf("Summary: planned=%d updated=0 skipped=0 failed=0 negative_plan=%d\n", len(rows), negativePlan)
-		return
-	}
-
-	updated := 0
-	skipped := 0
-	negativeUpdated := 0
-
-	err = db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		for _, row := range rows {
-			if nearlyEqual(row.CurrentQty, row.ComputedQty) {
-				fmt.Printf(
-					"SKIP pw=%d reason=no_change current_qty=%.3f computed_qty=%.3f\n",
-					row.ProductWarehouseID,
-					row.CurrentQty,
-					row.ComputedQty,
-				)
-				skipped++
-				continue
-			}
-
-			if err := tx.Table("product_warehouses").
-				Where("id = ?", row.ProductWarehouseID).
-				Update("qty", row.ComputedQty).Error; err != nil {
-				return fmt.Errorf("update qty for product_warehouse_id=%d: %w", row.ProductWarehouseID, err)
-			}
-
-			if row.ComputedQty < 0 {
-				negativeUpdated++
-			}
-
-			fmt.Printf(
-				"DONE pw=%d product_id=%d product=%q old_qty=%.3f new_qty=%.3f\n",
-				row.ProductWarehouseID,
-				row.ProductID,
-				row.ProductName,
-				row.CurrentQty,
-				row.ComputedQty,
-			)
-			updated++
-		}
-
-		return nil
-	})
-	if err != nil {
-		fmt.Println()
-		fmt.Printf(
-			"Summary: planned=%d updated=%d skipped=%d failed=1 negative_plan=%d negative_updated=%d\n",
-			len(rows),
-			updated,
-			skipped,
-			negativePlan,
-			negativeUpdated,
-		)
-		log.Printf("error: %v", err)
-		os.Exit(1)
-	}
-
-	fmt.Println()
-	fmt.Printf(
-		"Summary: planned=%d updated=%d skipped=%d failed=0 negative_plan=%d negative_updated=%d\n",
-		len(rows),
-		updated,
-		skipped,
-		negativePlan,
-		negativeUpdated,
-	)
-}
-
-func validateFlags(level int, productName string, productWarehouseID uint) error {
-	switch level {
-	case levelAll:
-		if productName != "" {
-			return errors.New("--product-name cannot be used on level 1")
-		}
-		if productWarehouseID > 0 {
-			return errors.New("--product-warehouse-id cannot be used on level 1")
-		}
-	case levelByProductName:
-		if productName == "" {
-			return errors.New("--product-name is required on level 2")
-		}
-		if productWarehouseID > 0 {
-			return errors.New("--product-warehouse-id cannot be used on level 2")
-		}
-	case levelByProductWarehouse:
-		if productWarehouseID == 0 {
-			return errors.New("--product-warehouse-id is required on level 3")
-		}
-		if productName != "" {
-			return errors.New("--product-name cannot be used on level 3")
-		}
-	default:
-		return fmt.Errorf("unsupported --level=%d (allowed: 1, 2, 3)", level)
-	}
-
-	return nil
-}
-
-func loadReflowRows(
-	ctx context.Context,
-	db *gorm.DB,
-	level int,
-	productName string,
-	productWarehouseID uint,
-) ([]reflowRow, error) {
-	allocSub := db.WithContext(ctx).
-		Table("stock_allocations sa").
-		Select(`
-			sa.stockable_id,
-			COALESCE(SUM(sa.qty), 0) AS used_qty
-		`).
-		Where("sa.stockable_type = ?", fifo.StockableKeyPurchaseItems.String()).
-		Where("sa.status = ?", entity.StockAllocationStatusActive).
-		Where("sa.deleted_at IS NULL").
-		Group("sa.stockable_id")
-
-	calcSub := db.WithContext(ctx).
-		Table("purchase_items pi").
-		Select(`
-			pi.product_warehouse_id,
-			COALESCE(SUM(pi.total_qty), 0) AS sum_total_qty,
-			COALESCE(SUM(COALESCE(alloc.used_qty, 0)), 0) AS sum_allocated_qty,
-			COALESCE(SUM(COALESCE(pi.total_qty, 0) - COALESCE(alloc.used_qty, 0)), 0) AS computed_qty
-		`).
-		Joins("LEFT JOIN (?) alloc ON alloc.stockable_id = pi.id", allocSub).
-		Where("pi.product_warehouse_id IS NOT NULL").
-		Group("pi.product_warehouse_id")
-
-	query := db.WithContext(ctx).
-		Table("product_warehouses pw").
-		Select(`
-			pw.id AS product_warehouse_id,
-			pw.product_id AS product_id,
-			p.name AS product_name,
-			COALESCE(pw.qty, 0) AS current_qty,
-			calc.sum_total_qty,
-			calc.sum_allocated_qty,
-			calc.computed_qty
-		`).
-		Joins("JOIN products p ON p.id = pw.product_id").
-		Joins("JOIN (?) calc ON calc.product_warehouse_id = pw.id", calcSub).
-		Order("pw.id ASC")
-
-	switch level {
-	case levelByProductName:
-		query = query.Where("LOWER(p.name) = LOWER(?)", productName)
-	case levelByProductWarehouse:
-		query = query.Where("pw.id = ?", productWarehouseID)
-	}
-
-	rows := make([]reflowRow, 0)
-	if err := query.Scan(&rows).Error; err != nil {
-		return nil, err
-	}
-
-	return rows, nil
-}
-
-func modeLabel(apply bool) string {
-	if apply {
-		return "APPLY"
-	}
-	return "DRY-RUN"
-}
-
-func levelLabel(level int) string {
-	switch level {
-	case levelAll:
-		return "all product_warehouse from purchase_items"
-	case levelByProductName:
-		return "specific product name"
-	case levelByProductWarehouse:
-		return "specific product_warehouse_id"
-	default:
-		return "unknown"
-	}
-}
-
-func nearlyEqual(a, b float64) bool {
-	return math.Abs(a-b) <= qtyEpsilon
-}

cmd/run-sql-file/main.go

@@ -1,75 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"strings"
-
-	"gitlab.com/mbugroup/lti-api.git/internal/config"
-	"gitlab.com/mbugroup/lti-api.git/internal/database"
-	"gorm.io/gorm"
-)
-
-type options struct {
-	FilePath string
-	Apply    bool
-}
-
-func main() {
-	var opts options
-	flag.StringVar(&opts.FilePath, "file", "", "Path to .sql file (required)")
-	flag.BoolVar(&opts.Apply, "apply", false, "Apply SQL to database. If false, run as dry-run")
-	flag.Parse()
-
-	opts.FilePath = strings.TrimSpace(opts.FilePath)
-	if opts.FilePath == "" {
-		log.Fatal("--file is required")
-	}
-
-	sqlContent, err := readSQLFile(opts.FilePath)
-	if err != nil {
-		log.Fatalf("failed reading sql file: %v", err)
-	}
-
-	mode := "dry-run"
-	if opts.Apply {
-		mode = "apply"
-	}
-	fmt.Printf("Mode: %s\n", mode)
-	fmt.Printf("File: %s\n", opts.FilePath)
-	fmt.Printf("SQL bytes: %d\n", len(sqlContent))
-
-	if !opts.Apply {
-		fmt.Println("Dry-run only. Add --apply to execute the SQL file.")
-		return
-	}
-
-	db := database.Connect(config.DBHost, config.DBName)
-	if err := executeSQL(db, sqlContent); err != nil {
-		log.Fatalf("failed executing sql file: %v", err)
-	}
-
-	fmt.Println("DONE: SQL executed successfully")
-}
-
-func readSQLFile(path string) (string, error) {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return "", err
-	}
-
-	sql := strings.TrimSpace(strings.TrimPrefix(string(raw), "\ufeff"))
-	if sql == "" {
-		return "", fmt.Errorf("sql file is empty")
-	}
-
-	return sql, nil
-}
-
-func executeSQL(db *gorm.DB, sql string) error {
-	return db.Transaction(func(tx *gorm.DB) error {
-		return tx.Exec(sql).Error
-	})
-}

cmd/validate-chickin-trace/main.go

@@ -1,122 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"log"
-	"math"
-	"os"
-
-	"gitlab.com/mbugroup/lti-api.git/internal/config"
-	"gitlab.com/mbugroup/lti-api.git/internal/database"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
-	"gorm.io/gorm"
-)
-
-type mismatchRow struct {
-	ChickinID           uint    `gorm:"column:chickin_id"`
-	ProjectFlockKandang uint    `gorm:"column:project_flock_kandang_id"`
-	ProductWarehouseID  uint    `gorm:"column:product_warehouse_id"`
-	UsageQty            float64 `gorm:"column:usage_qty"`
-	TraceQty            float64 `gorm:"column:trace_qty"`
-}
-
-func main() {
-	var projectFlockKandangID uint
-	flag.UintVar(&projectFlockKandangID, "project-flock-kandang-id", 0, "Optional project flock kandang scope")
-	flag.Parse()
-
-	ctx := context.Background()
-	db := database.Connect(config.DBHost, config.DBName)
-
-	rows, err := loadTraceMismatches(ctx, db, projectFlockKandangID)
-	if err != nil {
-		log.Fatalf("failed to load trace mismatches: %v", err)
-	}
-
-	activeConsumeRows, err := countActiveConsumeProjectChickin(ctx, db, projectFlockKandangID)
-	if err != nil {
-		log.Fatalf("failed to count active consume rows: %v", err)
-	}
-
-	fmt.Printf("Scope project_flock_kandang_id=%d\n", projectFlockKandangID)
-	fmt.Printf("Mismatched chickin trace rows: %d\n", len(rows))
-	fmt.Printf("Active PROJECT_CHICKIN consume rows: %d\n", activeConsumeRows)
-
-	if len(rows) > 0 {
-		for _, row := range rows {
-			fmt.Printf(
-				"MISMATCH chickin_id=%d pfk=%d pw=%d usage=%.3f trace=%.3f diff=%.3f\n",
-				row.ChickinID,
-				row.ProjectFlockKandang,
-				row.ProductWarehouseID,
-				row.UsageQty,
-				row.TraceQty,
-				row.TraceQty-row.UsageQty,
-			)
-		}
-	}
-
-	if len(rows) > 0 || activeConsumeRows > 0 {
-		os.Exit(1)
-	}
-}
-
-func loadTraceMismatches(ctx context.Context, db *gorm.DB, projectFlockKandangID uint) ([]mismatchRow, error) {
-	query := db.WithContext(ctx).
-		Table("project_chickins pc").
-		Select(`
-			pc.id AS chickin_id,
-			pc.project_flock_kandang_id,
-			pc.product_warehouse_id,
-			COALESCE(pc.usage_qty, 0) AS usage_qty,
-			COALESCE(SUM(sa.qty), 0) AS trace_qty
-		`).
-		Joins(`
-			LEFT JOIN stock_allocations sa
-				ON sa.usable_type = ?
-				AND sa.usable_id = pc.id
-				AND sa.status = 'ACTIVE'
-				AND sa.allocation_purpose = 'TRACE_CHICKIN'
-		`, fifo.UsableKeyProjectChickin.String()).
-		Where("pc.deleted_at IS NULL").
-		Where("COALESCE(pc.usage_qty,0) > 0").
-		Group("pc.id, pc.project_flock_kandang_id, pc.product_warehouse_id, pc.usage_qty")
-
-	if projectFlockKandangID > 0 {
-		query = query.Where("pc.project_flock_kandang_id = ?", projectFlockKandangID)
-	}
-
-	rows := make([]mismatchRow, 0)
-	if err := query.Scan(&rows).Error; err != nil {
-		return nil, err
-	}
-
-	out := make([]mismatchRow, 0, len(rows))
-	for _, row := range rows {
-		if math.Abs(row.TraceQty-row.UsageQty) > 1e-3 {
-			out = append(out, row)
-		}
-	}
-	return out, nil
-}
-
-func countActiveConsumeProjectChickin(ctx context.Context, db *gorm.DB, projectFlockKandangID uint) (int64, error) {
-	q := db.WithContext(ctx).
-		Table("stock_allocations sa").
-		Joins("JOIN project_chickins pc ON pc.id = sa.usable_id").
-		Where("sa.usable_type = ?", fifo.UsableKeyProjectChickin.String()).
-		Where("sa.status = 'ACTIVE'").
-		Where("sa.allocation_purpose = 'CONSUME'")
-
-	if projectFlockKandangID > 0 {
-		q = q.Where("pc.project_flock_kandang_id = ?", projectFlockKandangID)
-	}
-
-	var count int64
-	if err := q.Count(&count).Error; err != nil {
-		return 0, err
-	}
-	return count, nil
-}

docs/farm_depreciation_manual_inputs_import.md

@@ -1,76 +0,0 @@
-# Farm Depreciation Manual Inputs Import
-
-Command ini dipakai untuk bulk import data ke tabel `farm_depreciation_manual_inputs` dari file Excel (`.xlsx`).
-
-## Command
-
-```bash
-go run ./cmd/import-farm-depreciation-manual-inputs --file <path.xlsx> [--sheet <name>] [--apply]
-```
-
-## Flags
-
-- `--file` (required): path file `.xlsx`.
-- `--sheet` (optional): nama sheet. Jika tidak diisi, command pakai sheet pertama.
-- `--apply` (optional): default `false` (dry-run). Jika `true`, command menulis ke database.
-
-## Mode
-
-- Dry-run (default):
-  - parsing dan validasi semua baris.
-  - validasi `project_flock_id` terhadap farm aktif kategori `LAYING`.
-  - menampilkan `PLAN` + daftar error.
-  - tidak menulis data.
-
-- Apply (`--apply`):
-  - semua validasi tetap dijalankan dulu.
-  - jika ada 1 error, proses dihentikan.
-  - jika valid, upsert dijalankan dalam 1 transaksi (fail-fast).
-  - setelah upsert, snapshot di `farm_depreciation_snapshots` dihapus mulai `cutover_date` untuk `project_flock_id` terkait.
-
-## Format Excel
-
-Template tersedia di:
-
-- `docs/templates/farm_depreciation_manual_inputs.xlsx`
-
-Header wajib ada di baris 1 (case-insensitive, trim-spaces):
-
-- `project_flock_id` (required, integer > 0)
-- `total_cost` (required, numeric >= 0)
-- `cutover_date` (required, format `YYYY-MM-DD`)
-- `note` (optional, max 1000 karakter)
-
-Catatan:
-
-- Dalam 1 file tidak boleh ada duplikat `project_flock_id`.
-- `project_flock_id` harus mengarah ke `project_flocks` yang `deleted_at IS NULL` dan `category = LAYING`.
-
-## Contoh
-
-Dry-run:
-
-```bash
-env DB_HOST=127.0.0.1 DB_PORT=5432 DB_NAME=lti DB_USER=postgres DB_PASSWORD=postgres \
-go run ./cmd/import-farm-depreciation-manual-inputs \
-  --file docs/templates/farm_depreciation_manual_inputs.xlsx
-```
-
-Apply:
-
-```bash
-env DB_HOST=127.0.0.1 DB_PORT=5432 DB_NAME=lti DB_USER=postgres DB_PASSWORD=postgres \
-go run ./cmd/import-farm-depreciation-manual-inputs \
-  --file /path/to/farm_depreciation_manual_inputs.xlsx \
-  --sheet manual_inputs \
-  --apply
-```
-
-## Error Umum
-
-- `required header is missing`: header wajib tidak ditemukan.
-- `must be a positive integer`: `project_flock_id` bukan integer valid.
-- `must be greater than or equal to 0`: `total_cost` negatif.
-- `must follow format YYYY-MM-DD`: `cutover_date` tidak sesuai format.
-- `duplicate value ...`: `project_flock_id` duplikat dalam file yang sama.
-- `must reference an active LAYING project_flock`: farm tidak valid untuk import ini.

docs/farm_stock_attribution_design.md

@@ -1,31 +0,0 @@
-# Farm Stock Attribution Design Note
-
-## Goal
-
-Allow farm-level physical stock to be used directly by kandang-level operations without forcing transfers, while keeping kandang attribution, FIFO-v2 compatibility, traceability, and HPP/COGS intact.
-
-## Core Model
-
-- Physical stock stays on the real `product_warehouse_id` that was consumed or received.
-- Kandang attribution comes from the transaction or allocation path, not from `product_warehouses.project_flock_kandang_id`.
-- Existing kandang-bound warehouses remain valid for historical and current kandang-only flows.
-- Shared farm warehouses must stay shareable; application code must stop silently converting them into kandang-owned warehouses.
-
-## Attribution Rules
-
-- `recording_stocks`: consumer kandang is the parent `recordings.project_flock_kandangs_id`; physical stock source remains `recording_stocks.product_warehouse_id`.
-- `recording_depletions`: source kandang is the recording kandang and is stored explicitly for compatibility; physical source remains `source_product_warehouse_id`, destination stock remains `product_warehouse_id`.
-- `recording_eggs`: producer kandang is the recording kandang and is stored explicitly for compatibility; physical stock remains `product_warehouse_id`, which may be a farm warehouse.
-- `marketing_delivery_products`: outbound kandang attribution comes from active `stock_allocations` to `PROJECT_FLOCK_POPULATION`, `RECORDING_DEPLETION`, or `RECORDING_EGG`, with product-warehouse kandang ownership only as a fallback for historical/non-FIFO rows.
-
-## Reporting and HPP
-
-- Feed and OVK cost attribution should continue to follow recording-level consumption plus FIFO allocations to incoming stock.
-- Egg and live-bird sales attribution should be derived from `stock_allocations` back to the originating kandang transactions or populations.
-- Queries that filter or group by kandang must use explicit transaction attribution or FIFO allocation provenance, not warehouse ownership, when pooled farm stock is involved.
-
-## Live-Data Safety
-
-- Schema changes are additive and nullable.
-- Historical rows are backfilled only when attribution is deterministic from existing rows.
-- No FIFO-v2 route-rule behavior is changed unless the current code is only resyncing or constraining allocation metadata around already-created FIFO allocations.

docs/legacy_egg_farm_cutover_runbook.md

@@ -1,286 +0,0 @@
-# Runbook Cutover Stok Telur Historis Kandang ke Gudang Farm
-
-## Tujuan
-
-Runbook ini dipakai untuk memindahkan **stok telur historis yang masih on-hand di gudang kandang** ke **gudang farm** secara aman, audit-able, dan reversible.
-
-Cutover dilakukan dengan **transfer stok eksplisit**, bukan dengan mengubah `recording_eggs.product_warehouse_id` historis.
-
-## Scope
-
-Runbook ini hanya untuk:
-- stok telur historis kandang-level yang masih punya saldo on-hand
-- lokasi yang masuk kategori **clean cutover**
-- lokasi yang sudah punya gudang farm
-
-Runbook ini **tidak** dipakai untuk:
-- lokasi overlap seperti `Cijangkar`
-- koreksi histori `recording_eggs`
-- migrasi stok non-telur
-
-## Kebijakan yang Dikunci
-
-- Sumber qty yang dipindah adalah **`product_warehouses.qty` saat cutover**
-- Perintah dijalankan **per lokasi**
-- Wajib mulai dari `dry-run`
-- `--apply` hanya boleh dijalankan setelah review dry-run dan SQL checklist
-- Lokasi overlap tidak ikut otomatis kecuali ada approval khusus dan `--include-overlap`
-- Rollback hanya boleh dilakukan jika transfer hasil cutover belum dipakai transaksi turunan
-
-## Lokasi Fase 1
-
-Lokasi yang boleh dieksekusi pada fase pertama:
-- `Jamali`
-- `Cantilan`
-- `Darawati`
-- `Tamansari`
-
-Lokasi yang harus ditahan:
-- `Cijangkar`
-
-## Prasyarat
-
-Sebelum eksekusi, pastikan:
-- backend sudah ter-deploy dengan command [main.go](/Users/macbookair/Documents/coding/projects/LTI-ERP/lti-api/cmd/migrate-legacy-egg-stock-to-farm/main.go)
-- reusable transfer core sudah ikut ter-deploy:
-  - [transfer.service.go](/Users/macbookair/Documents/coding/projects/LTI-ERP/lti-api/internal/modules/inventory/transfers/services/transfer.service.go)
-  - [system_transfer.go](/Users/macbookair/Documents/coding/projects/LTI-ERP/lti-api/internal/modules/inventory/transfers/services/system_transfer.go)
-- migrasi farm stock attribution sebelumnya sudah terpasang
-- akses database target sudah tersedia
-- environment target memakai SSL bila RDS mewajibkan, contoh:
-  - `DB_SSLMODE=require`
-
-## Catatan Output Command
-
-Mode `--output table` adalah mode operasional yang direkomendasikan.
-
-Mode `--output json` bisa dipakai, tetapi pada environment saat ini output JSON masih dapat didahului log bootstrap aplikasi atau SQL logger. Untuk review manual gunakan `table`. Untuk parsing otomatis, filter payload mulai dari `{`.
-
-## Format Command
-
-### Dry-run
-
-```bash
-DB_SSLMODE=require go run ./cmd/migrate-legacy-egg-stock-to-farm \
-  --location-name Jamali \
-  --output table
-```
-
-### Apply
-
-```bash
-DB_SSLMODE=require go run ./cmd/migrate-legacy-egg-stock-to-farm \
-  --location-name Jamali \
-  --cutover-date 2026-04-07 \
-  --apply \
-  --output table
-```
-
-### Rollback Preview
-
-```bash
-DB_SSLMODE=require go run ./cmd/migrate-legacy-egg-stock-to-farm \
-  --rollback-run-id <run_id> \
-  --output table
-```
-
-### Rollback Apply
-
-```bash
-DB_SSLMODE=require go run ./cmd/migrate-legacy-egg-stock-to-farm \
-  --rollback-run-id <run_id> \
-  --apply \
-  --output table
-```
-
-## Arti `run_id`
-
-Setiap dry-run/apply menghasilkan `run_id`, misalnya:
-
-```text
-egg-cutover-20260407T130344.220407000Z
-```
-
-`run_id` ini wajib disimpan karena dipakai untuk:
-- audit hasil cutover
-- query verifikasi
-- rollback
-
-## Prosedur Eksekusi Per Lokasi
-
-### 1. Persiapan
-
-Tentukan:
-- `location_name`
-- `cutover_date`
-- operator yang bertanggung jawab
-
-Contoh:
-- lokasi: `Jamali`
-- cutover date: `2026-04-07`
-
-### 2. Jalankan Dry-run
-
-```bash
-DB_SSLMODE=require go run ./cmd/migrate-legacy-egg-stock-to-farm \
-  --location-name Jamali \
-  --output table
-```
-
-Yang harus dicek pada hasil dry-run:
-- status lokasi `CLEAN_CUTOVER`
-- semua baris yang akan dipindah punya `status=eligible`
-- gudang tujuan adalah gudang farm lokasi tersebut
-- qty yang dipindah masuk akal dan sesuai saldo on-hand aktual
-- tidak ada `missing_farm_warehouse`
-- tidak ada `overlap_location`
-
-### 3. Jalankan Checklist SQL Before
-
-Gunakan file:
-- [legacy_egg_cutover_verification_checklist.sql](/Users/macbookair/Documents/coding/projects/LTI-ERP/lti-api/docs/sql/legacy_egg_cutover_verification_checklist.sql)
-
-Minimal pastikan:
-- lokasi memang clean cutover
-- stok telur kandang positif masih ada
-- gudang farm ada
-- belum ada transfer `EGG_FARM_CUTOVER` aktif untuk lokasi yang sama pada run yang akan dipakai
-
-### 4. Simpan Evidence Sebelum Apply
-
-Simpan:
-- output dry-run
-- hasil query before
-- nama operator
-- waktu eksekusi
-
-Disarankan simpan dalam ticket / change record.
-
-### 5. Jalankan Apply
-
-```bash
-DB_SSLMODE=require go run ./cmd/migrate-legacy-egg-stock-to-farm \
-  --location-name Jamali \
-  --cutover-date 2026-04-07 \
-  --apply \
-  --output table
-```
-
-Setelah apply, simpan:
-- `run_id`
-- seluruh row dengan `transfer_id`
-- movement number yang terbentuk
-
-### 6. Jalankan Checklist SQL After
-
-Masih menggunakan file:
-- [legacy_egg_cutover_verification_checklist.sql](/Users/macbookair/Documents/coding/projects/LTI-ERP/lti-api/docs/sql/legacy_egg_cutover_verification_checklist.sql)
-
-Minimal pastikan:
-- transfer header/detail tercatat untuk `run_id`
-- qty source berkurang sesuai transfer
-- qty farm bertambah sesuai transfer
-- total gabungan source+dest per produk per lokasi tetap sama
-- stok eligible tidak lagi tersedia di gudang kandang
-- stok telur sekarang tersedia di gudang farm
-
-### 7. Smoke Test UI
-
-Lakukan minimal:
-- buka product stock farm untuk lokasi tersebut
-- pastikan produk telur hasil migrasi muncul
-- buat SO farm-level dan pastikan opsi produk telur tersedia
-- pastikan recording telur baru setelah cutover tetap langsung masuk ke gudang farm
-
-### 8. Tutup Eksekusi
-
-Catat hasil akhir:
-- sukses/gagal
-- `run_id`
-- lokasi
-- tanggal cutover
-- operator
-- link ke evidence SQL/UI
-
-## Kriteria Go / No-Go
-
-### Boleh lanjut apply bila:
-
-- dry-run menunjukkan hanya row yang memang expected
-- lokasi `CLEAN_CUTOVER`
-- gudang farm valid
-- query before menunjukkan tidak ada anomaly blocking
-
-### Wajib stop bila:
-
-- lokasi terdeteksi `OVERLAP`
-- ada qty aneh atau tidak sesuai data lapangan
-- gudang farm tidak ada
-- ada transfer lama serupa yang belum direkonsiliasi
-- setelah apply terjadi selisih total source+dest
-
-## Rollback Runbook
-
-### Kapan rollback boleh dilakukan
-
-Rollback boleh jika:
-- transfer hasil cutover belum dipakai transaksi turunan
-- verifikasi after menunjukkan issue yang membuat hasil cutover tidak dapat diterima
-
-### Langkah rollback
-
-1. Preview rollback:
-
-```bash
-DB_SSLMODE=require go run ./cmd/migrate-legacy-egg-stock-to-farm \
-  --rollback-run-id <run_id> \
-  --output table
-```
-
-2. Jalankan query rollback readiness pada file audit/helper SQL.
-3. Jika aman, apply rollback:
-
-```bash
-DB_SSLMODE=require go run ./cmd/migrate-legacy-egg-stock-to-farm \
-  --rollback-run-id <run_id> \
-  --apply \
-  --output table
-```
-
-4. Jalankan ulang query verifikasi after rollback.
-
-### Kapan rollback akan gagal by design
-
-Rollback memang harus gagal jika:
-- transfer hasil cutover sudah dipakai sales/recording/transaksi turunan
-- sudah ada `stock_allocations` consume aktif terhadap `STOCK_TRANSFER_IN`
-
-## Urutan Rollout yang Direkomendasikan
-
-### Dev
-
-1. Dry-run per lokasi
-2. Review SQL before
-3. Apply per lokasi
-4. SQL after
-5. Smoke UI
-6. Simpan `run_id`
-
-### Production
-
-1. Freeze operasional lokasi target bila perlu
-2. Dry-run
-3. Review by dev + ops + finance/stock owner
-4. Apply
-5. SQL after
-6. Smoke UI
-7. Release lokasi berikutnya
-
-## Referensi
-
-- Command cutover: [main.go](/Users/macbookair/Documents/coding/projects/LTI-ERP/lti-api/cmd/migrate-legacy-egg-stock-to-farm/main.go)
-- Test command: [main_test.go](/Users/macbookair/Documents/coding/projects/LTI-ERP/lti-api/cmd/migrate-legacy-egg-stock-to-farm/main_test.go)
-- Core reusable transfer: [system_transfer.go](/Users/macbookair/Documents/coding/projects/LTI-ERP/lti-api/internal/modules/inventory/transfers/services/system_transfer.go)
-- Transfer service refactor: [transfer.service.go](/Users/macbookair/Documents/coding/projects/LTI-ERP/lti-api/internal/modules/inventory/transfers/services/transfer.service.go)
-- Checklist SQL: [legacy_egg_cutover_verification_checklist.sql](/Users/macbookair/Documents/coding/projects/LTI-ERP/lti-api/docs/sql/legacy_egg_cutover_verification_checklist.sql)
-- Helper query audit: [legacy_egg_cutover_audit_queries.sql](/Users/macbookair/Documents/coding/projects/LTI-ERP/lti-api/docs/sql/legacy_egg_cutover_audit_queries.sql)

docs/postman/read-api.environment.json

@@ -1,174 +0,0 @@
-{
-  "_postman_exported_at": "2026-04-14T00:00:00Z",
-  "_postman_exported_using": "Codex",
-  "_postman_variable_scope": "environment",
-  "id": "lti-read-api-local",
-  "name": "LTI ERP Read API.local",
-  "values": [
-    {
-      "enabled": true,
-      "key": "adjustment_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "api_key",
-      "value": ""
-    },
-    {
-      "enabled": true,
-      "key": "area_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "bank_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "base_url",
-      "value": "http://localhost:8081"
-    },
-    {
-      "enabled": true,
-      "key": "bearer_token",
-      "value": ""
-    },
-    {
-      "enabled": true,
-      "key": "chickin_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "customer_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "employee_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "expense_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "flock_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "idDailyChecklist",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "idProjectFlockKandang",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "initial_balance_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "injection_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "location_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "nonstock_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "payment_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "product_category_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "product_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "projectFlockId",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "project_flock_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "project_flock_kandang_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "purchase_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "recording_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "supplier_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "transaction_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "transfer_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "uniformity_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "uom_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "user_id",
-      "value": "1"
-    },
-    {
-      "enabled": true,
-      "key": "warehouse_id",
-      "value": "1"
-    }
-  ]
-}

docs/qa_farm_stock_test_cases.csv

@@ -1,45 +0,0 @@
-ID;Kategori;Area;Judul;Tipe;Prioritas;Setup/Precondition;Langkah Uji;Hasil yang Diharapkan
-TC-A01;Migrasi dan Keamanan Data;Database;Migrasi aman pada DB tidak kosong;Integration;High;Gunakan snapshot DB staging yang sudah berisi recording, depletion, telur, penjualan, dan closing.;1. Jalankan migrasi 20260330110000_add_recording_attribution_fields_for_farm_stock.up.sql. 2. Inspect schema hasil migrasi.;Kolom recording_depletions.source_project_flock_kandang_id dan recording_eggs.project_flock_kandang_id tersedia dan nullable, index dan FK tersedia, tidak ada data historis yang terhapus atau berubah destruktif.
-TC-A02;Migrasi dan Keamanan Data;Database;Backfill deterministik berjalan;Integration;High;Ada data historis recording dengan recordings.project_flock_kandangs_id yang valid.;1. Query recording_depletions dan recording_eggs yang lama. 2. Bandingkan dengan kandang pada parent recording.;source_project_flock_kandang_id dan project_flock_kandang_id terisi sama dengan kandang parent recording untuk row yang sebelumnya null.
-TC-A03;Migrasi dan Keamanan Data;Reporting;Report historis kandang-only tidak berubah;Regression;High;Gunakan snapshot yang hanya memiliki data stok historis milik kandang, tanpa pooled stock farm-level.;1. Jalankan closing/report/HPP sebelum deploy. 2. Jalankan lagi sesudah deploy pada snapshot yang sama. 3. Bandingkan hasil.;Total dan hasil report tetap sama untuk skenario historis kandang-only.
-TC-B01;Purchase dan Warehouse;Purchase;Purchase pakan langsung ke gudang farm;UAT;High;Tersedia PO atau purchase request untuk produk Pakan Starter.;1. Buat purchase ke Gudang Farm A. 2. Approve dan receive purchase.;Stok masuk ke product_warehouse level farm, tidak perlu transfer paksa ke kandang, FIFO/HPP purchase tetap benar.
-TC-B02;Purchase dan Warehouse;Purchase;Purchase pakan langsung ke gudang kandang;Regression;High;Tersedia PO atau purchase request untuk produk Pakan Starter.;1. Buat purchase ke Gudang Kandang A1. 2. Approve dan receive purchase.;Stok masuk ke gudang kandang dan perilaku tetap sama seperti flow lama.
-TC-B03;Purchase dan Warehouse;Purchase;Purchase OVK langsung ke gudang farm;UAT;High;Tersedia PO atau purchase request untuk produk OVK A.;1. Buat purchase ke Gudang Farm A. 2. Approve dan receive purchase.;Stok OVK masuk ke gudang farm dan bisa dipakai kemudian pada recording.
-TC-B04;Purchase dan Warehouse;Product Warehouse;Gudang farm shared tidak diubah diam-diam menjadi milik kandang;Regression;High;Sudah ada row product_warehouse level farm untuk Pakan Starter di Gudang Farm A.;1. Trigger flow yang memanggil ensure/find product warehouse untuk produk yang sama. 2. Inspect row existing.;Row farm-level tetap farm-level, project_flock_kandang_id tidak dibackfill diam-diam, row khusus kandang dibuat terpisah bila memang diperlukan.
-TC-C01;Recording Stock Consumption;Recording;Recording kandang memakai pakan dari gudang kandang;Regression;High;Stok pakan tersedia di Gudang Kandang A1.;1. Buka recording untuk Kandang A1. 2. Pilih pakan dari gudang kandang. 3. Submit dan approve.;Recording berhasil, stok keluar dari product_warehouse kandang, atribusi kandang tetap A1, HPP pemakaian muncul di closing/HPP A1.
-TC-C02;Recording Stock Consumption;Recording;Recording kandang memakai pakan dari gudang farm;UAT;High;Stok pakan hanya tersedia di Gudang Farm A.;1. Buka recording untuk Kandang A1. 2. Pilih stok pakan farm-level. 3. Submit dan approve.;Recording berhasil tanpa transfer ke kandang, stok fisik berkurang dari gudang farm, usage/HPP tetap teratribusi ke Kandang A1, closing farm dan kandang tetap bisa dihitung.
-TC-C03;Recording Stock Consumption;Recording;Recording kandang memakai OVK dari gudang farm;UAT;High;Stok OVK hanya tersedia di Gudang Farm A.;1. Buka recording untuk Kandang A1. 2. Pilih stok OVK farm-level. 3. Submit dan approve.;Stok OVK keluar dari gudang farm dan biaya pemakaian teratribusi ke kandang yang dipilih.
-TC-C04;Recording Stock Consumption;Frontend Recording;Selector recording menampilkan opsi stok farm dan kandang dengan jelas;UI Regression;Medium;Produk yang sama tersedia di Gudang Farm A dan Gudang Kandang A1.;1. Buka form recording untuk A1. 2. Buka selector pakan.;Kedua opsi terlihat, label membedakan gudang atau scope dengan jelas, farm stock tidak tersembunyi secara salah.
-TC-C05;Recording Stock Consumption;Recording;Recording A1 tidak boleh memakai stok kandang A2;Negative;High;Pakan Starter tersedia di Gudang Kandang A2.;1. Buka recording untuk A1. 2. Periksa opsi stok yang bisa dipilih.;Opsi Gudang Kandang A2 tidak bisa dipilih, stok farm tetap bisa dipilih.
-TC-C06;Recording Stock Consumption;Recording;Perilaku pending stock dan usage lama tetap berjalan;Regression;Medium;Tidak ada setup khusus selain data recording yang valid.;1. Buat usage stock. 2. Buka kembali halaman edit dan detail.;Tampilan dan perhitungan pending atau usage tetap benar, tidak ada regresi pada route FIFO-v2.
-TC-D01;Recording Telur dan Atribusi;Recording;Recording telur ke gudang kandang tetap berjalan;Regression;High;Kandang A1 aktif dan gudang telur kandang tersedia.;1. Record telur untuk A1 ke Gudang Kandang A1. 2. Approve.;Stok telur di gudang kandang bertambah dan asal kandang tetap A1.
-TC-D02;Recording Telur dan Atribusi;Recording;Recording telur di kandang menyimpan stok ke gudang farm;UAT;High;Egg product warehouse tersedia di Gudang Farm A.;1. Record telur untuk A1. 2. Pilih Gudang Farm A sebagai gudang telur. 3. Submit dan approve.;Stok telur fisik masuk ke gudang farm, recording_eggs.project_flock_kandang_id bernilai A1, tidak ada transfer paksa ke kandang.
-TC-D03;Recording Telur dan Atribusi;Reporting;Stok telur pooled di farm tetap punya jejak asal kandang;Integration;High;A1 record 100 telur ke gudang farm dan A2 record 150 telur ke gudang farm yang sama.;1. Inspect row telur yang tersimpan. 2. Inspect hasil costing atau report setelahnya.;Stok fisik pooled di gudang farm, tetapi asal kandang tetap bisa dibedakan per row atau allocation, HPP per kandang tetap dapat dihitung.
-TC-D04;Recording Telur dan Atribusi;Recording Detail;Known gap pada detail recording dipahami;Known Limitation;Low;Sudah menjalankan TC-D02.;1. Buka detail recording setelah transaksi telur ke gudang farm.;Logika bisnis tetap berjalan, tetapi detail API atau UI mungkin belum menampilkan egg-origin secara eksplisit karena detail DTO belum diperluas.
-TC-E01;Depletion dan Atribusi Populasi;Recording;Depletion dari gudang ayam milik kandang normal;Regression;High;A1 memiliki populasi ayam di gudang kandang.;1. Buat depletion. 2. Approve.;Depletion berhasil, alokasi populasi ter-resolve ke A1, HPP atau usage tetap benar.
-TC-E02;Depletion dan Atribusi Populasi;Recording;Depletion dari sumber ayam fisik farm-level dengan source kandang A1;UAT;High;Stok ayam secara fisik ada di gudang farm dan punya jejak sumber ke A1.;1. Buat depletion untuk A1. 2. Gunakan path source atau farm-level yang didukung backend. 3. Approve.;source_product_warehouse_id menunjuk ke sumber fisik yang benar, source_project_flock_kandang_id bernilai A1, alokasi populasi berhasil tanpa mengasumsikan gudang fisik milik A1.
-TC-E03;Depletion dan Atribusi Populasi;Recording;Depletion gagal bila sumber populasi tidak dapat diatribusikan;Negative;High;Buat kasus stok ayam farm-level tanpa source kandang yang valid.;1. Coba approve depletion.;Backend menolak dengan error yang jelas dan tidak ada silent misattribution.
-TC-F01;Marketing dan Penjualan;Sales Order;Sales order dari gudang kandang tetap berjalan;Regression;High;Stok produk tersedia di Gudang Kandang A1.;1. Buat SO dari Gudang Kandang A1. 2. Lakukan delivery.;Perilaku lama tetap berjalan normal.
-TC-F02;Marketing dan Penjualan;Sales Order;Sales order dari gudang farm untuk telur;UAT;High;Stok telur farm-level tersedia dan berasal dari A1.;1. Buat SO menggunakan Gudang Farm A. 2. Lakukan delivery.;SO dan DO berhasil, stok fisik berkurang dari gudang farm, HPP dan COGS telur tetap teratribusi ke kandang penghasil melalui allocation.
-TC-F03;Marketing dan Penjualan;Sales Order;Sales order dari gudang farm untuk telur pooled A1 dan A2;Integration;High;Stok telur pooled tersedia di gudang farm dari A1 dan A2.;1. Buat penjualan. 2. Lakukan delivery. 3. Inspect closing atau report.;Stok fisik berkurang sekali dari gudang farm, revenue dan HPP terbagi benar ke A1 dan A2, tidak bergantung pada pw.project_flock_kandang_id.
-TC-F04;Marketing dan Penjualan;Sales Order;Sales order dari gudang farm untuk ayam atau culling;UAT;High;Stok ayam atau culling farm-level tersedia dengan jejak sumber dari A1 dan A2.;1. Buat SO dari gudang farm. 2. Buat DO dan approve.;allocatePopulationForMarketingDelivery menurunkan atribusi kandang dari source groups atau allocation, tidak gagal karena gudang jual tidak punya project_flock_kandang_id, HPP dan COGS teratribusi ke kandang sumber.
-TC-F05;Marketing dan Penjualan;Frontend Marketing;UI sales menampilkan semantik Gudang Fisik;UI Regression;Medium;Tidak ada setup khusus selain akses ke form SO.;1. Buka form SO. 2. Periksa label selector gudang dan label tabel produk.;UI menggunakan label Gudang Fisik, bukan Kandang yang menyesatkan, dan label produk memuat detail produk serta gudang atau scope.
-TC-F06;Marketing dan Penjualan;Delivery Order;Layar delivery order tetap kompatibel;Regression;Medium;Sudah ada SO dari gudang farm.;1. Lakukan delivery untuk SO farm-level. 2. Periksa tabel dan detail DO.;Tidak ada masalah payload, gudang fisik tampil dengan benar, dan tidak ada kebingungan akibat wording lama berbasis kandang.
-TC-G01;Report, Closing, dan HPP;Daily Marketing Report;Daily marketing report untuk penjualan telur farm-level;UAT;Medium;Sudah menjalankan TC-F02.;1. Jalankan daily marketing report. 2. Uji export.;Row muncul pada gudang fisik yang benar, report tidak menyiratkan gudang sama dengan kandang, export berjalan.
-TC-G02;Report, Closing, dan HPP;Closing Sales;Closing sales untuk penjualan pooled farm-level;UAT;High;Ada penjualan pooled telur atau ayam dari gudang farm.;1. Buka closing sales.;Penjualan bisa tampil teratribusi per kandang, label menunjukkan Kandang Atribusi, HPP dan revenue tetap benar secara matematis.
-TC-G03;Report, Closing, dan HPP;HPP per Kandang;HPP per kandang mencakup konsumsi pakan atau OVK dari gudang farm;UAT;High;A1 sudah memakai pakan atau OVK dari gudang farm.;1. Jalankan report HPP per kandang.;Biaya usage muncul di A1 dan tidak hilang walaupun gudang fisiknya level farm.
-TC-G04;Report, Closing, dan HPP;Closing Sapronak;Outgoing sapronak menampilkan gudang fisik dengan benar;UI Regression;Medium;Ada data outgoing sapronak yang valid.;1. Buka tabel closing outgoing sapronak.;Header jelas menunjukkan Gudang Asal (Fisik) dan Gudang Tujuan (Fisik).
-TC-G05;Report, Closing, dan HPP;Compatibility;Data historis kandang-owned dan pooled data baru dapat coexist;Regression;High;Dalam satu date range ada transaksi lama kandang-owned dan transaksi baru pooled farm-level.;1. Jalankan closing. 2. Jalankan report. 3. Jalankan HPP.;Kedua jenis data diproses dengan benar, tidak ada double count dan tidak ada atribusi yang hilang.
-TC-H01;FIFO-v2 dan Integritas Allocation;FIFO-v2;Kontrak FIFO-v2 tidak berubah;Integration;High;Gunakan data uji yang mencakup recording stock, depletion, egg, dan marketing.;1. Verifikasi route FIFO untuk RECORDING_STOCK_OUT, RECORDING_DEPLETION_OUT, RECORDING_DEPLETION_IN, RECORDING_EGG_IN, dan MARKETING_OUT. 2. Bandingkan dengan RFC.md dan seed config FIFO-v2.;Tidak ada perubahan semantik route yang tidak disengaja.
-TC-H02;FIFO-v2 dan Integritas Allocation;Stock Allocation;Stock allocation tetap konsisten untuk pakan dari gudang farm;Integration;High;Sudah menjalankan TC-C02.;1. Inspect stock_allocations setelah transaksi.;Allocation consume terbentuk dengan benar dan tidak ada row allocation yatim atau rusak.
-TC-H03;FIFO-v2 dan Integritas Allocation;Stock Allocation;Stock allocation tetap konsisten untuk penjualan telur pooled;Integration;High;Sudah menjalankan TC-F03.;1. Inspect stock_allocations. 2. Inspect row atribusi turunannya.;Allocation mendukung atribusi HPP kembali ke kandang sumber.
-TC-H04;FIFO-v2 dan Integritas Allocation;Population Allocation;Population allocation tetap konsisten untuk penjualan ayam pooled;Integration;High;Sudah menjalankan TC-F04.;1. Inspect population allocations.;Penggunaan kandang sumber teralokasi dengan benar dan tidak fallback ke atribusi null saat source tersedia.
-TC-I01;Negative dan Guard Cases;Recording;Recording dari stok farm-level dengan qty tidak cukup;Negative;High;Stok farm-level tersedia tetapi qty lebih kecil dari pemakaian yang diinput.;1. Buat recording dengan qty melebihi stok. 2. Submit atau approve.;Muncul validation atau business error dan tidak ada korupsi parsial.
-TC-I02;Negative dan Guard Cases;Marketing;Marketing dari stok farm-level dengan qty tidak cukup;Negative;High;Stok farm-level tersedia tetapi qty lebih kecil dari qty penjualan.;1. Buat SO atau DO dengan qty melebihi stok. 2. Submit atau approve.;Delivery atau approval diblok dan stok tetap konsisten.
-TC-I03;Negative dan Guard Cases;Frontend Selector;Opsi produk sama di gudang berbeda tidak salah terpilih;UI Regression;Medium;Produk yang sama tersedia di gudang farm dan gudang kandang.;1. Pilih masing-masing opsi secara eksplisit di UI. 2. Save. 3. Buka kembali edit atau detail.;Opsi yang terpilih jelas dan tetap stabil setelah save atau edit.
-TC-I04;Negative dan Guard Cases;Product Warehouse;Row gudang shared tidak diatribusikan ulang oleh flow maintenance;Regression;High;Ada row shared farm warehouse yang sudah aktif.;1. Jalankan flow yang menyentuh logic ensure/find product warehouse. 2. Cek ulang row farm shared.;Tidak ada mutasi diam-diam pada project_flock_kandang_id.
-TC-J01;Regression Frontend dan UX;Recording Form;Form recording menampilkan opsi stok farm dan kandang hanya dalam scope farm yang sama;UI Regression;Medium;Ada stok di gudang farm, gudang kandang saat ini, dan gudang kandang lain.;1. Buka form recording untuk kandang tertentu. 2. Periksa opsi stock selector.;Gudang farm dan gudang kandang saat ini terlihat, gudang kandang lain tersembunyi.
-TC-J02;Regression Frontend dan UX;Recording Form;Selector recording telur mengizinkan gudang farm;UI Regression;Medium;Egg warehouse tersedia di gudang farm.;1. Buka form recording telur. 2. Buka selector tujuan telur.;Gudang farm terlihat sebagai opsi tujuan telur.
-TC-J03;Regression Frontend dan UX;Sales Form;Form sales memakai semantik gudang secara konsisten;UI Regression;Medium;Akses ke halaman marketing tersedia.;1. Buka form sales. 2. Periksa label selector dan summary table.;Label menggunakan Gudang Fisik secara konsisten dan tidak ada wording Kandang yang menyesatkan untuk stok fisik.
-TC-J04;Regression Frontend dan UX;Marketing Modal;Modal list marketing menampilkan label gudang fisik;UI Regression;Low;Akses ke modal product list tersedia.;1. Buka modal product list di marketing.;Kolom menampilkan label Gudang Fisik.
-TC-K01;Known Limitation;Recording Detail;Detail recording belum menampilkan source atau origin attribution baru;Known Limitation;Low;Sudah ada recording telur farm-level dan depletion dengan source attribution.;1. Buat transaksi. 2. Buka detail recording.;Transaksi berjalan dan atribusi tersimpan di DB, tetapi detail API atau UI mungkin belum menampilkan field source atau origin tersebut

docs/sql/legacy_egg_cutover_audit_queries.sql

@@ -1,343 +0,0 @@
--- Legacy Egg Cutover Audit Helper Queries
--- Ad-hoc query pack for investigation, audit, dry-run review, and rollback readiness.
-
--- =====================================================================
--- AUDIT-01 All locations classified by kandang/farm egg posting timing
--- =====================================================================
-WITH timing AS (
-  SELECT
-    pf.location_id AS location_id,
-    l.name AS location_name,
-    MIN(CASE WHEN w.type = 'KANDANG' THEN DATE(r.record_datetime) END) AS first_kandang_date,
-    MAX(CASE WHEN w.type = 'KANDANG' THEN DATE(r.record_datetime) END) AS last_kandang_date,
-    MIN(CASE WHEN w.type = 'LOKASI' THEN DATE(r.record_datetime) END) AS first_farm_date,
-    MAX(CASE WHEN w.type = 'LOKASI' THEN DATE(r.record_datetime) END) AS last_farm_date
-  FROM recording_eggs re
-  JOIN recordings r ON r.id = re.recording_id
-  JOIN project_flock_kandangs pk ON pk.id = COALESCE(re.project_flock_kandang_id, r.project_flock_kandangs_id)
-  JOIN project_flocks pf ON pf.id = pk.project_flock_id
-  JOIN locations l ON l.id = pf.location_id
-  JOIN product_warehouses pw ON pw.id = re.product_warehouse_id
-  JOIN warehouses w ON w.id = pw.warehouse_id
-  GROUP BY pf.location_id, l.name
-)
-SELECT
-  location_id,
-  location_name,
-  first_kandang_date,
-  last_kandang_date,
-  first_farm_date,
-  last_farm_date,
-  CASE
-    WHEN first_farm_date IS NULL THEN 'KANDANG_ONLY'
-    WHEN last_kandang_date IS NULL OR first_farm_date > last_kandang_date THEN 'CLEAN_CUTOVER'
-    ELSE 'OVERLAP'
-  END AS location_status
-FROM timing
-ORDER BY location_name;
-
--- =====================================================================
--- AUDIT-02 All legacy kandang egg product warehouses with positive on-hand
--- =====================================================================
-WITH first_farm AS (
-  SELECT location_id, MIN(id) AS farm_warehouse_id
-  FROM warehouses
-  WHERE type = 'LOKASI'
-    AND deleted_at IS NULL
-  GROUP BY location_id
-)
-SELECT
-  l.id AS location_id,
-  l.name AS location_name,
-  kw.id AS source_warehouse_id,
-  kw.name AS source_warehouse_name,
-  fw.id AS farm_warehouse_id,
-  fw.name AS farm_warehouse_name,
-  pw.id AS product_warehouse_id,
-  p.id AS product_id,
-  p.name AS product_name,
-  COALESCE(pw.qty, 0) AS on_hand_qty
-FROM product_warehouses pw
-JOIN warehouses kw
-  ON kw.id = pw.warehouse_id
- AND kw.type = 'KANDANG'
- AND kw.deleted_at IS NULL
-JOIN locations l ON l.id = kw.location_id
-JOIN products p ON p.id = pw.product_id
-LEFT JOIN product_categories pc ON pc.id = p.product_category_id
-LEFT JOIN first_farm ff ON ff.location_id = kw.location_id
-LEFT JOIN warehouses fw ON fw.id = ff.farm_warehouse_id
-WHERE EXISTS (
-    SELECT 1 FROM recording_eggs re WHERE re.product_warehouse_id = pw.id
-  )
-  AND (
-    EXISTS (
-      SELECT 1 FROM flags f
-      WHERE f.flagable_type = 'products'
-        AND f.flagable_id = p.id
-        AND (UPPER(f.name) = 'TELUR' OR UPPER(f.name) LIKE 'TELUR-%')
-    )
-    OR (
-      NOT EXISTS (
-        SELECT 1 FROM flags f_any
-        WHERE f_any.flagable_type = 'products'
-          AND f_any.flagable_id = p.id
-      )
-      AND UPPER(COALESCE(pc.code, '')) = 'EGG'
-    )
-  )
-  AND COALESCE(pw.qty, 0) > 0
-ORDER BY l.name, kw.name, p.name;
-
--- =====================================================================
--- AUDIT-03 Totals per location for phase sizing
--- =====================================================================
-WITH candidates AS (
-  SELECT
-    l.name AS location_name,
-    COALESCE(pw.qty, 0) AS on_hand_qty
-  FROM product_warehouses pw
-  JOIN warehouses kw
-    ON kw.id = pw.warehouse_id
-   AND kw.type = 'KANDANG'
-   AND kw.deleted_at IS NULL
-  JOIN locations l ON l.id = kw.location_id
-  JOIN products p ON p.id = pw.product_id
-  LEFT JOIN product_categories pc ON pc.id = p.product_category_id
-  WHERE EXISTS (
-      SELECT 1 FROM recording_eggs re WHERE re.product_warehouse_id = pw.id
-    )
-    AND (
-      EXISTS (
-        SELECT 1 FROM flags f
-        WHERE f.flagable_type = 'products'
-          AND f.flagable_id = p.id
-          AND (UPPER(f.name) = 'TELUR' OR UPPER(f.name) LIKE 'TELUR-%')
-      )
-      OR (
-        NOT EXISTS (
-          SELECT 1 FROM flags f_any
-          WHERE f_any.flagable_type = 'products'
-            AND f_any.flagable_id = p.id
-        )
-        AND UPPER(COALESCE(pc.code, '')) = 'EGG'
-      )
-    )
-    AND COALESCE(pw.qty, 0) > 0
-)
-SELECT
-  location_name,
-  COUNT(*) AS positive_rows,
-  SUM(on_hand_qty) AS total_on_hand_qty
-FROM candidates
-GROUP BY location_name
-ORDER BY location_name;
-
--- =====================================================================
--- AUDIT-04 Locations missing farm warehouse
--- =====================================================================
-SELECT
-  l.id AS location_id,
-  l.name AS location_name
-FROM locations l
-WHERE EXISTS (
-    SELECT 1
-    FROM warehouses kw
-    WHERE kw.location_id = l.id
-      AND kw.type = 'KANDANG'
-      AND kw.deleted_at IS NULL
-  )
-  AND NOT EXISTS (
-    SELECT 1
-    FROM warehouses fw
-    WHERE fw.location_id = l.id
-      AND fw.type = 'LOKASI'
-      AND fw.deleted_at IS NULL
-  )
-ORDER BY l.name;
-
--- =====================================================================
--- AUDIT-05 Legacy recording_eggs still pointing to kandang warehouse
--- =====================================================================
-SELECT
-  l.name AS location_name,
-  kw.name AS kandang_warehouse_name,
-  p.name AS product_name,
-  COUNT(*) AS recording_rows
-FROM recording_eggs re
-JOIN product_warehouses pw ON pw.id = re.product_warehouse_id
-JOIN warehouses kw ON kw.id = pw.warehouse_id
-JOIN locations l ON l.id = kw.location_id
-JOIN products p ON p.id = pw.product_id
-WHERE kw.type = 'KANDANG'
-GROUP BY l.name, kw.name, p.name
-ORDER BY l.name, kw.name, p.name;
-
--- =====================================================================
--- AUDIT-06 Farm-level recording_eggs already present
--- =====================================================================
-SELECT
-  l.name AS location_name,
-  fw.name AS farm_warehouse_name,
-  p.name AS product_name,
-  COUNT(*) AS recording_rows
-FROM recording_eggs re
-JOIN product_warehouses pw ON pw.id = re.product_warehouse_id
-JOIN warehouses fw ON fw.id = pw.warehouse_id
-JOIN locations l ON l.id = fw.location_id
-JOIN products p ON p.id = pw.product_id
-WHERE fw.type = 'LOKASI'
-GROUP BY l.name, fw.name, p.name
-ORDER BY l.name, fw.name, p.name;
-
--- =====================================================================
--- AUDIT-07 Transfers created by cutover reason, grouped by run_id
--- =====================================================================
-SELECT
-  SPLIT_PART(SPLIT_PART(st.reason, '|run_id=', 2), '|', 1) AS run_id,
-  COUNT(DISTINCT st.id) AS transfer_count,
-  COUNT(std.id) AS detail_count,
-  SUM(COALESCE(std.total_qty, std.usage_qty, 0)) AS total_moved_qty,
-  MIN(st.transfer_date) AS first_transfer_date,
-  MAX(st.transfer_date) AS last_transfer_date
-FROM stock_transfers st
-JOIN stock_transfer_details std
-  ON std.stock_transfer_id = st.id
- AND std.deleted_at IS NULL
-WHERE st.reason LIKE 'EGG_FARM_CUTOVER|run_id=%'
-GROUP BY 1
-ORDER BY first_transfer_date DESC, run_id DESC;
-
--- =====================================================================
--- AUDIT-08 Detailed summary per run_id
--- Replace <run_id> before running.
--- =====================================================================
-SELECT
-  st.id AS transfer_id,
-  st.movement_number,
-  st.transfer_date,
-  ws.name AS source_warehouse_name,
-  wd.name AS farm_warehouse_name,
-  p.name AS product_name,
-  COALESCE(std.total_qty, std.usage_qty, 0) AS moved_qty,
-  st.deleted_at
-FROM stock_transfers st
-JOIN stock_transfer_details std
-  ON std.stock_transfer_id = st.id
- AND std.deleted_at IS NULL
-JOIN products p ON p.id = std.product_id
-JOIN warehouses ws ON ws.id = st.from_warehouse_id
-JOIN warehouses wd ON wd.id = st.to_warehouse_id
-WHERE st.reason LIKE 'EGG_FARM_CUTOVER|run_id=<run_id>|%'
-ORDER BY st.id, p.name;
-
--- =====================================================================
--- AUDIT-09 Downstream consumption check per run_id
--- Replace <run_id> before running.
--- =====================================================================
-SELECT
-  st.id AS transfer_id,
-  st.movement_number,
-  p.name AS product_name,
-  sa.usable_type,
-  sa.usable_id,
-  sa.qty,
-  sa.function_code,
-  sa.flag_group_code
-FROM stock_transfers st
-JOIN stock_transfer_details std
-  ON std.stock_transfer_id = st.id
- AND std.deleted_at IS NULL
-JOIN products p ON p.id = std.product_id
-JOIN stock_allocations sa
-  ON sa.stockable_type = 'STOCK_TRANSFER_IN'
- AND sa.stockable_id = std.id
- AND sa.status = 'ACTIVE'
- AND sa.allocation_purpose = 'CONSUME'
- AND sa.deleted_at IS NULL
-WHERE st.deleted_at IS NULL
-  AND st.reason LIKE 'EGG_FARM_CUTOVER|run_id=<run_id>|%'
-ORDER BY st.id, p.name, sa.usable_type, sa.usable_id;
-
--- =====================================================================
--- AUDIT-10 Stock log reconciliation per cutover transfer detail
--- Replace <run_id> before running.
--- =====================================================================
-SELECT
-  st.id AS transfer_id,
-  st.movement_number,
-  p.name AS product_name,
-  std.id AS transfer_detail_id,
-  COALESCE(std.total_qty, std.usage_qty, 0) AS moved_qty,
-  SUM(CASE WHEN sl.decrease > 0 THEN sl.decrease ELSE 0 END) AS total_logged_out,
-  SUM(CASE WHEN sl.increase > 0 THEN sl.increase ELSE 0 END) AS total_logged_in
-FROM stock_transfers st
-JOIN stock_transfer_details std
-  ON std.stock_transfer_id = st.id
- AND std.deleted_at IS NULL
-JOIN products p ON p.id = std.product_id
-LEFT JOIN stock_logs sl
-  ON sl.loggable_type = 'TRANSFER'
- AND sl.loggable_id = std.id
-WHERE st.deleted_at IS NULL
-  AND st.reason LIKE 'EGG_FARM_CUTOVER|run_id=<run_id>|%'
-GROUP BY st.id, st.movement_number, p.name, std.id, COALESCE(std.total_qty, std.usage_qty, 0)
-ORDER BY st.id, p.name;
-
--- =====================================================================
--- AUDIT-11 New recording eggs still posting to kandang after cutoff date
--- Replace values before running.
--- =====================================================================
-SELECT
-  DATE(r.record_datetime) AS record_date,
-  l.name AS location_name,
-  kw.name AS kandang_warehouse_name,
-  p.name AS product_name,
-  re.qty
-FROM recording_eggs re
-JOIN recordings r ON r.id = re.recording_id
-JOIN product_warehouses pw ON pw.id = re.product_warehouse_id
-JOIN warehouses kw ON kw.id = pw.warehouse_id
-JOIN locations l ON l.id = kw.location_id
-JOIN products p ON p.id = pw.product_id
-WHERE kw.type = 'KANDANG'
-  AND LOWER(l.name) = LOWER('<location_name>')
-  AND DATE(r.record_datetime) >= DATE('<cutover_date>')
-ORDER BY r.record_datetime ASC, kw.name, p.name;
-
--- Expectation:
--- - after deploy and cutover, this should ideally return 0 rows for the location
-
--- =====================================================================
--- AUDIT-12 Combined kandang + farm egg stock per location after cutover
--- Replace <location_name> before running.
--- =====================================================================
-SELECT
-  l.name AS location_name,
-  w.type AS warehouse_type,
-  p.name AS product_name,
-  SUM(COALESCE(pw.qty, 0)) AS total_qty
-FROM product_warehouses pw
-JOIN warehouses w ON w.id = pw.warehouse_id
-JOIN locations l ON l.id = w.location_id
-JOIN products p ON p.id = pw.product_id
-LEFT JOIN product_categories pc ON pc.id = p.product_category_id
-WHERE LOWER(l.name) = LOWER('<location_name>')
-  AND (
-    EXISTS (
-      SELECT 1 FROM flags f
-      WHERE f.flagable_type = 'products'
-        AND f.flagable_id = p.id
-        AND (UPPER(f.name) = 'TELUR' OR UPPER(f.name) LIKE 'TELUR-%')
-    )
-    OR (
-      NOT EXISTS (
-        SELECT 1 FROM flags f_any
-        WHERE f_any.flagable_type = 'products'
-          AND f_any.flagable_id = p.id
-      )
-      AND UPPER(COALESCE(pc.code, '')) = 'EGG'
-    )
-  )
-GROUP BY l.name, w.type, p.name
-ORDER BY w.type, p.name;

docs/sql/legacy_egg_cutover_verification_checklist.sql

@@ -1,400 +0,0 @@
--- Legacy Egg Cutover Verification Checklist
--- Usage:
--- 1. Replace the values below before executing.
--- 2. Run section BEFORE before --apply.
--- 3. Run section AFTER after --apply.
--- 4. Run rollback checks if needed.
-
--- =====================================================================
--- PARAMETERS
--- =====================================================================
-
--- Replace manually before running.
--- Example:
---   location_name = Jamali
---   cutover_date  = 2026-04-07
---   run_id        = egg-cutover-20260407T130344.220407000Z
-
--- =====================================================================
--- BEFORE APPLY
--- =====================================================================
-
--- [BEFORE-01] Identify target location and farm warehouse
-SELECT
-  l.id AS location_id,
-  l.name AS location_name,
-  fw.id AS farm_warehouse_id,
-  fw.name AS farm_warehouse_name
-FROM locations l
-LEFT JOIN warehouses fw
-  ON fw.location_id = l.id
- AND fw.type = 'LOKASI'
- AND fw.deleted_at IS NULL
-WHERE LOWER(l.name) = LOWER('<location_name>')
-ORDER BY fw.id ASC;
-
--- Expectation:
--- - exactly one target location
--- - at least one farm warehouse exists
-
--- [BEFORE-02] Verify location timing status (must be CLEAN_CUTOVER for phase 1)
-WITH timing AS (
-  SELECT
-    pf.location_id AS location_id,
-    l.name AS location_name,
-    MIN(CASE WHEN w.type = 'KANDANG' THEN DATE(r.record_datetime) END) AS first_kandang_date,
-    MAX(CASE WHEN w.type = 'KANDANG' THEN DATE(r.record_datetime) END) AS last_kandang_date,
-    MIN(CASE WHEN w.type = 'LOKASI' THEN DATE(r.record_datetime) END) AS first_farm_date,
-    MAX(CASE WHEN w.type = 'LOKASI' THEN DATE(r.record_datetime) END) AS last_farm_date
-  FROM recording_eggs re
-  JOIN recordings r ON r.id = re.recording_id
-  JOIN project_flock_kandangs pk ON pk.id = COALESCE(re.project_flock_kandang_id, r.project_flock_kandangs_id)
-  JOIN project_flocks pf ON pf.id = pk.project_flock_id
-  JOIN locations l ON l.id = pf.location_id
-  JOIN product_warehouses pw ON pw.id = re.product_warehouse_id
-  JOIN warehouses w ON w.id = pw.warehouse_id
-  WHERE LOWER(l.name) = LOWER('<location_name>')
-  GROUP BY pf.location_id, l.name
-)
-SELECT
-  location_id,
-  location_name,
-  first_kandang_date,
-  last_kandang_date,
-  first_farm_date,
-  last_farm_date,
-  CASE
-    WHEN first_farm_date IS NULL THEN 'KANDANG_ONLY'
-    WHEN last_kandang_date IS NULL OR first_farm_date > last_kandang_date THEN 'CLEAN_CUTOVER'
-    ELSE 'OVERLAP'
-  END AS location_status
-FROM timing;
-
--- Expectation:
--- - phase 1 location must be CLEAN_CUTOVER
-
--- [BEFORE-03] Candidate source rows that should be migrated
-WITH first_farm AS (
-  SELECT location_id, MIN(id) AS farm_warehouse_id
-  FROM warehouses
-  WHERE type = 'LOKASI'
-    AND deleted_at IS NULL
-  GROUP BY location_id
-)
-SELECT
-  l.id AS location_id,
-  l.name AS location_name,
-  kw.id AS source_warehouse_id,
-  kw.name AS source_warehouse_name,
-  fw.id AS farm_warehouse_id,
-  fw.name AS farm_warehouse_name,
-  pw.id AS product_warehouse_id,
-  p.id AS product_id,
-  p.name AS product_name,
-  COALESCE(pw.qty, 0) AS on_hand_qty
-FROM product_warehouses pw
-JOIN warehouses kw
-  ON kw.id = pw.warehouse_id
- AND kw.type = 'KANDANG'
- AND kw.deleted_at IS NULL
-JOIN locations l ON l.id = kw.location_id
-JOIN products p ON p.id = pw.product_id
-LEFT JOIN product_categories pc ON pc.id = p.product_category_id
-LEFT JOIN first_farm ff ON ff.location_id = kw.location_id
-LEFT JOIN warehouses fw ON fw.id = ff.farm_warehouse_id
-WHERE LOWER(l.name) = LOWER('<location_name>')
-  AND EXISTS (
-    SELECT 1
-    FROM recording_eggs re
-    WHERE re.product_warehouse_id = pw.id
-  )
-  AND (
-    EXISTS (
-      SELECT 1
-      FROM flags f
-      WHERE f.flagable_type = 'products'
-        AND f.flagable_id = p.id
-        AND (UPPER(f.name) = 'TELUR' OR UPPER(f.name) LIKE 'TELUR-%')
-    )
-    OR (
-      NOT EXISTS (
-        SELECT 1
-        FROM flags f_any
-        WHERE f_any.flagable_type = 'products'
-          AND f_any.flagable_id = p.id
-      )
-      AND UPPER(COALESCE(pc.code, '')) = 'EGG'
-    )
-  )
-  AND COALESCE(pw.qty, 0) > 0
-ORDER BY kw.name, p.name;
-
--- Expectation:
--- - every row here should match dry-run eligible rows
-
--- [BEFORE-04] Totals per source warehouse and product
-WITH candidates AS (
-  SELECT
-    kw.name AS source_warehouse_name,
-    p.name AS product_name,
-    COALESCE(pw.qty, 0) AS on_hand_qty
-  FROM product_warehouses pw
-  JOIN warehouses kw
-    ON kw.id = pw.warehouse_id
-   AND kw.type = 'KANDANG'
-   AND kw.deleted_at IS NULL
-  JOIN locations l ON l.id = kw.location_id
-  JOIN products p ON p.id = pw.product_id
-  LEFT JOIN product_categories pc ON pc.id = p.product_category_id
-  WHERE LOWER(l.name) = LOWER('<location_name>')
-    AND EXISTS (
-      SELECT 1 FROM recording_eggs re WHERE re.product_warehouse_id = pw.id
-    )
-    AND (
-      EXISTS (
-        SELECT 1 FROM flags f
-        WHERE f.flagable_type = 'products'
-          AND f.flagable_id = p.id
-          AND (UPPER(f.name) = 'TELUR' OR UPPER(f.name) LIKE 'TELUR-%')
-      )
-      OR (
-        NOT EXISTS (
-          SELECT 1 FROM flags f_any
-          WHERE f_any.flagable_type = 'products'
-            AND f_any.flagable_id = p.id
-        )
-        AND UPPER(COALESCE(pc.code, '')) = 'EGG'
-      )
-    )
-    AND COALESCE(pw.qty, 0) > 0
-)
-SELECT
-  source_warehouse_name,
-  product_name,
-  SUM(on_hand_qty) AS total_qty
-FROM candidates
-GROUP BY source_warehouse_name, product_name
-ORDER BY source_warehouse_name, product_name;
-
--- [BEFORE-05] Current farm egg stock before cutover
-SELECT
-  fw.name AS farm_warehouse_name,
-  p.name AS product_name,
-  COALESCE(pw.qty, 0) AS farm_on_hand_qty
-FROM warehouses fw
-JOIN locations l ON l.id = fw.location_id
-JOIN product_warehouses pw ON pw.warehouse_id = fw.id
-JOIN products p ON p.id = pw.product_id
-LEFT JOIN product_categories pc ON pc.id = p.product_category_id
-WHERE LOWER(l.name) = LOWER('<location_name>')
-  AND fw.type = 'LOKASI'
-  AND fw.deleted_at IS NULL
-  AND (
-    EXISTS (
-      SELECT 1 FROM flags f
-      WHERE f.flagable_type = 'products'
-        AND f.flagable_id = p.id
-        AND (UPPER(f.name) = 'TELUR' OR UPPER(f.name) LIKE 'TELUR-%')
-    )
-    OR (
-      NOT EXISTS (
-        SELECT 1 FROM flags f_any
-        WHERE f_any.flagable_type = 'products'
-          AND f_any.flagable_id = p.id
-      )
-      AND UPPER(COALESCE(pc.code, '')) = 'EGG'
-    )
-  )
-ORDER BY p.name;
-
--- [BEFORE-06] Existing cutover transfers for this location
-SELECT
-  st.id,
-  st.movement_number,
-  st.transfer_date,
-  st.reason,
-  ws.name AS source_warehouse_name,
-  wd.name AS farm_warehouse_name,
-  st.deleted_at
-FROM stock_transfers st
-JOIN warehouses ws ON ws.id = st.from_warehouse_id
-JOIN warehouses wd ON wd.id = st.to_warehouse_id
-LEFT JOIN locations l ON l.id = COALESCE(ws.location_id, wd.location_id)
-WHERE LOWER(COALESCE(l.name, '')) = LOWER('<location_name>')
-  AND st.reason LIKE 'EGG_FARM_CUTOVER|%'
-ORDER BY st.id DESC;
-
--- Expectation:
--- - no unexpected older active cutover transfers for the same location
-
--- =====================================================================
--- AFTER APPLY
--- =====================================================================
-
--- [AFTER-01] Transfer headers created by run_id
-SELECT
-  st.id,
-  st.movement_number,
-  st.transfer_date,
-  st.reason,
-  ws.name AS source_warehouse_name,
-  wd.name AS farm_warehouse_name,
-  st.deleted_at
-FROM stock_transfers st
-JOIN warehouses ws ON ws.id = st.from_warehouse_id
-JOIN warehouses wd ON wd.id = st.to_warehouse_id
-WHERE st.reason LIKE 'EGG_FARM_CUTOVER|run_id=<run_id>|%'
-ORDER BY st.id ASC;
-
--- [AFTER-02] Transfer detail rows created by run_id
-SELECT
-  st.id AS transfer_id,
-  st.movement_number,
-  ws.name AS source_warehouse_name,
-  wd.name AS farm_warehouse_name,
-  p.name AS product_name,
-  COALESCE(std.total_qty, std.usage_qty, 0) AS moved_qty,
-  std.source_product_warehouse_id,
-  std.dest_product_warehouse_id
-FROM stock_transfers st
-JOIN stock_transfer_details std
-  ON std.stock_transfer_id = st.id
- AND std.deleted_at IS NULL
-JOIN products p ON p.id = std.product_id
-JOIN warehouses ws ON ws.id = st.from_warehouse_id
-JOIN warehouses wd ON wd.id = st.to_warehouse_id
-WHERE st.deleted_at IS NULL
-  AND st.reason LIKE 'EGG_FARM_CUTOVER|run_id=<run_id>|%'
-ORDER BY st.id, p.name;
-
--- [AFTER-03] Stock logs created by run_id transfer details
-SELECT
-  st.id AS transfer_id,
-  st.movement_number,
-  p.name AS product_name,
-  sl.product_warehouse_id,
-  sl.increase,
-  sl.decrease,
-  sl.stock,
-  sl.created_at
-FROM stock_transfers st
-JOIN stock_transfer_details std
-  ON std.stock_transfer_id = st.id
- AND std.deleted_at IS NULL
-JOIN products p ON p.id = std.product_id
-JOIN stock_logs sl
-  ON sl.loggable_type = 'TRANSFER'
- AND sl.loggable_id = std.id
-WHERE st.deleted_at IS NULL
-  AND st.reason LIKE 'EGG_FARM_CUTOVER|run_id=<run_id>|%'
-ORDER BY st.id, p.name, sl.id;
-
--- Expectation:
--- - every detail has one stock log decrease from source and one stock log increase to destination
-
--- [AFTER-04] Source rows after cutover
-SELECT
-  kw.name AS source_warehouse_name,
-  p.name AS product_name,
-  COALESCE(pw.qty, 0) AS source_qty_after
-FROM product_warehouses pw
-JOIN warehouses kw ON kw.id = pw.warehouse_id
-JOIN locations l ON l.id = kw.location_id
-JOIN products p ON p.id = pw.product_id
-WHERE LOWER(l.name) = LOWER('<location_name>')
-  AND kw.type = 'KANDANG'
-  AND EXISTS (
-    SELECT 1 FROM recording_eggs re WHERE re.product_warehouse_id = pw.id
-  )
-ORDER BY kw.name, p.name;
-
--- Expectation:
--- - rows that were transferred should now be 0 or no longer available for use
-
--- [AFTER-05] Farm rows after cutover
-SELECT
-  fw.name AS farm_warehouse_name,
-  p.name AS product_name,
-  COALESCE(pw.qty, 0) AS farm_qty_after
-FROM product_warehouses pw
-JOIN warehouses fw ON fw.id = pw.warehouse_id
-JOIN locations l ON l.id = fw.location_id
-JOIN products p ON p.id = pw.product_id
-WHERE LOWER(l.name) = LOWER('<location_name>')
-  AND fw.type = 'LOKASI'
-ORDER BY fw.name, p.name;
-
--- Expectation:
--- - farm qty increases by the moved amount
-
--- [AFTER-06] Reconciliation: total moved by run
-SELECT
-  p.name AS product_name,
-  SUM(COALESCE(std.total_qty, std.usage_qty, 0)) AS total_moved_qty
-FROM stock_transfers st
-JOIN stock_transfer_details std
-  ON std.stock_transfer_id = st.id
- AND std.deleted_at IS NULL
-JOIN products p ON p.id = std.product_id
-WHERE st.deleted_at IS NULL
-  AND st.reason LIKE 'EGG_FARM_CUTOVER|run_id=<run_id>|%'
-GROUP BY p.name
-ORDER BY p.name;
-
--- [AFTER-07] Farm stock available for SO after cutover
-SELECT
-  fw.name AS farm_warehouse_name,
-  p.name AS product_name,
-  COALESCE(pw.qty, 0) AS available_qty
-FROM product_warehouses pw
-JOIN warehouses fw ON fw.id = pw.warehouse_id
-JOIN locations l ON l.id = fw.location_id
-JOIN products p ON p.id = pw.product_id
-WHERE LOWER(l.name) = LOWER('<location_name>')
-  AND fw.type = 'LOKASI'
-  AND COALESCE(pw.qty, 0) > 0
-ORDER BY p.name;
-
--- =====================================================================
--- ROLLBACK CHECKS
--- =====================================================================
-
--- [ROLLBACK-01] Check downstream consumption guard before rollback
-SELECT
-  st.id AS transfer_id,
-  st.movement_number,
-  p.name AS product_name,
-  sa.usable_type,
-  sa.usable_id,
-  sa.qty,
-  sa.function_code,
-  sa.flag_group_code
-FROM stock_transfers st
-JOIN stock_transfer_details std
-  ON std.stock_transfer_id = st.id
- AND std.deleted_at IS NULL
-JOIN products p ON p.id = std.product_id
-JOIN stock_allocations sa
-  ON sa.stockable_type = 'STOCK_TRANSFER_IN'
- AND sa.stockable_id = std.id
- AND sa.status = 'ACTIVE'
- AND sa.allocation_purpose = 'CONSUME'
- AND sa.deleted_at IS NULL
-WHERE st.deleted_at IS NULL
-  AND st.reason LIKE 'EGG_FARM_CUTOVER|run_id=<run_id>|%'
-ORDER BY st.id, p.name, sa.usable_type, sa.usable_id;
-
--- Expectation:
--- - rollback only safe if this query returns 0 rows
-
--- [ROLLBACK-02] Verify run is fully rolled back
-SELECT
-  st.id,
-  st.movement_number,
-  st.deleted_at
-FROM stock_transfers st
-WHERE st.reason LIKE 'EGG_FARM_CUTOVER|run_id=<run_id>|%'
-ORDER BY st.id;
-
--- Expectation:
--- - after rollback, deleted_at should be filled for all transfers in the run

internal/apikeys/defaults.go

@@ -1,93 +0,0 @@
-package apikeys
-
-func DefaultDashboardPermissions() []string {
-	return []string{
-		"lti.approval.list",
-		"lti.closing.list",
-		"lti.closing.detail",
-		"lti.daily_checklist.create",
-		"lti.daily_checklist.dashboard.list",
-		"lti.daily_checklist.detail",
-		"lti.daily_checklist.list",
-		"lti.daily_checklist.master_data.activity",
-		"lti.daily_checklist.master_data.configuration",
-		"lti.daily_checklist.master_data.employee",
-		"lti.daily_checklist.reports",
-		"lti.dashboard.list",
-		"lti.expense.detail",
-		"lti.expense.list",
-		"lti.finance.initial_balances.detail",
-		"lti.finance.injections.detail",
-		"lti.finance.payments.detail",
-		"lti.finance.transactions.detail",
-		"lti.finance.transactions.list",
-		"lti.inventory.detail",
-		"lti.inventory.list",
-		"lti.inventory.product_stock.detail",
-		"lti.inventory.product_stock.list",
-		"lti.inventory.product_warehouses.detail",
-		"lti.inventory.product_warehouses.list",
-		"lti.inventory.transfer.detail",
-		"lti.inventory.transfer.list",
-		"lti.marketing.delivery_order.detail",
-		"lti.marketing.delivery_order.list",
-		"lti.master.area.detail",
-		"lti.master.area.list",
-		"lti.master.banks.detail",
-		"lti.master.banks.list",
-		"lti.master.customer.detail",
-		"lti.master.customer.list",
-		"lti.master.fcr.detail",
-		"lti.master.fcr.list",
-		"lti.master.flocks.detail",
-		"lti.master.flocks.list",
-		"lti.master.kandangs.detail",
-		"lti.master.kandangs.list",
-		"lti.master.locations.detail",
-		"lti.master.locations.list",
-		"lti.master.nonstocks.detail",
-		"lti.master.nonstocks.list",
-		"lti.master.product_categories.detail",
-		"lti.master.product_categories.list",
-		"lti.master.products.detail",
-		"lti.master.products.list",
-		"lti.master.production_standards.detail",
-		"lti.master.production_standards.list",
-		"lti.master.suppliers.detail",
-		"lti.master.suppliers.list",
-		"lti.master.uoms.detail",
-		"lti.master.uoms.list",
-		"lti.master.warehouses.detail",
-		"lti.master.warehouses.list",
-		"lti.production.chickins.detail",
-		"lti.production.project_flock_kandangs.closing.detail",
-		"lti.production.project_flock_kandangs.detail",
-		"lti.production.project_flock_kandangs.list",
-		"lti.production.project_flocks.detail",
-		"lti.production.project_flocks.list",
-		"lti.production.project_flocks.lookup",
-		"lti.production.project_flocks.next_period",
-		"lti.production.recording.detail",
-		"lti.production.recording.list",
-		"lti.production.recording.next_day",
-		"lti.production.transfer_to_laying.create",
-		"lti.production.transfer_to_laying.detail",
-		"lti.production.transfer_to_laying.getavailableqty",
-		"lti.production.transfer_to_laying.list",
-		"lti.production.uniformity.detail",
-		"lti.production.uniformity.list",
-		"lti.purchase.detail",
-		"lti.purchase.list",
-		"lti.repport.customerpayment.list",
-		"lti.repport.debtsupplier.list",
-		"lti.repport.delivery.list",
-		"lti.repport.expense.list",
-		"lti.repport.expense.depreciation.manage",
-		"lti.repport.gethppperkandang.list",
-		"lti.repport.production_result.list",
-		"lti.repport.purchasesupplier.list",
-		"lti.users.detail",
-		"lti.users.list",
-		"lti.daily_checklist.master_data.kandang",
-	}
-}

internal/apikeys/repository.go

@@ -1,107 +0,0 @@
-package apikeys
-
-import (
-	"context"
-	"errors"
-	"time"
-
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gorm.io/gorm"
-)
-
-type Repository interface {
-	Create(ctx context.Context, record *entity.IntegrationAPIKey) error
-	GetByEnvironmentAndPrefix(ctx context.Context, environment, prefix string) (*entity.IntegrationAPIKey, error)
-	List(ctx context.Context, environment string) ([]entity.IntegrationAPIKey, error)
-	Revoke(ctx context.Context, environment, prefix string, revokedAt time.Time) error
-	TouchLastUsed(ctx context.Context, id uint, usedAt time.Time, usedFrom string) error
-}
-
-type repository struct {
-	db *gorm.DB
-}
-
-func NewRepository(db *gorm.DB) Repository {
-	return &repository{db: db}
-}
-
-func (r *repository) Create(ctx context.Context, record *entity.IntegrationAPIKey) error {
-	if r.db == nil {
-		return errors.New("database not configured")
-	}
-	return r.db.WithContext(ctx).Create(record).Error
-}
-
-func (r *repository) GetByEnvironmentAndPrefix(ctx context.Context, environment, prefix string) (*entity.IntegrationAPIKey, error) {
-	if r.db == nil {
-		return nil, errors.New("database not configured")
-	}
-
-	var record entity.IntegrationAPIKey
-	if err := r.db.WithContext(ctx).
-		Where("environment = ?", environment).
-		Where("key_prefix = ?", prefix).
-		First(&record).Error; err != nil {
-		return nil, err
-	}
-
-	return &record, nil
-}
-
-func (r *repository) List(ctx context.Context, environment string) ([]entity.IntegrationAPIKey, error) {
-	if r.db == nil {
-		return nil, errors.New("database not configured")
-	}
-
-	query := r.db.WithContext(ctx).Model(&entity.IntegrationAPIKey{})
-	if environment != "" {
-		query = query.Where("environment = ?", environment)
-	}
-
-	var records []entity.IntegrationAPIKey
-	if err := query.Order("environment ASC").Order("name ASC").Find(&records).Error; err != nil {
-		return nil, err
-	}
-
-	return records, nil
-}
-
-func (r *repository) Revoke(ctx context.Context, environment, prefix string, revokedAt time.Time) error {
-	if r.db == nil {
-		return errors.New("database not configured")
-	}
-
-	updates := map[string]any{
-		"status":     entity.IntegrationAPIKeyStatusRevoked,
-		"revoked_at": revokedAt,
-		"updated_at": revokedAt,
-	}
-
-	result := r.db.WithContext(ctx).
-		Model(&entity.IntegrationAPIKey{}).
-		Where("environment = ?", environment).
-		Where("key_prefix = ?", prefix).
-		Updates(updates)
-	if result.Error != nil {
-		return result.Error
-	}
-	if result.RowsAffected == 0 {
-		return gorm.ErrRecordNotFound
-	}
-	return nil
-}
-
-func (r *repository) TouchLastUsed(ctx context.Context, id uint, usedAt time.Time, usedFrom string) error {
-	if r.db == nil {
-		return errors.New("database not configured")
-	}
-
-	return r.db.WithContext(ctx).
-		Model(&entity.IntegrationAPIKey{}).
-		Where("id = ?", id).
-		Updates(map[string]any{
-			"last_used_at":   usedAt,
-			"last_used_from": usedFrom,
-			"updated_at":     usedAt,
-		}).Error
-}

internal/apikeys/service.go

@@ -1,233 +0,0 @@
-package apikeys
-
-import (
-	"context"
-	"crypto/rand"
-	"encoding/base32"
-	"errors"
-	"fmt"
-	"strings"
-	"time"
-
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils/secure"
-	"gorm.io/gorm"
-)
-
-var (
-	ErrInvalidAPIKey = errors.New("invalid api key")
-	ErrInactiveKey   = errors.New("inactive api key")
-)
-
-type Principal struct {
-	ID          uint
-	Name        string
-	Environment string
-	Permissions []string
-	AllArea     bool
-	AreaIDs     []uint
-	AllLocation bool
-	LocationIDs []uint
-}
-
-type Authenticator interface {
-	Authenticate(ctx context.Context, rawKey, source string) (*Principal, error)
-}
-
-type Service interface {
-	Authenticator
-	Create(ctx context.Context, input CreateInput) (*IssuedKey, error)
-	List(ctx context.Context, environment string) ([]entity.IntegrationAPIKey, error)
-	Revoke(ctx context.Context, environment, prefix string) error
-}
-
-type CreateInput struct {
-	Name            string
-	Environment     string
-	PermissionCodes []string
-	AllArea         bool
-	AreaIDs         []uint
-	AllLocation     bool
-	LocationIDs     []uint
-}
-
-type IssuedKey struct {
-	Key    string
-	Record *entity.IntegrationAPIKey
-}
-
-type service struct {
-	repo Repository
-	now  func() time.Time
-}
-
-func NewService(db *gorm.DB) Service {
-	return &service{
-		repo: NewRepository(db),
-		now:  time.Now,
-	}
-}
-
-func (s *service) Authenticate(ctx context.Context, rawKey, source string) (*Principal, error) {
-	environment, prefix, secret, err := parseRawKey(rawKey)
-	if err != nil {
-		return nil, ErrInvalidAPIKey
-	}
-
-	record, err := s.repo.GetByEnvironmentAndPrefix(ctx, environment, prefix)
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, ErrInvalidAPIKey
-		}
-		return nil, err
-	}
-
-	if !strings.EqualFold(record.Status, entity.IntegrationAPIKeyStatusActive) || record.RevokedAt != nil {
-		return nil, ErrInactiveKey
-	}
-	if !secure.Verify(record.KeyHash, secret) {
-		return nil, ErrInvalidAPIKey
-	}
-
-	usedAt := s.now().UTC()
-	if err := s.repo.TouchLastUsed(ctx, record.ID, usedAt, strings.TrimSpace(source)); err != nil {
-		utils.Log.WithError(err).Warn("api key: failed to update last_used fields")
-	}
-
-	return &Principal{
-		ID:          record.ID,
-		Name:        record.Name,
-		Environment: record.Environment,
-		Permissions: canonicalPermissions(record.PermissionCodes),
-		AllArea:     record.AllArea,
-		AreaIDs:     uniqueUint(record.AreaIDs),
-		AllLocation: record.AllLocation,
-		LocationIDs: uniqueUint(record.LocationIDs),
-	}, nil
-}
-
-func (s *service) Create(ctx context.Context, input CreateInput) (*IssuedKey, error) {
-	name := strings.TrimSpace(input.Name)
-	environment := strings.ToLower(strings.TrimSpace(input.Environment))
-	if name == "" || environment == "" {
-		return nil, fmt.Errorf("name and environment are required")
-	}
-
-	prefix, err := randomToken(10)
-	if err != nil {
-		return nil, err
-	}
-	secret, err := randomToken(24)
-	if err != nil {
-		return nil, err
-	}
-
-	hash, err := secure.Hash(secret, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	record := &entity.IntegrationAPIKey{
-		Name:            name,
-		Environment:     environment,
-		Status:          entity.IntegrationAPIKeyStatusActive,
-		KeyPrefix:       prefix,
-		KeyHash:         hash,
-		PermissionCodes: canonicalPermissions(input.PermissionCodes),
-		AllArea:         input.AllArea,
-		AreaIDs:         uniqueUint(input.AreaIDs),
-		AllLocation:     input.AllLocation,
-		LocationIDs:     uniqueUint(input.LocationIDs),
-	}
-
-	if err := s.repo.Create(ctx, record); err != nil {
-		return nil, err
-	}
-
-	return &IssuedKey{
-		Key:    fmt.Sprintf("lti_%s_%s_%s", environment, prefix, secret),
-		Record: record,
-	}, nil
-}
-
-func (s *service) List(ctx context.Context, environment string) ([]entity.IntegrationAPIKey, error) {
-	return s.repo.List(ctx, strings.ToLower(strings.TrimSpace(environment)))
-}
-
-func (s *service) Revoke(ctx context.Context, environment, prefix string) error {
-	environment = strings.ToLower(strings.TrimSpace(environment))
-	prefix = strings.TrimSpace(prefix)
-	if environment == "" || prefix == "" {
-		return fmt.Errorf("environment and prefix are required")
-	}
-	return s.repo.Revoke(ctx, environment, prefix, s.now().UTC())
-}
-
-func parseRawKey(rawKey string) (environment string, prefix string, secret string, err error) {
-	rawKey = strings.TrimSpace(rawKey)
-	parts := strings.Split(rawKey, "_")
-	if len(parts) != 4 || parts[0] != "lti" {
-		return "", "", "", ErrInvalidAPIKey
-	}
-
-	environment = strings.ToLower(strings.TrimSpace(parts[1]))
-	prefix = strings.TrimSpace(parts[2])
-	secret = strings.TrimSpace(parts[3])
-	if environment == "" || prefix == "" || secret == "" {
-		return "", "", "", ErrInvalidAPIKey
-	}
-
-	return environment, prefix, secret, nil
-}
-
-func randomToken(size int) (string, error) {
-	buf := make([]byte, size)
-	if _, err := rand.Read(buf); err != nil {
-		return "", err
-	}
-
-	encoder := base32.StdEncoding.WithPadding(base32.NoPadding)
-	return strings.ToLower(encoder.EncodeToString(buf)), nil
-}
-
-func canonicalPermissions(perms []string) []string {
-	if len(perms) == 0 {
-		return []string{}
-	}
-
-	seen := make(map[string]struct{}, len(perms))
-	result := make([]string, 0, len(perms))
-	for _, perm := range perms {
-		perm = strings.ToLower(strings.TrimSpace(perm))
-		if perm == "" {
-			continue
-		}
-		if _, ok := seen[perm]; ok {
-			continue
-		}
-		seen[perm] = struct{}{}
-		result = append(result, perm)
-	}
-	return result
-}
-
-func uniqueUint(values []uint) []uint {
-	if len(values) == 0 {
-		return []uint{}
-	}
-
-	seen := make(map[uint]struct{}, len(values))
-	result := make([]uint, 0, len(values))
-	for _, value := range values {
-		if value == 0 {
-			continue
-		}
-		if _, ok := seen[value]; ok {
-			continue
-		}
-		seen[value] = struct{}{}
-		result = append(result, value)
-	}
-	return result
-}

internal/common/repository/common.hpp.repository.go

@@ -2,7 +2,6 @@ package repository
 
 import (
 	"context"
-	"errors"
 	"time"
 
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
@@ -24,7 +23,6 @@ type HppCostRepository interface {
 	GetEggTerjualPiecesAndWeightKgByProjectFlockKandangIds(ctx context.Context, projectFlockKandangIDs []uint, startDate *time.Time, endDate *time.Time) (float64, float64, error)
 	GetProjectFlockIDByProjectFlockKandangID(ctx context.Context, projectFlockKandangId uint) (uint, error)
 	GetTransferSourceSummary(ctx context.Context, projectFlockKandangId uint) (uint, float64, error)
-	GetManualDepreciationCostByProjectFlockID(ctx context.Context, projectFlockId uint) (float64, error)
 }
 
 type HppRepositoryImpl struct {
@@ -50,32 +48,12 @@ func (r *HppRepositoryImpl) GetProjectFlockKandangIDs(ctx context.Context, proje
 }
 
 func (r *HppRepositoryImpl) GetDocCost(ctx context.Context, projectFlockKandangIDs []uint) (float64, error) {
-	stockablePurchase := fifo.StockableKeyPurchaseItems.String()
-	stockableAdjustment := fifo.StockableKeyAdjustmentIn.String()
-	usableProjectChickin := fifo.UsableKeyProjectChickin.String()
-
 	var total float64
 	err := r.db.WithContext(ctx).
 		Table("project_chickins AS pc").
-		Select(`
+		Select("COALESCE(SUM(pc.usage_qty * COALESCE(pi.price, 0)), 0)").
-			COALESCE(SUM(sa.qty * CASE
+		Joins("JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = pc.id AND sa.stockable_type = ?", fifo.UsableKeyProjectChickin.String(), fifo.StockableKeyPurchaseItems.String()).
-				WHEN sa.stockable_type = ? THEN COALESCE(pi.price, 0)
+		Joins("JOIN purchase_items AS pi ON pi.id = sa.stockable_id").
-				WHEN sa.stockable_type = ? THEN COALESCE(ast.price, 0)
-				ELSE 0
-			END), 0)`,
-			stockablePurchase,
-			stockableAdjustment,
-		).
-		Joins(
-			"JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = pc.id AND (sa.stockable_type = ? OR sa.stockable_type = ?) AND sa.status = ? AND sa.allocation_purpose = ?",
-			usableProjectChickin,
-			stockablePurchase,
-			stockableAdjustment,
-			entity.StockAllocationStatusActive,
-			entity.StockAllocationPurposeTraceChickin,
-		).
-		Joins("LEFT JOIN purchase_items AS pi ON pi.id = sa.stockable_id AND sa.stockable_type = ?", stockablePurchase).
-		Joins("LEFT JOIN adjustment_stocks AS ast ON ast.id = sa.stockable_id AND sa.stockable_type = ?", stockableAdjustment).
 		Where("pc.project_flock_kandang_id IN (?)", projectFlockKandangIDs).
 		Scan(&total).Error
 	if err != nil {
@@ -107,7 +85,7 @@ func (r *HppRepositoryImpl) GetExpedisionCost(ctx context.Context, projectFlockK
 		Joins("JOIN expense_realizations AS er ON er.expense_nonstock_id = en.id").
 		Joins("JOIN flags AS f ON f.flagable_id = en.nonstock_id AND f.flagable_type = ?", entity.FlagableTypeNonstock).
 		Where("en.project_flock_kandang_id IN (?)", projectFlockKandangIDs).
-		// Where("f.name = ?", utils.FlagEkspedisi).
+		Where("f.name = ?", utils.FlagEkspedisi).
 		Scan(&total).Error
 	if err != nil {
 		return 0, err
@@ -122,35 +100,15 @@ func (r *HppRepositoryImpl) GetFeedUsageCost(ctx context.Context, projectFlockKa
 		date = &now
 	}
 
-	stockablePurchase := fifo.StockableKeyPurchaseItems.String()
-	stockableAdjustment := fifo.StockableKeyAdjustmentIn.String()
-	usableRecordingStock := fifo.UsableKeyRecordingStock.String()
-
 	var total float64
 	err := r.db.WithContext(ctx).
 		Table("recordings AS r").
-		Select(`
+		Select("COALESCE(SUM(rs.usage_qty * COALESCE(pi.price, 0)), 0)").
-			COALESCE(SUM(sa.qty * CASE
-				WHEN sa.stockable_type = ? THEN COALESCE(pi.price, 0)
-				WHEN sa.stockable_type = ? THEN COALESCE(ast.price, 0)
-				ELSE 0
-			END), 0)`,
-			stockablePurchase,
-			stockableAdjustment,
-		).
 		Joins("JOIN recording_stocks AS rs ON rs.recording_id = r.id").
 		Joins("JOIN product_warehouses AS pw ON pw.id = rs.product_warehouse_id").
 		Joins("JOIN flags AS f ON f.flagable_id = pw.product_id AND f.flagable_type = ?", entity.FlagableTypeProduct).
-		Joins(
+		Joins("JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = rs.id AND sa.stockable_type = ?", fifo.UsableKeyRecordingStock.String(), fifo.StockableKeyPurchaseItems.String()).
-			"JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = rs.id AND (sa.stockable_type = ? OR sa.stockable_type = ?) AND sa.status = ? AND sa.allocation_purpose = ?",
+		Joins("JOIN purchase_items AS pi ON pi.id = sa.stockable_id").
-			usableRecordingStock,
-			stockablePurchase,
-			stockableAdjustment,
-			entity.StockAllocationStatusActive,
-			entity.StockAllocationPurposeConsume,
-		).
-		Joins("LEFT JOIN purchase_items AS pi ON pi.id = sa.stockable_id AND sa.stockable_type = ?", stockablePurchase).
-		Joins("LEFT JOIN adjustment_stocks AS ast ON ast.id = sa.stockable_id AND sa.stockable_type = ?", stockableAdjustment).
 		Where("r.project_flock_kandangs_id IN (?)", projectFlockKandangIDs).
 		Where("r.record_datetime <= ?", *date).
 		Where("f.name = ?", utils.FlagPakan).
@@ -174,34 +132,15 @@ func (r *HppRepositoryImpl) GetOvkUsageCost(ctx context.Context, projectFlockKan
 		utils.FlagVitamin,
 		utils.FlagKimia,
 	}
-	stockablePurchase := fifo.StockableKeyPurchaseItems.String()
-	stockableAdjustment := fifo.StockableKeyAdjustmentIn.String()
-	usableRecordingStock := fifo.UsableKeyRecordingStock.String()
 
 	var total float64
 	err := r.db.WithContext(ctx).
 		Table("recordings AS r").
-		Select(`
+		Select("COALESCE(SUM(rs.usage_qty * COALESCE(pi.price, 0)), 0)").
-			COALESCE(SUM(sa.qty * CASE
-				WHEN sa.stockable_type = ? THEN COALESCE(pi.price, 0)
-				WHEN sa.stockable_type = ? THEN COALESCE(ast.price, 0)
-				ELSE 0
-			END), 0)`,
-			stockablePurchase,
-			stockableAdjustment,
-		).
 		Joins("JOIN recording_stocks AS rs ON rs.recording_id = r.id").
 		Joins("JOIN product_warehouses AS pw ON pw.id = rs.product_warehouse_id").
-		Joins(
+		Joins("JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = rs.id AND sa.stockable_type = ?", fifo.UsableKeyRecordingStock.String(), fifo.StockableKeyPurchaseItems.String()).
-			"JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = rs.id AND (sa.stockable_type = ? OR sa.stockable_type = ?) AND sa.status = ? AND sa.allocation_purpose = ?",
+		Joins("JOIN purchase_items AS pi ON pi.id = sa.stockable_id").
-			usableRecordingStock,
-			stockablePurchase,
-			stockableAdjustment,
-			entity.StockAllocationStatusActive,
-			entity.StockAllocationPurposeConsume,
-		).
-		Joins("LEFT JOIN purchase_items AS pi ON pi.id = sa.stockable_id AND sa.stockable_type = ?", stockablePurchase).
-		Joins("LEFT JOIN adjustment_stocks AS ast ON ast.id = sa.stockable_id AND sa.stockable_type = ?", stockableAdjustment).
 		Where("r.project_flock_kandangs_id IN (?)", projectFlockKandangIDs).
 		Where("r.record_datetime <= ?", *date).
 		Where("EXISTS (SELECT 1 FROM flags f WHERE f.flagable_id = pw.product_id AND f.flagable_type = ? AND f.name IN ?)", entity.FlagableTypeProduct, flags).
@@ -230,28 +169,22 @@ func (r *HppRepositoryImpl) GetTotalPopulation(ctx context.Context, projectFlock
 func (r *HppRepositoryImpl) GetPulletCost(ctx context.Context, projectFlockKandangId uint) (float64, error) {
 	stockablePurchase := fifo.StockableKeyPurchaseItems.String()
 	stockableTransferIn := fifo.StockableKeyStockTransferIn.String()
-	stockableAdjustment := fifo.StockableKeyAdjustmentIn.String()
 	usableProjectChickin := fifo.UsableKeyProjectChickin.String()
 
 	var total float64
 	err := r.db.WithContext(ctx).
 		Table("project_chickins AS pc").
 		Select(`
-				COALESCE(SUM(sa.qty * CASE
+			COALESCE(SUM(pc.usage_qty * CASE
-					WHEN sa.stockable_type = ? THEN COALESCE(pi.price, 0)
+				WHEN sa.stockable_type = ? THEN COALESCE(pi.price, 0)
-					WHEN sa.stockable_type = ? THEN COALESCE(tpi.price, 0)
+				WHEN sa.stockable_type = ? THEN COALESCE(tpi.price, 0)
-					WHEN sa.stockable_type = ? THEN COALESCE(ast.price, 0)
+				ELSE 0
-					ELSE 0
+			END), 0)`,
-				END), 0)`,
+			stockablePurchase, stockableTransferIn).
-			stockablePurchase,
+		Joins("JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = pc.id", usableProjectChickin).
-			stockableTransferIn,
-			stockableAdjustment,
-		).
-		Joins("JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = pc.id AND sa.status = ? AND sa.allocation_purpose = ?", usableProjectChickin, entity.StockAllocationStatusActive, entity.StockAllocationPurposeTraceChickin).
 		Joins("LEFT JOIN purchase_items AS pi ON pi.id = sa.stockable_id AND sa.stockable_type = ?", stockablePurchase).
-		Joins("LEFT JOIN stock_allocations AS tsa ON tsa.usable_type = ? AND tsa.usable_id = sa.stockable_id AND sa.stockable_type = ? AND tsa.stockable_type = ? AND tsa.status = ? AND tsa.allocation_purpose = ?", stockableTransferIn, stockableTransferIn, stockablePurchase, entity.StockAllocationStatusActive, entity.StockAllocationPurposeConsume).
+		Joins("LEFT JOIN stock_allocations AS tsa ON tsa.usable_type = ? AND tsa.usable_id = sa.stockable_id AND sa.stockable_type = ? AND tsa.stockable_type = ?", stockableTransferIn, stockableTransferIn, stockablePurchase).
 		Joins("LEFT JOIN purchase_items AS tpi ON tpi.id = tsa.stockable_id").
-		Joins("LEFT JOIN adjustment_stocks AS ast ON ast.id = sa.stockable_id AND sa.stockable_type = ?", stockableAdjustment).
 		Where("pc.project_flock_kandang_id = ?", projectFlockKandangId).
 		Scan(&total).Error
 	if err != nil {
@@ -282,33 +215,6 @@ func (r *HppRepositoryImpl) GetEggProduksiPiecesAndWeightKgByProjectFlockKandang
 		return 0, 0, err
 	}
 
-	var adjustmentTotalWeight float64
-	adjustmentSubQuery := r.db.WithContext(ctx).
-		Table("recordings AS r").
-		Select("DISTINCT ast.id AS adjustment_id, ast.price AS price").
-		Joins("JOIN recording_eggs AS re ON re.recording_id = r.id").
-		Joins("JOIN stock_transfer_details AS std ON std.dest_product_warehouse_id = re.product_warehouse_id").
-		Joins(
-			"JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = std.id AND sa.stockable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?",
-			fifo.UsableKeyStockTransferOut.String(),
-			fifo.StockableKeyAdjustmentIn.String(),
-			entity.StockAllocationStatusActive,
-			entity.StockAllocationPurposeConsume,
-		).
-		Joins("JOIN adjustment_stocks AS ast ON ast.id = sa.stockable_id AND ast.product_warehouse_id = std.source_product_warehouse_id").
-		Where("r.project_flock_kandangs_id IN (?)", projectFlockKandangIDs).
-		Where("r.record_datetime <= ?", *date)
-
-	err = r.db.WithContext(ctx).
-		Table("(?) AS adjustment_sources", adjustmentSubQuery).
-		Select("COALESCE(SUM(adjustment_sources.price), 0)").
-		Scan(&adjustmentTotalWeight).Error
-	if err != nil {
-		return 0, 0, err
-	}
-
-	totals.TotalWeightKg += adjustmentTotalWeight
-
 	return totals.TotalPieces, totals.TotalWeightKg, nil
 }
 
@@ -339,11 +245,9 @@ func (r *HppRepositoryImpl) GetEggTerjualPiecesAndWeightKgByProjectFlockKandangI
 		`).
 		Joins("JOIN recording_eggs re ON re.recording_id = r.id").
 		Joins(
-			"JOIN stock_allocations sa ON sa.stockable_type = ? AND sa.stockable_id = re.id AND sa.usable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?",
+			"JOIN stock_allocations sa ON sa.stockable_type = ? AND sa.stockable_id = re.id AND sa.usable_type = ?",
 			fifo.StockableKeyRecordingEgg.String(),
 			fifo.UsableKeyMarketingDelivery.String(),
-			entity.StockAllocationStatusActive,
-			entity.StockAllocationPurposeConsume,
 		).
 		Joins("JOIN marketing_delivery_products mdp ON mdp.id = sa.usable_id").
 		Where("r.project_flock_kandangs_id IN (?)", projectFlockKandangIDs).
@@ -393,9 +297,6 @@ func (r *HppRepositoryImpl) GetTransferSourceSummary(ctx context.Context, projec
 		Table("laying_transfer_targets AS ltt").
 		Select("lt.from_project_flock_id AS project_flock_id, COALESCE(SUM(ltt.total_qty), 0) AS total_qty").
 		Joins("JOIN laying_transfers AS lt ON lt.id = ltt.laying_transfer_id").
-		Where("lt.deleted_at IS NULL").
-		Where("ltt.deleted_at IS NULL").
-		Where("lt.executed_at IS NOT NULL").
 		Where("ltt.target_project_flock_kandang_id = ?", projectFlockKandangId).
 		Group("lt.from_project_flock_id").
 		Scan(&summary).Error
@@ -405,25 +306,3 @@ func (r *HppRepositoryImpl) GetTransferSourceSummary(ctx context.Context, projec
 
 	return summary.ProjectFlockID, summary.TotalQty, nil
 }
-
-func (r *HppRepositoryImpl) GetManualDepreciationCostByProjectFlockID(ctx context.Context, projectFlockId uint) (float64, error) {
-	type row struct {
-		TotalCost float64
-	}
-
-	var selected row
-	err := r.db.WithContext(ctx).
-		Table("farm_depreciation_manual_inputs").
-		Select("total_cost").
-		Where("project_flock_id = ?", projectFlockId).
-		Limit(1).
-		Take(&selected).Error
-	if errors.Is(err, gorm.ErrRecordNotFound) {
-		return 0, nil
-	}
-	if err != nil {
-		return 0, err
-	}
-
-	return selected.TotalCost, nil
-}

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

@@ -1,248 +0,0 @@
-package repository
-
-import (
-	"context"
-	"math"
-	"testing"
-	"time"
-
-	"github.com/glebarez/sqlite"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
-	"gorm.io/gorm"
-)
-
-func TestHppV2RepositoryGetEggProduksiIncludesTransferredAdjustmentStock(t *testing.T) {
-	db := setupHppV2RepositoryTestDB(t)
-
-	mustExecHppV2(t, db,
-		`INSERT INTO recordings (id, project_flock_kandangs_id, record_datetime) VALUES (1, 101, '2026-04-19 10:00:00')`,
-		`INSERT INTO recording_eggs (id, recording_id, product_warehouse_id, qty, weight, project_flock_kandang_id) VALUES (1, 1, 401, 80, 8, 101)`,
-		`INSERT INTO stock_transfers (id, transfer_date) VALUES (1, '2026-04-18 08:00:00')`,
-		`INSERT INTO stock_transfer_details (id, stock_transfer_id, source_product_warehouse_id, dest_product_warehouse_id) VALUES (1, 1, 301, 401)`,
-		`INSERT INTO stock_allocations (id, usable_type, usable_id, stockable_type, stockable_id, status, allocation_purpose) VALUES (1, 'STOCK_TRANSFER_OUT', 1, 'ADJUSTMENT_IN', 501, 'ACTIVE', 'CONSUME')`,
-		`INSERT INTO adjustment_stocks (id, product_warehouse_id, total_qty, price, created_at) VALUES (501, 301, 20, 2.5, '2026-04-18 07:30:00')`,
-	)
-
-	repo := &HppV2RepositoryImpl{db: db}
-	endDate := mustJakartaTime(t, "2026-04-20 00:00:00")
-
-	totalPieces, totalWeightKg, err := repo.GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(context.Background(), []uint{101}, &endDate)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	assertFloatEquals(t, totalPieces, 100)
-	assertFloatEquals(t, totalWeightKg, 10.5)
-}
-
-func TestHppV2RepositoryGetEggTerjualUsesEndDateForSameDayFarmSales(t *testing.T) {
-	db := setupHppV2RepositoryTestDB(t)
-
-	mustExecHppV2(t, db,
-		`INSERT INTO kandangs (id, location_id) VALUES (1, 10), (2, 10)`,
-		`INSERT INTO project_flock_kandangs (id, kandang_id) VALUES (101, 1), (102, 2)`,
-		`INSERT INTO warehouses (id, type, location_id) VALUES (201, 'LOKASI', 10)`,
-		`INSERT INTO product_warehouses (id, warehouse_id, product_id, project_flock_kandang_id) VALUES (301, 201, 900, NULL)`,
-		`INSERT INTO flags (id, flagable_type, flagable_id, name) VALUES (1, 'products', 900, 'TELUR')`,
-		`INSERT INTO recordings (id, project_flock_kandangs_id, record_datetime, deleted_at) VALUES (1, 101, '2026-04-19 08:00:00', NULL), (2, 102, '2026-04-19 09:00:00', NULL)`,
-		`INSERT INTO recording_eggs (id, recording_id, product_warehouse_id, qty, weight, project_flock_kandang_id) VALUES (1, 1, 301, 60, 6, 101), (2, 2, 301, 40, 4, 102)`,
-		`INSERT INTO marketing_products (id, product_warehouse_id) VALUES (401, 301)`,
-		`INSERT INTO marketing_delivery_products (id, marketing_product_id, usage_qty, total_weight, delivery_date) VALUES (501, 401, 50, 5, '2026-04-19 12:00:00')`,
-	)
-
-	repo := &HppV2RepositoryImpl{db: db}
-	startDate := mustJakartaTime(t, "2026-04-19 00:00:00")
-	endDate := mustJakartaTime(t, "2026-04-20 00:00:00")
-
-	totalPieces, totalWeightKg, err := repo.GetEggTerjualPiecesAndWeightKgByProjectFlockKandangIds(context.Background(), []uint{101}, &startDate, &endDate)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	assertFloatEquals(t, totalPieces, 30)
-	assertFloatEquals(t, totalWeightKg, 3)
-}
-
-func TestHppV2RepositoryGetEggTerjualProratesHistoricalFarmSalesFromAdjustments(t *testing.T) {
-	db := setupHppV2RepositoryTestDB(t)
-
-	mustExecHppV2(t, db,
-		`INSERT INTO kandangs (id, location_id) VALUES (1, 10), (2, 10)`,
-		`INSERT INTO project_flock_kandangs (id, kandang_id) VALUES (101, 1), (102, 2)`,
-		`INSERT INTO warehouses (id, type, location_id) VALUES (201, 'LOKASI', 10), (211, 'KANDANG', 10), (212, 'KANDANG', 10)`,
-		`INSERT INTO product_warehouses (id, warehouse_id, product_id, project_flock_kandang_id) VALUES (301, 201, 900, NULL), (311, 211, 900, 101), (312, 212, 900, 102)`,
-		`INSERT INTO flags (id, flagable_type, flagable_id, name) VALUES (1, 'products', 900, 'TELUR')`,
-		`INSERT INTO stock_transfers (id, transfer_date) VALUES (1, '2026-04-18 08:00:00'), (2, '2026-04-18 08:15:00')`,
-		`INSERT INTO stock_transfer_details (id, stock_transfer_id, source_product_warehouse_id, dest_product_warehouse_id) VALUES (1, 1, 311, 301), (2, 2, 312, 301)`,
-		`INSERT INTO adjustment_stocks (id, product_warehouse_id, usage_qty, price, function_code, transaction_type, created_at) VALUES
-			(801, 311, 70, 7, 'RECORDING_EGG_IN', 'RECORDING', '2026-04-18 07:00:00'),
-			(802, 312, 30, 3, 'RECORDING_EGG_IN', 'RECORDING', '2026-04-18 07:30:00')`,
-		`INSERT INTO marketing_products (id, product_warehouse_id) VALUES (401, 301)`,
-		`INSERT INTO marketing_delivery_products (id, marketing_product_id, usage_qty, total_weight, delivery_date) VALUES (501, 401, 20, 2, '2026-04-19 12:00:00')`,
-	)
-
-	repo := &HppV2RepositoryImpl{db: db}
-	startDate := mustJakartaTime(t, "2026-04-19 00:00:00")
-	endDate := mustJakartaTime(t, "2026-04-20 00:00:00")
-
-	totalPieces, totalWeightKg, err := repo.GetEggTerjualPiecesAndWeightKgByProjectFlockKandangIds(context.Background(), []uint{101}, &startDate, &endDate)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	assertFloatEquals(t, totalPieces, 14)
-	assertFloatEquals(t, totalWeightKg, 1.4)
-}
-
-func setupHppV2RepositoryTestDB(t *testing.T) *gorm.DB {
-	t.Helper()
-
-	db, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=private"), &gorm.Config{})
-	if err != nil {
-		t.Fatalf("failed opening sqlite db: %v", err)
-	}
-
-	mustExecHppV2(t, db,
-		`CREATE TABLE recordings (
-			id INTEGER PRIMARY KEY,
-			project_flock_kandangs_id INTEGER NULL,
-			record_datetime DATETIME NULL,
-			deleted_at DATETIME NULL
-		)`,
-		`CREATE TABLE recording_eggs (
-			id INTEGER PRIMARY KEY,
-			recording_id INTEGER NULL,
-			product_warehouse_id INTEGER NULL,
-			qty NUMERIC(15,3) NULL,
-			weight NUMERIC(15,3) NULL,
-			project_flock_kandang_id INTEGER NULL
-		)`,
-		`CREATE TABLE stock_transfers (
-			id INTEGER PRIMARY KEY,
-			transfer_date DATETIME NULL
-		)`,
-		`CREATE TABLE stock_transfer_details (
-			id INTEGER PRIMARY KEY,
-			stock_transfer_id INTEGER NULL,
-			source_product_warehouse_id INTEGER NULL,
-			dest_product_warehouse_id INTEGER NULL
-		)`,
-		`CREATE TABLE stock_allocations (
-			id INTEGER PRIMARY KEY,
-			usable_type TEXT NULL,
-			usable_id INTEGER NULL,
-			stockable_type TEXT NULL,
-			stockable_id INTEGER NULL,
-			status TEXT NULL,
-			allocation_purpose TEXT NULL,
-			qty NUMERIC(15,3) NULL
-		)`,
-		`CREATE TABLE adjustment_stocks (
-			id INTEGER PRIMARY KEY,
-			product_warehouse_id INTEGER NULL,
-			total_qty NUMERIC(15,3) NULL,
-			usage_qty NUMERIC(15,3) NULL,
-			price NUMERIC(15,3) NULL,
-			grand_total NUMERIC(15,3) NULL,
-			function_code TEXT NULL,
-			transaction_type TEXT NULL,
-			created_at DATETIME NULL
-		)`,
-		`CREATE TABLE kandangs (
-			id INTEGER PRIMARY KEY,
-			location_id INTEGER NULL
-		)`,
-		`CREATE TABLE project_flock_kandangs (
-			id INTEGER PRIMARY KEY,
-			kandang_id INTEGER NULL,
-			project_flock_id INTEGER NULL
-		)`,
-		`CREATE TABLE warehouses (
-			id INTEGER PRIMARY KEY,
-			type TEXT NULL,
-			location_id INTEGER NULL
-		)`,
-		`CREATE TABLE product_warehouses (
-			id INTEGER PRIMARY KEY,
-			warehouse_id INTEGER NULL,
-			product_id INTEGER NULL,
-			project_flock_kandang_id INTEGER NULL
-		)`,
-		`CREATE TABLE marketing_products (
-			id INTEGER PRIMARY KEY,
-			product_warehouse_id INTEGER NULL
-		)`,
-		`CREATE TABLE marketing_delivery_products (
-			id INTEGER PRIMARY KEY,
-			marketing_product_id INTEGER NULL,
-			usage_qty NUMERIC(15,3) NULL,
-			total_weight NUMERIC(15,3) NULL,
-			delivery_date DATETIME NULL
-		)`,
-		`CREATE TABLE flags (
-			id INTEGER PRIMARY KEY,
-			flagable_type TEXT NULL,
-			flagable_id INTEGER NULL,
-			name TEXT NULL
-		)`,
-	)
-
-	return db
-}
-
-func mustExecHppV2(t *testing.T, db *gorm.DB, statements ...string) {
-	t.Helper()
-
-	for _, statement := range statements {
-		if err := db.Exec(statement).Error; err != nil {
-			t.Fatalf("failed executing statement %q: %v", statement, err)
-		}
-	}
-}
-
-func mustJakartaTime(t *testing.T, raw string) time.Time {
-	t.Helper()
-
-	location, err := time.LoadLocation("Asia/Jakarta")
-	if err != nil {
-		t.Fatalf("failed loading timezone: %v", err)
-	}
-
-	value, err := time.ParseInLocation("2006-01-02 15:04:05", raw, location)
-	if err != nil {
-		t.Fatalf("failed parsing time %q: %v", raw, err)
-	}
-
-	return value
-}
-
-func assertFloatEquals(t *testing.T, got float64, want float64) {
-	t.Helper()
-
-	if math.Abs(got-want) > 0.000001 {
-		t.Fatalf("expected %.6f, got %.6f", want, got)
-	}
-}
-
-func TestHppV2RepositoryConstantsStayAlignedWithProductionQueries(t *testing.T) {
-	if fifo.UsableKeyStockTransferOut.String() != "STOCK_TRANSFER_OUT" {
-		t.Fatalf("unexpected stock transfer usable key: %s", fifo.UsableKeyStockTransferOut.String())
-	}
-	if fifo.StockableKeyAdjustmentIn.String() != "ADJUSTMENT_IN" {
-		t.Fatalf("unexpected adjustment stockable key: %s", fifo.StockableKeyAdjustmentIn.String())
-	}
-	if entity.StockAllocationStatusActive != "ACTIVE" {
-		t.Fatalf("unexpected active stock allocation status: %s", entity.StockAllocationStatusActive)
-	}
-	if entity.StockAllocationPurposeConsume != "CONSUME" {
-		t.Fatalf("unexpected consume stock allocation purpose: %s", entity.StockAllocationPurposeConsume)
-	}
-	if string(utils.AdjustmentTransactionSubtypeRecordingEggIn) != "RECORDING_EGG_IN" {
-		t.Fatalf("unexpected adjustment function code: %s", utils.AdjustmentTransactionSubtypeRecordingEggIn)
-	}
-	if string(utils.AdjustmentTransactionTypeRecording) != "RECORDING" {
-		t.Fatalf("unexpected adjustment transaction type: %s", utils.AdjustmentTransactionTypeRecording)
-	}
-}

internal/common/repository/common.stock_allocation.repository.go

@@ -33,7 +33,7 @@ func (r *StockAllocationRepositoryImpl) FindActiveByUsable(
 	var allocations []entity.StockAllocation
 
 	q := r.DB().WithContext(ctx).
-		Where("usable_type = ? AND usable_id = ? AND status = ? AND allocation_purpose = ?", usableType, usableID, entity.StockAllocationStatusActive, entity.StockAllocationPurposeConsume)
+		Where("usable_type = ? AND usable_id = ? AND status = ?", usableType, usableID, entity.StockAllocationStatusActive)
 
 	if modifier != nil {
 		q = modifier(q)
@@ -70,7 +70,7 @@ func (r *StockAllocationRepositoryImpl) ReleaseByUsable(
 
 	q := baseDB.WithContext(ctx).
 		Model(&entity.StockAllocation{}).
-		Where("usable_type = ? AND usable_id = ? AND status = ? AND allocation_purpose = ?", usableType, usableID, entity.StockAllocationStatusActive, entity.StockAllocationPurposeConsume)
+		Where("usable_type = ? AND usable_id = ? AND status = ?", usableType, usableID, entity.StockAllocationStatusActive)
 
 	return q.Updates(updates).Error
 }

internal/common/repository/marketing_delivery_attribution.repository.go

@@ -1,224 +0,0 @@
-package repository
-
-import (
-	"fmt"
-
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
-	"gorm.io/gorm"
-)
-
-type MarketingDeliveryAttributionRow struct {
-	MarketingDeliveryProductID uint    `gorm:"column:marketing_delivery_product_id"`
-	ProjectFlockKandangID      uint    `gorm:"column:project_flock_kandang_id"`
-	ProjectFlockID             uint    `gorm:"column:project_flock_id"`
-	ProjectFlockCategory       string  `gorm:"column:project_flock_category"`
-	AllocatedQty               float64 `gorm:"column:allocated_qty"`
-}
-
-func MarketingDeliveryAttributionRowsQuery(db *gorm.DB) *gorm.DB {
-	sql := `
-WITH mapped AS (
-	SELECT
-		sa.usable_id AS marketing_delivery_product_id,
-		pc.project_flock_kandang_id AS project_flock_kandang_id,
-		pfk.project_flock_id AS project_flock_id,
-		pf.category AS project_flock_category,
-		SUM(sa.qty) AS allocated_qty
-	FROM stock_allocations sa
-	JOIN project_flock_populations pfp
-		ON pfp.id = sa.stockable_id
-		AND sa.stockable_type = ?
-	JOIN project_chickins pc ON pc.id = pfp.project_chickin_id
-	JOIN project_flock_kandangs pfk ON pfk.id = pc.project_flock_kandang_id
-	JOIN project_flocks pf ON pf.id = pfk.project_flock_id
-	WHERE sa.usable_type = ?
-		AND sa.status = ?
-		AND sa.allocation_purpose = ?
-	GROUP BY sa.usable_id, pc.project_flock_kandang_id, pfk.project_flock_id, pf.category
-
-	UNION ALL
-
-	SELECT
-		sa.usable_id AS marketing_delivery_product_id,
-		COALESCE(re.project_flock_kandang_id, r.project_flock_kandangs_id) AS project_flock_kandang_id,
-		pfk.project_flock_id AS project_flock_id,
-		pf.category AS project_flock_category,
-		SUM(sa.qty) AS allocated_qty
-	FROM stock_allocations sa
-	JOIN recording_eggs re
-		ON re.id = sa.stockable_id
-		AND sa.stockable_type = ?
-	LEFT JOIN recordings r ON r.id = re.recording_id
-	JOIN project_flock_kandangs pfk ON pfk.id = COALESCE(re.project_flock_kandang_id, r.project_flock_kandangs_id)
-	JOIN project_flocks pf ON pf.id = pfk.project_flock_id
-	WHERE sa.usable_type = ?
-		AND sa.status = ?
-		AND sa.allocation_purpose = ?
-	GROUP BY sa.usable_id, COALESCE(re.project_flock_kandang_id, r.project_flock_kandangs_id), pfk.project_flock_id, pf.category
-
-	UNION ALL
-
-	SELECT
-		sa.usable_id AS marketing_delivery_product_id,
-		COALESCE(rd.source_project_flock_kandang_id, r.project_flock_kandangs_id) AS project_flock_kandang_id,
-		pfk.project_flock_id AS project_flock_id,
-		pf.category AS project_flock_category,
-		SUM(sa.qty) AS allocated_qty
-	FROM stock_allocations sa
-	JOIN recording_depletions rd
-		ON rd.id = sa.stockable_id
-		AND sa.stockable_type = ?
-	LEFT JOIN recordings r ON r.id = rd.recording_id
-	JOIN project_flock_kandangs pfk ON pfk.id = COALESCE(rd.source_project_flock_kandang_id, r.project_flock_kandangs_id)
-	JOIN project_flocks pf ON pf.id = pfk.project_flock_id
-	WHERE sa.usable_type = ?
-		AND sa.status = ?
-		AND sa.allocation_purpose = ?
-	GROUP BY sa.usable_id, COALESCE(rd.source_project_flock_kandang_id, r.project_flock_kandangs_id), pfk.project_flock_id, pf.category
-
-	UNION ALL
-
-	SELECT
-		sa.usable_id AS marketing_delivery_product_id,
-		pi.project_flock_kandang_id AS project_flock_kandang_id,
-		pfk.project_flock_id AS project_flock_id,
-		pf.category AS project_flock_category,
-		SUM(sa.qty) AS allocated_qty
-	FROM stock_allocations sa
-	JOIN purchase_items pi
-		ON pi.id = sa.stockable_id
-		AND sa.stockable_type = ?
-	JOIN project_flock_kandangs pfk ON pfk.id = pi.project_flock_kandang_id
-	JOIN project_flocks pf ON pf.id = pfk.project_flock_id
-	WHERE sa.usable_type = ?
-		AND sa.status = ?
-		AND sa.allocation_purpose = ?
-		AND pi.project_flock_kandang_id IS NOT NULL
-	GROUP BY sa.usable_id, pi.project_flock_kandang_id, pfk.project_flock_id, pf.category
-
-	UNION ALL
-
-	SELECT
-		sa.usable_id AS marketing_delivery_product_id,
-		source_pw.project_flock_kandang_id AS project_flock_kandang_id,
-		pfk.project_flock_id AS project_flock_id,
-		pf.category AS project_flock_category,
-		SUM(sa.qty) AS allocated_qty
-	FROM stock_allocations sa
-	JOIN stock_transfer_details std
-		ON std.id = sa.stockable_id
-		AND sa.stockable_type = ?
-	JOIN product_warehouses source_pw ON source_pw.id = std.source_product_warehouse_id
-	JOIN project_flock_kandangs pfk ON pfk.id = source_pw.project_flock_kandang_id
-	JOIN project_flocks pf ON pf.id = pfk.project_flock_id
-	WHERE sa.usable_type = ?
-		AND sa.status = ?
-		AND sa.allocation_purpose = ?
-		AND source_pw.project_flock_kandang_id IS NOT NULL
-	GROUP BY sa.usable_id, source_pw.project_flock_kandang_id, pfk.project_flock_id, pf.category
-
-	UNION ALL
-
-	SELECT
-		sa.usable_id AS marketing_delivery_product_id,
-		ltt.target_project_flock_kandang_id AS project_flock_kandang_id,
-		pfk.project_flock_id AS project_flock_id,
-		pf.category AS project_flock_category,
-		SUM(sa.qty) AS allocated_qty
-	FROM stock_allocations sa
-	JOIN laying_transfer_targets ltt
-		ON ltt.id = sa.stockable_id
-		AND sa.stockable_type = ?
-	JOIN project_flock_kandangs pfk ON pfk.id = ltt.target_project_flock_kandang_id
-	JOIN project_flocks pf ON pf.id = pfk.project_flock_id
-	WHERE sa.usable_type = ?
-		AND sa.status = ?
-		AND sa.allocation_purpose = ?
-	GROUP BY sa.usable_id, ltt.target_project_flock_kandang_id, pfk.project_flock_id, pf.category
-)
-SELECT
-	src.marketing_delivery_product_id,
-	src.project_flock_kandang_id,
-	src.project_flock_id,
-	src.project_flock_category,
-	SUM(src.allocated_qty) AS allocated_qty
-FROM (
-	SELECT
-		mapped.marketing_delivery_product_id,
-		mapped.project_flock_kandang_id,
-		mapped.project_flock_id,
-		mapped.project_flock_category,
-		mapped.allocated_qty
-	FROM mapped
-
-	UNION ALL
-
-	SELECT
-		mdp.id AS marketing_delivery_product_id,
-		pw.project_flock_kandang_id AS project_flock_kandang_id,
-		pfk.project_flock_id AS project_flock_id,
-		pf.category AS project_flock_category,
-		COALESCE(mdp.usage_qty, 0) AS allocated_qty
-	FROM marketing_delivery_products mdp
-	JOIN marketing_products mp ON mp.id = mdp.marketing_product_id
-	JOIN product_warehouses pw ON pw.id = mp.product_warehouse_id
-	JOIN project_flock_kandangs pfk ON pfk.id = pw.project_flock_kandang_id
-	JOIN project_flocks pf ON pf.id = pfk.project_flock_id
-	LEFT JOIN mapped ON mapped.marketing_delivery_product_id = mdp.id
-	WHERE mapped.marketing_delivery_product_id IS NULL
-		AND pw.project_flock_kandang_id IS NOT NULL
-		AND COALESCE(mdp.usage_qty, 0) > 0
-) src
-GROUP BY
-	src.marketing_delivery_product_id,
-	src.project_flock_kandang_id,
-	src.project_flock_id,
-	src.project_flock_category
-`
-
-	return db.Raw(
-		sql,
-		fifo.StockableKeyProjectFlockPopulation.String(),
-		fifo.UsableKeyMarketingDelivery.String(),
-		entity.StockAllocationStatusActive,
-		entity.StockAllocationPurposeConsume,
-		fifo.StockableKeyRecordingEgg.String(),
-		fifo.UsableKeyMarketingDelivery.String(),
-		entity.StockAllocationStatusActive,
-		entity.StockAllocationPurposeConsume,
-		fifo.StockableKeyRecordingDepletion.String(),
-		fifo.UsableKeyMarketingDelivery.String(),
-		entity.StockAllocationStatusActive,
-		entity.StockAllocationPurposeConsume,
-		fifo.StockableKeyPurchaseItems.String(),
-		fifo.UsableKeyMarketingDelivery.String(),
-		entity.StockAllocationStatusActive,
-		entity.StockAllocationPurposeConsume,
-		fifo.StockableKeyStockTransferIn.String(),
-		fifo.UsableKeyMarketingDelivery.String(),
-		entity.StockAllocationStatusActive,
-		entity.StockAllocationPurposeConsume,
-		fifo.StockableKeyTransferToLayingIn.String(),
-		fifo.UsableKeyMarketingDelivery.String(),
-		entity.StockAllocationStatusActive,
-		entity.StockAllocationPurposeConsume,
-	)
-}
-
-func MarketingDeliverySingleAttributionQuery(db *gorm.DB) *gorm.DB {
-	return db.
-		Table("(?) AS mda", MarketingDeliveryAttributionRowsQuery(db)).
-		Select(`
-			mda.marketing_delivery_product_id,
-			CASE
-				WHEN COUNT(DISTINCT mda.project_flock_kandang_id) = 1 THEN MIN(mda.project_flock_kandang_id)
-				ELSE NULL
-			END AS attributed_project_flock_kandang_id
-		`).
-		Group("mda.marketing_delivery_product_id")
-}
-
-func MarketingDeliveryAttributionFilterSQL(column string) string {
-	return fmt.Sprintf("EXISTS (SELECT 1 FROM (?) AS mda WHERE mda.marketing_delivery_product_id = %s)", column)
-}

internal/common/repository/marketing_delivery_attribution.repository_test.go

@@ -1,147 +0,0 @@
-package repository
-
-import (
-	"testing"
-
-	"github.com/glebarez/sqlite"
-	"gorm.io/gorm"
-)
-
-func TestMarketingDeliveryAttributionRowsQueryIncludesMappedAndFallbackRows(t *testing.T) {
-	db := setupMarketingAttributionTestDB(t)
-
-	statements := []string{
-		`INSERT INTO project_flocks (id, category) VALUES (1, 'LAYING')`,
-		`INSERT INTO project_flock_kandangs (id, project_flock_id) VALUES (101, 1), (102, 1)`,
-		`INSERT INTO project_chickins (id, project_flock_kandang_id) VALUES (201, 101), (202, 102)`,
-		`INSERT INTO project_flock_populations (id, project_chickin_id) VALUES (301, 201), (302, 202)`,
-		`INSERT INTO product_warehouses (id, project_flock_kandang_id) VALUES (401, NULL), (402, 101)`,
-		`INSERT INTO marketing_products (id, product_warehouse_id) VALUES (501, 401), (502, 402), (503, 401)`,
-		`INSERT INTO marketing_delivery_products (id, marketing_product_id, usage_qty) VALUES (601, 501, 100), (602, 502, 25), (603, 503, 12)`,
-		`INSERT INTO recording_eggs (id, recording_id, project_flock_kandang_id) VALUES (701, NULL, 101)`,
-		`INSERT INTO stock_allocations (id, product_warehouse_id, stockable_type, stockable_id, usable_type, usable_id, qty, status, allocation_purpose) VALUES
-			(1, 401, 'PROJECT_FLOCK_POPULATION', 301, 'MARKETING_DELIVERY', 601, 60, 'ACTIVE', 'CONSUME'),
-			(2, 401, 'PROJECT_FLOCK_POPULATION', 302, 'MARKETING_DELIVERY', 601, 40, 'ACTIVE', 'CONSUME'),
-			(3, 401, 'RECORDING_EGG', 701, 'MARKETING_DELIVERY', 603, 12, 'ACTIVE', 'CONSUME')`,
-	}
-	for _, stmt := range statements {
-		if err := db.Exec(stmt).Error; err != nil {
-			t.Fatalf("failed seeding fixtures: %v", err)
-		}
-	}
-
-	var rows []MarketingDeliveryAttributionRow
-	if err := db.Table("(?) AS mda", MarketingDeliveryAttributionRowsQuery(db)).
-		Order("mda.marketing_delivery_product_id ASC, mda.project_flock_kandang_id ASC").
-		Scan(&rows).Error; err != nil {
-		t.Fatalf("failed scanning attribution rows: %v", err)
-	}
-
-	if len(rows) != 4 {
-		t.Fatalf("expected 4 attribution rows, got %d", len(rows))
-	}
-	if rows[0].MarketingDeliveryProductID != 601 || rows[0].ProjectFlockKandangID != 101 || rows[0].AllocatedQty != 60 {
-		t.Fatalf("unexpected first attribution row: %+v", rows[0])
-	}
-	if rows[1].MarketingDeliveryProductID != 601 || rows[1].ProjectFlockKandangID != 102 || rows[1].AllocatedQty != 40 {
-		t.Fatalf("unexpected second attribution row: %+v", rows[1])
-	}
-	if rows[2].MarketingDeliveryProductID != 602 || rows[2].ProjectFlockKandangID != 101 || rows[2].AllocatedQty != 25 {
-		t.Fatalf("unexpected fallback attribution row: %+v", rows[2])
-	}
-	if rows[3].MarketingDeliveryProductID != 603 || rows[3].ProjectFlockKandangID != 101 || rows[3].AllocatedQty != 12 {
-		t.Fatalf("unexpected egg attribution row: %+v", rows[3])
-	}
-}
-
-func TestMarketingDeliverySingleAttributionQueryOnlyReturnsSingleSourceRows(t *testing.T) {
-	db := setupMarketingAttributionTestDB(t)
-
-	statements := []string{
-		`INSERT INTO project_flocks (id, category) VALUES (1, 'LAYING')`,
-		`INSERT INTO project_flock_kandangs (id, project_flock_id) VALUES (101, 1), (102, 1)`,
-		`INSERT INTO project_chickins (id, project_flock_kandang_id) VALUES (201, 101), (202, 102)`,
-		`INSERT INTO project_flock_populations (id, project_chickin_id) VALUES (301, 201), (302, 202)`,
-		`INSERT INTO product_warehouses (id, project_flock_kandang_id) VALUES (401, NULL), (402, 101)`,
-		`INSERT INTO marketing_products (id, product_warehouse_id) VALUES (501, 401), (502, 402), (503, 401)`,
-		`INSERT INTO marketing_delivery_products (id, marketing_product_id, usage_qty) VALUES (601, 501, 100), (602, 502, 25), (603, 503, 12)`,
-		`INSERT INTO recording_eggs (id, recording_id, project_flock_kandang_id) VALUES (701, NULL, 101)`,
-		`INSERT INTO stock_allocations (id, product_warehouse_id, stockable_type, stockable_id, usable_type, usable_id, qty, status, allocation_purpose) VALUES
-			(1, 401, 'PROJECT_FLOCK_POPULATION', 301, 'MARKETING_DELIVERY', 601, 60, 'ACTIVE', 'CONSUME'),
-			(2, 401, 'PROJECT_FLOCK_POPULATION', 302, 'MARKETING_DELIVERY', 601, 40, 'ACTIVE', 'CONSUME'),
-			(3, 401, 'RECORDING_EGG', 701, 'MARKETING_DELIVERY', 603, 12, 'ACTIVE', 'CONSUME')`,
-	}
-	for _, stmt := range statements {
-		if err := db.Exec(stmt).Error; err != nil {
-			t.Fatalf("failed seeding fixtures: %v", err)
-		}
-	}
-
-	type singleRow struct {
-		MarketingDeliveryProductID      uint  `gorm:"column:marketing_delivery_product_id"`
-		AttributedProjectFlockKandangID *uint `gorm:"column:attributed_project_flock_kandang_id"`
-	}
-
-	var rows []singleRow
-	if err := db.Table("(?) AS mda", MarketingDeliverySingleAttributionQuery(db)).
-		Order("mda.marketing_delivery_product_id ASC").
-		Scan(&rows).Error; err != nil {
-		t.Fatalf("failed scanning single attribution rows: %v", err)
-	}
-
-	if len(rows) != 3 {
-		t.Fatalf("expected 3 rows, got %d", len(rows))
-	}
-	if rows[0].MarketingDeliveryProductID != 601 || rows[0].AttributedProjectFlockKandangID != nil {
-		t.Fatalf("expected pooled delivery 601 to have nil single attribution, got %+v", rows[0])
-	}
-	if rows[1].MarketingDeliveryProductID != 602 || rows[1].AttributedProjectFlockKandangID == nil || *rows[1].AttributedProjectFlockKandangID != 101 {
-		t.Fatalf("expected fallback delivery 602 to map to kandang 101, got %+v", rows[1])
-	}
-	if rows[2].MarketingDeliveryProductID != 603 || rows[2].AttributedProjectFlockKandangID == nil || *rows[2].AttributedProjectFlockKandangID != 101 {
-		t.Fatalf("expected egg delivery 603 to map to kandang 101, got %+v", rows[2])
-	}
-}
-
-func setupMarketingAttributionTestDB(t *testing.T) *gorm.DB {
-	t.Helper()
-
-	db, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=private"), &gorm.Config{})
-	if err != nil {
-		t.Fatalf("failed opening sqlite db: %v", err)
-	}
-
-	statements := []string{
-		`CREATE TABLE stock_allocations (
-			id INTEGER PRIMARY KEY,
-			product_warehouse_id INTEGER,
-			stockable_type TEXT,
-			stockable_id INTEGER,
-			usable_type TEXT,
-			usable_id INTEGER,
-			qty NUMERIC(15,3),
-			status TEXT,
-			allocation_purpose TEXT
-		)`,
-		`CREATE TABLE project_flock_populations (id INTEGER PRIMARY KEY, project_chickin_id INTEGER)`,
-		`CREATE TABLE project_chickins (id INTEGER PRIMARY KEY, project_flock_kandang_id INTEGER)`,
-		`CREATE TABLE project_flock_kandangs (id INTEGER PRIMARY KEY, project_flock_id INTEGER)`,
-		`CREATE TABLE project_flocks (id INTEGER PRIMARY KEY, category TEXT)`,
-		`CREATE TABLE marketing_delivery_products (id INTEGER PRIMARY KEY, marketing_product_id INTEGER, usage_qty NUMERIC(15,3))`,
-		`CREATE TABLE marketing_products (id INTEGER PRIMARY KEY, product_warehouse_id INTEGER)`,
-		`CREATE TABLE product_warehouses (id INTEGER PRIMARY KEY, project_flock_kandang_id INTEGER NULL)`,
-		`CREATE TABLE recording_eggs (id INTEGER PRIMARY KEY, recording_id INTEGER, project_flock_kandang_id INTEGER NULL)`,
-		`CREATE TABLE recordings (id INTEGER PRIMARY KEY, project_flock_kandangs_id INTEGER NULL)`,
-		`CREATE TABLE recording_depletions (id INTEGER PRIMARY KEY, recording_id INTEGER, source_project_flock_kandang_id INTEGER NULL)`,
-		`CREATE TABLE purchase_items (id INTEGER PRIMARY KEY, project_flock_kandang_id INTEGER NULL)`,
-		`CREATE TABLE stock_transfer_details (id INTEGER PRIMARY KEY, source_product_warehouse_id INTEGER NULL)`,
-		`CREATE TABLE laying_transfer_targets (id INTEGER PRIMARY KEY, target_project_flock_kandang_id INTEGER NULL)`,
-	}
-	for _, stmt := range statements {
-		if err := db.Exec(stmt).Error; err != nil {
-			t.Fatalf("failed preparing schema: %v", err)
-		}
-	}
-
-	return db
-}

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

@@ -1,104 +0,0 @@
-package service
-
-import (
-	"strings"
-	"time"
-)
-
-const (
-	depreciationStartAgeDayCloseHouse = 155
-	depreciationStartAgeDayOpenHouse  = 176
-)
-
-func NormalizeDepreciationHouseType(raw string) string {
-	return strings.TrimSpace(strings.ToLower(raw))
-}
-
-func DepreciationStartAgeDay(houseType string) int {
-	switch NormalizeDepreciationHouseType(houseType) {
-	case "close_house":
-		return depreciationStartAgeDayCloseHouse
-	case "open_house":
-		return depreciationStartAgeDayOpenHouse
-	default:
-		return 0
-	}
-}
-
-func FlockAgeDay(originDate time.Time, periodDate time.Time) int {
-	origin := time.Date(originDate.Year(), originDate.Month(), originDate.Day(), 0, 0, 0, 0, originDate.Location())
-	period := time.Date(periodDate.Year(), periodDate.Month(), periodDate.Day(), 0, 0, 0, 0, periodDate.Location())
-	if period.Before(origin) {
-		return 0
-	}
-	return int(period.Sub(origin).Hours()/24) + 1
-}
-
-func DepreciationScheduleDay(originDate time.Time, periodDate time.Time, houseType string) int {
-	ageDay := FlockAgeDay(originDate, periodDate)
-	startAgeDay := DepreciationStartAgeDay(houseType)
-	if ageDay <= 0 || startAgeDay <= 0 || ageDay < startAgeDay {
-		return 0
-	}
-	return ageDay - startAgeDay + 1
-}
-
-func CalculateDepreciationAtDayN(
-	initialPulletCost float64,
-	dayN int,
-	houseType string,
-	percentByHouseType map[string]map[int]float64,
-) (float64, float64, float64) {
-	return CalculateDepreciationFromDayRange(initialPulletCost, 1, dayN, houseType, percentByHouseType)
-}
-
-func CalculateDepreciationFromDayRange(
-	initialPulletCost float64,
-	startDay int,
-	endDay int,
-	houseType string,
-	percentByHouseType map[string]map[int]float64,
-) (float64, float64, float64) {
-	if initialPulletCost <= 0 || endDay <= 0 {
-		return 0, 0, 0
-	}
-	if startDay <= 0 {
-		startDay = 1
-	}
-	if endDay < startDay {
-		return 0, 0, 0
-	}
-
-	normalizedHouseType := NormalizeDepreciationHouseType(houseType)
-	housePercent, exists := percentByHouseType[normalizedHouseType]
-	if !exists {
-		return 0, 0, 0
-	}
-
-	current := initialPulletCost
-	pulletCostDayN := 0.0
-	depreciationValue := 0.0
-	depreciationPercent := 0.0
-	for day := startDay; day <= endDay; day++ {
-		pct := housePercent[day]
-		dep := current * (pct / 100)
-		if day == endDay {
-			pulletCostDayN = current
-			depreciationValue = dep
-			depreciationPercent = pct
-		}
-		current -= dep
-		if current < 0 {
-			current = 0
-		}
-	}
-
-	return pulletCostDayN, depreciationValue, depreciationPercent
-}
-
-func CalculateEffectiveDepreciationPercent(totalDepreciationValue, totalPulletCostDayN float64) float64 {
-	if totalPulletCostDayN <= 0 {
-		return 0
-	}
-	return (totalDepreciationValue / totalPulletCostDayN) * 100
-}

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

@@ -1,81 +0,0 @@
-package service
-
-import (
-	"testing"
-	"time"
-)
-
-func TestDepreciationScheduleDay_UsesHouseTypeOffsets(t *testing.T) {
-	openOrigin := mustDepreciationDate(t, "2026-01-01")
-	if got := DepreciationScheduleDay(openOrigin, mustDepreciationDate(t, "2026-06-24"), "open_house"); got != 0 {
-		t.Fatalf("expected open house day before start to be 0, got %d", got)
-	}
-	if got := DepreciationScheduleDay(openOrigin, mustDepreciationDate(t, "2026-06-25"), "open_house"); got != 1 {
-		t.Fatalf("expected open house start day to map to schedule day 1, got %d", got)
-	}
-
-	closeOrigin := mustDepreciationDate(t, "2026-01-01")
-	if got := DepreciationScheduleDay(closeOrigin, mustDepreciationDate(t, "2026-06-03"), "close_house"); got != 0 {
-		t.Fatalf("expected close house day before start to be 0, got %d", got)
-	}
-	if got := DepreciationScheduleDay(closeOrigin, mustDepreciationDate(t, "2026-06-04"), "close_house"); got != 1 {
-		t.Fatalf("expected close house start day to map to schedule day 1, got %d", got)
-	}
-}
-
-func TestCalculateDepreciationAtDayN_UsesRemainingBasisRecursively(t *testing.T) {
-	percentByHouseType := map[string]map[int]float64{
-		"close_house": {
-			1: 10,
-			2: 20,
-		},
-	}
-
-	pulletCostDayN, depreciationValue, depreciationPercent := CalculateDepreciationAtDayN(1000, 2, "close_house", percentByHouseType)
-	if pulletCostDayN != 900 {
-		t.Fatalf("expected remaining basis entering day 2 to be 900, got %v", pulletCostDayN)
-	}
-	if depreciationValue != 180 {
-		t.Fatalf("expected day 2 depreciation to be 180, got %v", depreciationValue)
-	}
-	if depreciationPercent != 20 {
-		t.Fatalf("expected day 2 depreciation percent to be 20, got %v", depreciationPercent)
-	}
-}
-
-func TestCalculateDepreciationFromDayRange_StartsFromProvidedScheduleDay(t *testing.T) {
-	percentByHouseType := map[string]map[int]float64{
-		"close_house": {
-			1: 10,
-			2: 20,
-			3: 5,
-		},
-	}
-
-	pulletCostDayN, depreciationValue, depreciationPercent := CalculateDepreciationFromDayRange(1000, 2, 3, "close_house", percentByHouseType)
-	if pulletCostDayN != 800 {
-		t.Fatalf("expected remaining basis entering day 3 to be 800, got %v", pulletCostDayN)
-	}
-	if depreciationValue != 40 {
-		t.Fatalf("expected day 3 depreciation to be 40, got %v", depreciationValue)
-	}
-	if depreciationPercent != 5 {
-		t.Fatalf("expected day 3 depreciation percent to be 5, got %v", depreciationPercent)
-	}
-}
-
-func mustDepreciationDate(t *testing.T, raw string) time.Time {
-	t.Helper()
-
-	location, err := time.LoadLocation("Asia/Jakarta")
-	if err != nil {
-		t.Fatalf("failed loading timezone: %v", err)
-	}
-
-	value, err := time.ParseInLocation("2006-01-02", raw, location)
-	if err != nil {
-		t.Fatalf("failed parsing date %q: %v", raw, err)
-	}
-
-	return value
-}

internal/common/service/common.fifo.service.go

@@ -528,7 +528,6 @@ func (s *fifoService) allocateFromStock(
 			UsableType:         usableKey.String(),
 			UsableId:           usableID,
 			Qty:                portion,
-			AllocationPurpose:  entities.StockAllocationPurposeConsume,
 			Status:             entities.StockAllocationStatusActive,
 		})
 
@@ -891,22 +890,22 @@ func (s *fifoService) fetchPendingCandidates(ctx context.Context, tx *gorm.DB, p
 				query = query.Order(order)
 			}
 
-			if err := query.Find(&rows).Error; err != nil {
+		if err := query.Find(&rows).Error; err != nil {
-				return nil, err
+			return nil, err
+		}
+		for _, row := range rows {
+			if row.Pending <= 0 {
+				continue
 			}
-			for _, row := range rows {
+			candidates = append(candidates, pendingCandidate{
-				if row.Pending <= 0 {
+				UsableKey: key,
-					continue
+				Config:    cfg,
-				}
+				UsableID:  row.ID,
-				candidates = append(candidates, pendingCandidate{
+				Pending:   row.Pending,
-					UsableKey: key,
+				CreatedAt: time.Unix(0, row.CreatedAt),
-					Config:    cfg,
+			})
-					UsableID:  row.ID,
+		}
-					Pending:   row.Pending,
+	} else {
-					CreatedAt: time.Unix(0, row.CreatedAt),
-				})
-			}
-		} else {
 			var rows []struct {
 				ID        uint
 				Pending   float64   `gorm:"column:pending_qty"`

internal/common/service/common.fifo_stock_v2.service.go

@@ -1,41 +0,0 @@
-package service
-
-import (
-	"github.com/sirupsen/logrus"
-	fifoStockV2 "gitlab.com/mbugroup/lti-api.git/internal/common/service/fifo_stock_v2"
-	"gorm.io/gorm"
-)
-
-type FifoStockV2Service = fifoStockV2.Service
-
-type FifoStockV2Lane = fifoStockV2.Lane
-
-type FifoStockV2Ref = fifoStockV2.Ref
-
-type FifoStockV2GatherRequest = fifoStockV2.GatherRequest
-
-type FifoStockV2GatherRow = fifoStockV2.GatherRow
-
-type FifoStockV2AllocateRequest = fifoStockV2.AllocateRequest
-
-type FifoStockV2AllocateResult = fifoStockV2.AllocateResult
-
-type FifoStockV2AllocationDetail = fifoStockV2.AllocationDetail
-
-type FifoStockV2RollbackRequest = fifoStockV2.RollbackRequest
-
-type FifoStockV2RollbackResult = fifoStockV2.RollbackResult
-
-type FifoStockV2ReflowRequest = fifoStockV2.ReflowRequest
-
-type FifoStockV2ReflowResult = fifoStockV2.ReflowResult
-
-type FifoStockV2RecalculateRequest = fifoStockV2.RecalculateRequest
-
-type FifoStockV2RecalculateResult = fifoStockV2.RecalculateResult
-
-type FifoStockV2WarehouseDrift = fifoStockV2.WarehouseDrift
-
-func NewFifoStockV2Service(db *gorm.DB, logger *logrus.Logger) FifoStockV2Service {
-	return fifoStockV2.NewService(db, logger)
-}

internal/common/service/common.hpp.service.go

@@ -46,7 +46,6 @@ func (s *hppService) CalculateHppCost(projectFlockKandangId uint, date *time.Tim
 
 	location, err := time.LoadLocation("Asia/Jakarta")
 	if err != nil {
-
 		return nil, err
 	}
 
@@ -55,21 +54,16 @@ func (s *hppService) CalculateHppCost(projectFlockKandangId uint, date *time.Tim
 
 	depresiasiTransfer, err := s.GetDepresiasiTransfer(projectFlockKandangId, &endOfDay)
 	if err != nil {
-
 		return nil, err
 	}
 
 	totalProductionCost, err := s.GetTotalProductionCost(projectFlockKandangId, &endOfDay, depresiasiTransfer)
 	if err != nil {
-
 		return nil, err
 	}
-	result, err := s.GetHppEstimationDanRealisasi(totalProductionCost, projectFlockKandangId, &startOfDay, &endOfDay)
-	if err != nil {
 
-		return nil, err
+	return s.GetHppEstimationDanRealisasi(totalProductionCost, projectFlockKandangId, &startOfDay, &endOfDay)
-	}
+
-	return result, nil
 }
 
 func (s *hppService) GetTotalDepresiasiFlockGrowing(sourceProjectFlockID uint, date *time.Time) (float64, error) {
@@ -79,48 +73,40 @@ func (s *hppService) GetTotalDepresiasiFlockGrowing(sourceProjectFlockID uint, d
 	}
 
 	if s.hppRepo == nil {
-
 		return 0, nil
 	}
 
 	kandangIDs, err := s.hppRepo.GetProjectFlockKandangIDs(context.Background(), sourceProjectFlockID)
 	if err != nil {
-
 		return 0, err
 	}
 
 	docCost, err := s.hppRepo.GetDocCost(context.Background(), kandangIDs)
 	if err != nil {
-
 		return 0, err
 	}
 
 	budgetCost, err := s.hppRepo.GetBudgetCostByProjectFlockId(context.Background(), sourceProjectFlockID)
 	if err != nil {
-
 		return 0, err
 	}
 
 	expedisionCost, err := s.hppRepo.GetExpedisionCost(context.Background(), kandangIDs)
 	if err != nil {
-
 		return 0, err
 	}
 
 	feedCost, err := s.hppRepo.GetFeedUsageCost(context.Background(), kandangIDs, date)
 	if err != nil {
-
 		return 0, err
 	}
 
 	ovkCost, err := s.hppRepo.GetOvkUsageCost(context.Background(), kandangIDs, date)
 	if err != nil {
-
 		return 0, err
 	}
 
-	total := docCost + budgetCost + expedisionCost + feedCost + ovkCost
+	return docCost + budgetCost + expedisionCost + feedCost + ovkCost, nil
-	return total, nil
 }
 
 func (s *hppService) GetTotalProductionCost(projectFlockKandangId uint, endDate *time.Time, depresiasiTransfer float64) (float64, error) {
@@ -131,40 +117,30 @@ func (s *hppService) GetTotalProductionCost(projectFlockKandangId uint, endDate
 
 	costPullet, err := s.hppRepo.GetPulletCost(context.Background(), projectFlockKandangId)
 	if err != nil {
-
 		return 0, err
 	}
 
 	costFeed, err := s.hppRepo.GetFeedUsageCost(context.Background(), []uint{projectFlockKandangId}, endDate)
 	if err != nil {
-
 		return 0, err
 	}
 
 	costOvk, err := s.hppRepo.GetOvkUsageCost(context.Background(), []uint{projectFlockKandangId}, endDate)
 	if err != nil {
-
 		return 0, err
 	}
 
 	costExpedision, err := s.hppRepo.GetExpedisionCost(context.Background(), []uint{projectFlockKandangId})
 	if err != nil {
-
 		return 0, err
 	}
 
 	costBudget, err := s.GetBudgetKandangLaying(projectFlockKandangId, endDate)
 	if err != nil {
-
 		return 0, err
 	}
 
-	// fmt.Println(costBudget, costExpedision, costOvk, costFeed, costPullet, depresiasiTransfer)
+	return depresiasiTransfer + costPullet + costFeed + costOvk + costExpedision + costBudget, nil
-
-	// depresiasiTransfer = 0
-
-	total := depresiasiTransfer + costPullet + costFeed + costOvk + costExpedision + costBudget
-	return total, nil
 }
 
 func (s *hppService) GetBudgetKandangLaying(projectFlockKandangId uint, endDate *time.Time) (float64, error) {
@@ -174,57 +150,48 @@ func (s *hppService) GetBudgetKandangLaying(projectFlockKandangId uint, endDate
 	// }
 
 	if s.hppRepo == nil {
-
 		return 0, nil
 	}
 
 	projectFlockId, err := s.hppRepo.GetProjectFlockIDByProjectFlockKandangID(context.Background(), projectFlockKandangId)
 	if err != nil {
-
 		return 0, err
 	}
 
 	projectFlockKandangIds, err := s.hppRepo.GetProjectFlockKandangIDs(context.Background(), projectFlockId)
 	if err != nil {
-
 		return 0, err
 	}
 
 	eggProduksiPiecesFlock, _, err := s.hppRepo.GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(context.Background(), projectFlockKandangIds, endDate)
 	if err != nil {
-
 		return 0, err
 	}
 
 	eggProduksiPiecesKandang, _, err := s.hppRepo.GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(context.Background(), []uint{projectFlockKandangId}, endDate)
 	if err != nil {
-
 		return 0, err
 	}
 
 	totalBudgetCost, err := s.hppRepo.GetBudgetCostByProjectFlockId(context.Background(), projectFlockId)
 	if err != nil {
-
 		return 0, err
 	}
 
 	if eggProduksiPiecesFlock == 0 {
-
 		return 0, nil
 	}
 
-	result := (totalBudgetCost * eggProduksiPiecesKandang) / eggProduksiPiecesFlock
+	return (totalBudgetCost * eggProduksiPiecesKandang) / eggProduksiPiecesFlock, nil
-	return result, nil
 }
 
 func (s *hppService) GetDepresiasiTransfer(projectFlockKandangId uint, endDate *time.Time) (float64, error) {
-	if endDate == nil {
+	// if endDate == nil {
-		now := time.Now()
+	// 	now := time.Now()
-		endDate = &now
+	// 	endDate = &now
-	}
+	// }
 
 	if s.hppRepo == nil {
-
 		return 0, nil
 	}
 
@@ -232,13 +199,6 @@ func (s *hppService) GetDepresiasiTransfer(projectFlockKandangId uint, endDate *
 	if err != nil {
 		return 0, err
 	}
-	if sourceProjectFlockID == 0 || transferTotalQty <= 0 {
-		result, fallbackErr := s.getManualDepresiasiTransferFallback(projectFlockKandangId)
-		if fallbackErr != nil {
-			return 0, fallbackErr
-		}
-		return result, nil
-	}
 
 	kandangIDsGrowing, err := s.hppRepo.GetProjectFlockKandangIDs(context.Background(), sourceProjectFlockID)
 	if err != nil {
@@ -258,81 +218,22 @@ func (s *hppService) GetDepresiasiTransfer(projectFlockKandangId uint, endDate *
 		return 0, err
 	}
 
-	result := (totalDepresiasiFlockGrowing * transferTotalQty) / totalPopulationFlockGrowing
+	return (totalDepresiasiFlockGrowing * transferTotalQty) / totalPopulationFlockGrowing, nil
-	return result, nil
-}
-
-func (s *hppService) getManualDepresiasiTransferFallback(projectFlockKandangId uint) (float64, error) {
-	projectFlockID, err := s.hppRepo.GetProjectFlockIDByProjectFlockKandangID(context.Background(), projectFlockKandangId)
-	if err != nil {
-
-		return 0, err
-	}
-	if projectFlockID == 0 {
-
-		return 0, nil
-	}
-
-	manualCost, err := s.hppRepo.GetManualDepreciationCostByProjectFlockID(context.Background(), projectFlockID)
-	if err != nil {
-
-		return 0, err
-	}
-	if manualCost <= 0 {
-
-		return 0, nil
-	}
-
-	kandangIDs, err := s.hppRepo.GetProjectFlockKandangIDs(context.Background(), projectFlockID)
-	if err != nil {
-
-		return 0, err
-	}
-	if len(kandangIDs) == 0 {
-
-		return 0, nil
-	}
-
-	totalUsageQty, err := s.hppRepo.GetTotalPopulation(context.Background(), kandangIDs)
-	if err != nil {
-
-		return 0, err
-	}
-	if totalUsageQty <= 0 {
-
-		return 0, nil
-	}
-
-	kandangUsageQty, err := s.hppRepo.GetTotalPopulation(context.Background(), []uint{projectFlockKandangId})
-	if err != nil {
-
-		return 0, err
-	}
-	if kandangUsageQty <= 0 {
-
-		return 0, nil
-	}
-
-	result := manualCost * (kandangUsageQty / totalUsageQty)
-	return result, nil
 }
 
 func (s *hppService) GetHppEstimationDanRealisasi(totalProductionCost float64, projectFlockKandangId uint, startDate *time.Time, endDate *time.Time) (*HppCostResponse, error) {
 
 	if s.hppRepo == nil {
-
 		return &HppCostResponse{}, nil
 	}
 
 	estimPieces, estimWeightKg, err := s.hppRepo.GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(context.Background(), []uint{projectFlockKandangId}, endDate)
 	if err != nil {
-
 		return nil, err
 	}
 
 	realPieces, realWeightKg, err := s.hppRepo.GetEggTerjualPiecesAndWeightKgByProjectFlockKandangIds(context.Background(), []uint{projectFlockKandangId}, startDate, endDate)
 	if err != nil {
-
 		return nil, err
 	}
 
@@ -360,21 +261,12 @@ func (s *hppService) GetHppEstimationDanRealisasi(totalProductionCost float64, p
 		real.HargaButir = roundToTwoDecimals(totalProductionCost / realPieces)
 	}
 
-	result := &HppCostResponse{
+	return &HppCostResponse{
 		Estimation: estimation,
 		Real:       real,
-	}
+	}, nil
-	return result, nil
 }
 
 func roundToTwoDecimals(value float64) float64 {
-	result := math.Round(value*100) / 100
+	return math.Round(value*100) / 100
-	return result
-}
-
-func formatTimePtr(value *time.Time) string {
-	if value == nil {
-		return "<nil>"
-	}
-	return value.Format(time.RFC3339)
 }

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

@@ -1,61 +0,0 @@
-package service
-
-type HppV2DateWindow struct {
-	Start string `json:"start"`
-	End   string `json:"end"`
-}
-
-type HppV2Proration struct {
-	Basis       string  `json:"basis"`
-	Numerator   float64 `json:"numerator"`
-	Denominator float64 `json:"denominator"`
-	Ratio       float64 `json:"ratio"`
-}
-
-type HppV2Reference struct {
-	Type                  string  `json:"type"`
-	ID                    uint    `json:"id"`
-	StockableType         string  `json:"stockable_type,omitempty"`
-	ProjectFlockKandangID *uint   `json:"project_flock_kandang_id,omitempty"`
-	ProductID             uint    `json:"product_id,omitempty"`
-	ProductName           string  `json:"product_name,omitempty"`
-	Date                  string  `json:"date,omitempty"`
-	Qty                   float64 `json:"qty"`
-	UnitPrice             float64 `json:"unit_price"`
-	Total                 float64 `json:"total"`
-	AppliedTotal          float64 `json:"applied_total"`
-}
-
-type HppV2ComponentPart struct {
-	Code       string           `json:"code"`
-	Title      string           `json:"title"`
-	Scopes     []string         `json:"scopes,omitempty"`
-	Total      float64          `json:"total"`
-	Proration  *HppV2Proration  `json:"proration,omitempty"`
-	Details    map[string]any   `json:"details,omitempty"`
-	References []HppV2Reference `json:"references,omitempty"`
-}
-
-type HppV2Component struct {
-	Code   string               `json:"code"`
-	Title  string               `json:"title"`
-	Scopes []string             `json:"scopes,omitempty"`
-	Total  float64              `json:"total"`
-	Parts  []HppV2ComponentPart `json:"parts"`
-}
-
-type HppV2Breakdown struct {
-	ProjectFlockKandangID uint             `json:"project_flock_kandang_id"`
-	ProjectFlockID        uint             `json:"project_flock_id"`
-	ProjectFlockCategory  string           `json:"project_flock_category,omitempty"`
-	HouseType             string           `json:"house_type,omitempty"`
-	KandangID             uint             `json:"kandang_id,omitempty"`
-	KandangName           string           `json:"kandang_name,omitempty"`
-	LocationID            uint             `json:"location_id,omitempty"`
-	PeriodDate            string           `json:"period_date"`
-	Window                HppV2DateWindow  `json:"window"`
-	TotalPulletCost       float64          `json:"total_pullet_cost"`
-	TotalProductionCost   float64          `json:"total_production_cost"`
-	Components            []HppV2Component `json:"components"`
-	Hpp                   HppCostResponse  `json:"hpp"`
-}

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

@@ -1,872 +0,0 @@
-package service
-
-import (
-	"context"
-	"fmt"
-	"sort"
-	"strings"
-	"testing"
-	"time"
-
-	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils"
-)
-
-type hppV2RepoStub struct {
-	contextByPFK         map[uint]*commonRepo.HppV2ProjectFlockKandangContext
-	pfkIDsByProject      map[uint][]uint
-	latestTransferByPFK  map[uint]*commonRepo.HppV2LatestTransferInputRow
-	manualInputByProject map[uint]*commonRepo.HppV2ManualDepreciationInputRow
-	snapshotByProjectKey map[string]*commonRepo.HppV2FarmDepreciationSnapshotRow
-	chickInDateByProject map[uint]*time.Time
-	depreciationByHouse  map[string]map[int]float64
-	usageRowsByKey       map[string][]commonRepo.HppV2UsageCostRow
-	adjustRowsByKey      map[string][]commonRepo.HppV2AdjustmentCostRow
-	chickinRowsByKey     map[string][]commonRepo.HppV2ChickinCostRow
-	expenseRowsByPFKKey  map[string][]commonRepo.HppV2ExpenseCostRow
-	expenseRowsByFarmKey map[string][]commonRepo.HppV2ExpenseCostRow
-	totalPopulationByKey map[string]float64
-	transferSummaryByPFK map[uint]struct {
-		projectFlockID uint
-		totalQty       float64
-	}
-	eggProductionByPFK map[uint]struct {
-		pieces float64
-		kg     float64
-	}
-	eggSalesByPFK map[uint]struct {
-		pieces float64
-		kg     float64
-	}
-}
-
-func (s *hppV2RepoStub) GetProjectFlockKandangContext(_ context.Context, projectFlockKandangId uint) (*commonRepo.HppV2ProjectFlockKandangContext, error) {
-	row := s.contextByPFK[projectFlockKandangId]
-	if row == nil {
-		return nil, fmt.Errorf("pfk %d not found", projectFlockKandangId)
-	}
-	return row, nil
-}
-
-func (s *hppV2RepoStub) GetProjectFlockKandangIDs(_ context.Context, projectFlockId uint) ([]uint, error) {
-	return append([]uint{}, s.pfkIDsByProject[projectFlockId]...), nil
-}
-
-func (s *hppV2RepoStub) GetLatestTransferInputByProjectFlockKandangID(_ context.Context, projectFlockKandangId uint, _ time.Time) (*commonRepo.HppV2LatestTransferInputRow, error) {
-	return s.latestTransferByPFK[projectFlockKandangId], nil
-}
-
-func (s *hppV2RepoStub) GetManualDepreciationInputByProjectFlockID(_ context.Context, projectFlockID uint) (*commonRepo.HppV2ManualDepreciationInputRow, error) {
-	return s.manualInputByProject[projectFlockID], nil
-}
-
-func (s *hppV2RepoStub) GetFarmDepreciationSnapshotByProjectFlockIDAndPeriod(_ context.Context, projectFlockID uint, periodDate time.Time) (*commonRepo.HppV2FarmDepreciationSnapshotRow, error) {
-	if s.snapshotByProjectKey == nil {
-		return nil, nil
-	}
-	return s.snapshotByProjectKey[fmt.Sprintf("%d|%s", projectFlockID, periodDate.Format("2006-01-02"))], nil
-}
-
-func (s *hppV2RepoStub) GetEarliestChickInDateByProjectFlockID(_ context.Context, projectFlockID uint) (*time.Time, error) {
-	return s.chickInDateByProject[projectFlockID], nil
-}
-
-func (s *hppV2RepoStub) GetDepreciationPercents(_ context.Context, houseTypes []string, maxDay int) (map[string]map[int]float64, error) {
-	result := make(map[string]map[int]float64)
-	for _, houseType := range houseTypes {
-		source := s.depreciationByHouse[houseType]
-		if len(source) == 0 {
-			continue
-		}
-		result[houseType] = make(map[int]float64)
-		for day, pct := range source {
-			if day <= maxDay {
-				result[houseType][day] = pct
-			}
-		}
-	}
-	return result, nil
-}
-
-func (s *hppV2RepoStub) ListUsageCostRowsByProductFlags(_ context.Context, projectFlockKandangIDs []uint, flagNames []string, _ *time.Time) ([]commonRepo.HppV2UsageCostRow, error) {
-	return append([]commonRepo.HppV2UsageCostRow{}, s.usageRowsByKey[stubKey(projectFlockKandangIDs, flagNames)]...), nil
-}
-
-func (s *hppV2RepoStub) ListAdjustmentCostRowsByProductFlags(_ context.Context, projectFlockKandangIDs []uint, flagNames []string, _ *time.Time) ([]commonRepo.HppV2AdjustmentCostRow, error) {
-	return append([]commonRepo.HppV2AdjustmentCostRow{}, s.adjustRowsByKey[stubKey(projectFlockKandangIDs, flagNames)]...), nil
-}
-
-func (s *hppV2RepoStub) ListExpenseRealizationRowsByProjectFlockKandangIDs(_ context.Context, projectFlockKandangIDs []uint, _ *time.Time, ekspedisi bool) ([]commonRepo.HppV2ExpenseCostRow, error) {
-	return append([]commonRepo.HppV2ExpenseCostRow{}, s.expenseRowsByPFKKey[expenseStubKey(projectFlockKandangIDs, ekspedisi)]...), nil
-}
-
-func (s *hppV2RepoStub) ListExpenseRealizationRowsByProjectFlockID(_ context.Context, projectFlockID uint, _ *time.Time, ekspedisi bool) ([]commonRepo.HppV2ExpenseCostRow, error) {
-	return append([]commonRepo.HppV2ExpenseCostRow{}, s.expenseRowsByFarmKey[expenseFarmKey(projectFlockID, ekspedisi)]...), nil
-}
-
-func (s *hppV2RepoStub) ListChickinCostRowsByProductFlags(_ context.Context, projectFlockKandangIDs []uint, flagNames []string, _ *time.Time, excludeTransferToLaying bool) ([]commonRepo.HppV2ChickinCostRow, error) {
-	return append([]commonRepo.HppV2ChickinCostRow{}, s.chickinRowsByKey[chickinStubKey(projectFlockKandangIDs, flagNames, excludeTransferToLaying)]...), nil
-}
-
-func (s *hppV2RepoStub) GetFeedUsageCost(_ context.Context, _ []uint, _ *time.Time) (float64, error) {
-	return 0, nil
-}
-
-func (s *hppV2RepoStub) GetTotalPopulation(_ context.Context, projectFlockKandangIDs []uint) (float64, error) {
-	return s.totalPopulationByKey[stubKey(projectFlockKandangIDs, nil)], nil
-}
-
-func (s *hppV2RepoStub) GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(_ context.Context, projectFlockKandangIDs []uint, _ *time.Time) (float64, float64, error) {
-	totalPieces := 0.0
-	totalKg := 0.0
-	for _, projectFlockKandangID := range projectFlockKandangIDs {
-		row := s.eggProductionByPFK[projectFlockKandangID]
-		totalPieces += row.pieces
-		totalKg += row.kg
-	}
-	return totalPieces, totalKg, nil
-}
-
-func (s *hppV2RepoStub) GetEggTerjualPiecesAndWeightKgByProjectFlockKandangIds(_ context.Context, projectFlockKandangIDs []uint, _ *time.Time, _ *time.Time) (float64, float64, error) {
-	if len(projectFlockKandangIDs) != 1 {
-		return 0, 0, nil
-	}
-	row := s.eggSalesByPFK[projectFlockKandangIDs[0]]
-	return row.pieces, row.kg, nil
-}
-
-func (s *hppV2RepoStub) GetTransferSourceSummary(_ context.Context, projectFlockKandangId uint) (uint, float64, error) {
-	row := s.transferSummaryByPFK[projectFlockKandangId]
-	return row.projectFlockID, row.totalQty, nil
-}
-
-func TestHppV2CalculateHppBreakdown_ComposesPakanSlices(t *testing.T) {
-	repo := &hppV2RepoStub{
-		contextByPFK: map[uint]*commonRepo.HppV2ProjectFlockKandangContext{
-			10: {
-				ProjectFlockKandangID: 10,
-				ProjectFlockID:        2,
-				ProjectFlockCategory:  "LAYING",
-				KandangID:             100,
-				KandangName:           "Kandang A",
-				LocationID:            16,
-			},
-		},
-		pfkIDsByProject: map[uint][]uint{
-			1: {101, 102},
-		},
-		usageRowsByKey: map[string][]commonRepo.HppV2UsageCostRow{
-			stubKey([]uint{101, 102}, []string{"PAKAN"}): {
-				{StockableType: "purchase_items", StockableID: 9001, SourceProductID: 8, SourceProductName: "Pakan Growing", Qty: 100, UnitPrice: 40, TotalCost: 4000},
-			},
-			stubKey([]uint{10}, []string{"PAKAN"}): {
-				{StockableType: "purchase_items", StockableID: 9002, SourceProductID: 9, SourceProductName: "Pakan Laying", Qty: 50, UnitPrice: 30, TotalCost: 1500},
-			},
-		},
-		adjustRowsByKey: map[string][]commonRepo.HppV2AdjustmentCostRow{
-			stubKey([]uint{101, 102}, []string{"PAKAN-CUTOVER"}): {
-				{AdjustmentID: 8001, ProductID: 11, ProductName: "Pakan Growing Cut-over", Qty: 20, Price: 30, GrandTotal: 600},
-			},
-			stubKey([]uint{10}, []string{"PAKAN-CUTOVER"}): {
-				{AdjustmentID: 8002, ProductID: 12, ProductName: "Pakan Laying Cut-over", Qty: 10, Price: 30, GrandTotal: 300},
-			},
-		},
-		totalPopulationByKey: map[string]float64{
-			stubKey([]uint{101, 102}, nil): 1000,
-		},
-		transferSummaryByPFK: map[uint]struct {
-			projectFlockID uint
-			totalQty       float64
-		}{
-			10: {projectFlockID: 1, totalQty: 250},
-		},
-		eggProductionByPFK: map[uint]struct {
-			pieces float64
-			kg     float64
-		}{
-			10: {pieces: 100, kg: 10},
-		},
-		eggSalesByPFK: map[uint]struct {
-			pieces float64
-			kg     float64
-		}{
-			10: {pieces: 40, kg: 4},
-		},
-	}
-
-	svc := NewHppV2Service(repo)
-	result, err := svc.CalculateHppBreakdown(10, mustDate(t, "2026-04-19"))
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if result == nil {
-		t.Fatal("expected breakdown result")
-	}
-	if got := result.TotalPulletCost; got != 1150 {
-		t.Fatalf("expected total pullet cost 1150, got %v", got)
-	}
-	if got := result.TotalProductionCost; got != 1800 {
-		t.Fatalf("expected total production cost 1800, got %v", got)
-	}
-	if len(result.Components) != 1 {
-		t.Fatalf("expected 1 component, got %d", len(result.Components))
-	}
-	component := result.Components[0]
-	if component.Code != "PAKAN" {
-		t.Fatalf("expected PAKAN component, got %s", component.Code)
-	}
-	partTotals := map[string]float64{}
-	for _, part := range component.Parts {
-		partTotals[part.Code] = part.Total
-	}
-	if partTotals[hppV2PartGrowingNormal] != 1000 {
-		t.Fatalf("expected growing normal 1000, got %v", partTotals[hppV2PartGrowingNormal])
-	}
-	if partTotals[hppV2PartGrowingCutover] != 150 {
-		t.Fatalf("expected growing cutover 150, got %v", partTotals[hppV2PartGrowingCutover])
-	}
-	if partTotals[hppV2PartLayingNormal] != 1500 {
-		t.Fatalf("expected laying normal 1500, got %v", partTotals[hppV2PartLayingNormal])
-	}
-	if partTotals[hppV2PartLayingCutover] != 300 {
-		t.Fatalf("expected laying cutover 300, got %v", partTotals[hppV2PartLayingCutover])
-	}
-	if component.Parts[0].Proration == nil || component.Parts[0].Proration.Ratio != 0.25 {
-		t.Fatalf("expected growing proration ratio 0.25, got %+v", component.Parts[0].Proration)
-	}
-	if result.Hpp.Estimation.HargaKg != 180 {
-		t.Fatalf("expected estimation harga/kg 180, got %v", result.Hpp.Estimation.HargaKg)
-	}
-	if result.Hpp.Real.HargaKg != 450 {
-		t.Fatalf("expected real harga/kg 450, got %v", result.Hpp.Real.HargaKg)
-	}
-}
-
-func TestHppV2CalculateHppBreakdown_ManualCutoverUsesLayingSlicesOnly(t *testing.T) {
-	repo := &hppV2RepoStub{
-		contextByPFK: map[uint]*commonRepo.HppV2ProjectFlockKandangContext{
-			20: {
-				ProjectFlockKandangID: 20,
-				ProjectFlockID:        3,
-				ProjectFlockCategory:  "LAYING",
-				KandangID:             200,
-				KandangName:           "Kandang B",
-				LocationID:            17,
-			},
-		},
-		usageRowsByKey: map[string][]commonRepo.HppV2UsageCostRow{
-			stubKey([]uint{20}, []string{"PAKAN"}): {
-				{StockableType: "purchase_items", StockableID: 9100, SourceProductID: 21, SourceProductName: "Pakan Laying", Qty: 20, UnitPrice: 10, TotalCost: 200},
-			},
-		},
-		adjustRowsByKey: map[string][]commonRepo.HppV2AdjustmentCostRow{
-			stubKey([]uint{20}, []string{"PAKAN-CUTOVER"}): {
-				{AdjustmentID: 8100, ProductID: 22, ProductName: "Pakan Laying Cut-over", Qty: 30, Price: 10, GrandTotal: 300},
-			},
-		},
-		eggProductionByPFK: map[uint]struct {
-			pieces float64
-			kg     float64
-		}{
-			20: {pieces: 50, kg: 5},
-		},
-		eggSalesByPFK: map[uint]struct {
-			pieces float64
-			kg     float64
-		}{
-			20: {pieces: 25, kg: 2.5},
-		},
-	}
-
-	svc := NewHppV2Service(repo)
-	result, err := svc.CalculateHppBreakdown(20, mustDate(t, "2026-04-19"))
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if result.TotalProductionCost != 500 {
-		t.Fatalf("expected total production cost 500, got %v", result.TotalProductionCost)
-	}
-	component := result.Components[0]
-	if len(component.Parts) != 2 {
-		t.Fatalf("expected 2 laying parts, got %d", len(component.Parts))
-	}
-	for _, part := range component.Parts {
-		if strings.HasPrefix(part.Code, "growing_") {
-			t.Fatalf("expected no growing parts, got %s", part.Code)
-		}
-	}
-	if result.Hpp.Estimation.HargaKg != 100 {
-		t.Fatalf("expected estimation harga/kg 100, got %v", result.Hpp.Estimation.HargaKg)
-	}
-}
-
-func TestHppV2CalculateHppBreakdown_IncludesOvkComponent(t *testing.T) {
-	repo := &hppV2RepoStub{
-		contextByPFK: map[uint]*commonRepo.HppV2ProjectFlockKandangContext{
-			30: {
-				ProjectFlockKandangID: 30,
-				ProjectFlockID:        4,
-				ProjectFlockCategory:  "LAYING",
-				KandangID:             300,
-				KandangName:           "Kandang C",
-				LocationID:            18,
-			},
-		},
-		pfkIDsByProject: map[uint][]uint{
-			5: {301, 302},
-		},
-		usageRowsByKey: map[string][]commonRepo.HppV2UsageCostRow{
-			stubKey([]uint{30}, []string{"PAKAN"}): {
-				{StockableType: "purchase_items", StockableID: 9200, SourceProductID: 31, SourceProductName: "Pakan Laying", Qty: 20, UnitPrice: 25, TotalCost: 500},
-			},
-			stubKey([]uint{301, 302}, []string{string(utils.FlagOVK), string(utils.FlagObat), string(utils.FlagVitamin), string(utils.FlagKimia)}): {
-				{StockableType: "purchase_items", StockableID: 9201, SourceProductID: 32, SourceProductName: "OVK Growing", Qty: 40, UnitPrice: 10, TotalCost: 400},
-			},
-			stubKey([]uint{30}, []string{string(utils.FlagOVK), string(utils.FlagObat), string(utils.FlagVitamin), string(utils.FlagKimia)}): {
-				{StockableType: "purchase_items", StockableID: 9202, SourceProductID: 33, SourceProductName: "OVK Laying", Qty: 15, UnitPrice: 10, TotalCost: 150},
-			},
-		},
-		adjustRowsByKey: map[string][]commonRepo.HppV2AdjustmentCostRow{
-			stubKey([]uint{301, 302}, []string{"OVK"}): {
-				{AdjustmentID: 8201, ProductID: 34, ProductName: "OVK Growing Cut-over", Qty: 10, Price: 10, GrandTotal: 100},
-			},
-			stubKey([]uint{30}, []string{"OVK"}): {
-				{AdjustmentID: 8202, ProductID: 35, ProductName: "OVK Laying Cut-over", Qty: 5, Price: 10, GrandTotal: 50},
-			},
-		},
-		totalPopulationByKey: map[string]float64{
-			stubKey([]uint{301, 302}, nil): 1000,
-		},
-		transferSummaryByPFK: map[uint]struct {
-			projectFlockID uint
-			totalQty       float64
-		}{
-			30: {projectFlockID: 5, totalQty: 500},
-		},
-		eggProductionByPFK: map[uint]struct {
-			pieces float64
-			kg     float64
-		}{
-			30: {pieces: 120, kg: 12},
-		},
-		eggSalesByPFK: map[uint]struct {
-			pieces float64
-			kg     float64
-		}{
-			30: {pieces: 60, kg: 6},
-		},
-	}
-
-	svc := NewHppV2Service(repo)
-	result, err := svc.CalculateHppBreakdown(30, mustDate(t, "2026-04-19"))
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if result == nil {
-		t.Fatal("expected breakdown result")
-	}
-	if len(result.Components) != 2 {
-		t.Fatalf("expected 2 components, got %d", len(result.Components))
-	}
-
-	componentTotals := map[string]float64{}
-	for _, component := range result.Components {
-		componentTotals[component.Code] = component.Total
-	}
-
-	if componentTotals[hppV2ComponentPakan] != 500 {
-		t.Fatalf("expected pakan total 500, got %v", componentTotals[hppV2ComponentPakan])
-	}
-	if componentTotals[hppV2ComponentOvk] != 450 {
-		t.Fatalf("expected ovk total 450, got %v", componentTotals[hppV2ComponentOvk])
-	}
-	if result.TotalPulletCost != 250 {
-		t.Fatalf("expected total pullet cost 250, got %v", result.TotalPulletCost)
-	}
-	if result.TotalProductionCost != 700 {
-		t.Fatalf("expected total production cost 700, got %v", result.TotalProductionCost)
-	}
-	if result.Hpp.Estimation.HargaKg != 58.33 {
-		t.Fatalf("expected estimation harga/kg 58.33, got %v", result.Hpp.Estimation.HargaKg)
-	}
-}
-
-func TestHppV2CalculateHppBreakdown_IncludesDocAndDirectPulletChickin(t *testing.T) {
-	repo := &hppV2RepoStub{
-		contextByPFK: map[uint]*commonRepo.HppV2ProjectFlockKandangContext{
-			35: {
-				ProjectFlockKandangID: 35,
-				ProjectFlockID:        8,
-				ProjectFlockCategory:  "LAYING",
-				KandangID:             350,
-				KandangName:           "Kandang E",
-				LocationID:            20,
-			},
-		},
-		pfkIDsByProject: map[uint][]uint{
-			9: {901, 902},
-		},
-		totalPopulationByKey: map[string]float64{
-			stubKey([]uint{901, 902}, nil): 1000,
-		},
-		transferSummaryByPFK: map[uint]struct {
-			projectFlockID uint
-			totalQty       float64
-		}{
-			35: {projectFlockID: 9, totalQty: 250},
-		},
-		chickinRowsByKey: map[string][]commonRepo.HppV2ChickinCostRow{
-			chickinStubKey([]uint{901, 902}, []string{string(utils.FlagDOC)}, false): {
-				{ProjectChickinID: 1, ProjectFlockKandangID: 901, ChickInDate: mustTime(t, "2026-04-01"), StockableType: "purchase_items", StockableID: 1001, SourceProductID: 77, SourceProductName: "DOC", Qty: 1000, UnitPrice: 2, TotalCost: 2000},
-			},
-			chickinStubKey([]uint{35}, []string{string(utils.FlagPullet), string(utils.FlagLayer)}, true): {
-				{ProjectChickinID: 2, ProjectFlockKandangID: 35, ChickInDate: mustTime(t, "2026-04-15"), StockableType: "purchase_items", StockableID: 1002, SourceProductID: 78, SourceProductName: "Pullet", Qty: 50, UnitPrice: 20, TotalCost: 1000},
-			},
-		},
-		eggProductionByPFK: map[uint]struct {
-			pieces float64
-			kg     float64
-		}{
-			35: {pieces: 100, kg: 10},
-		},
-		eggSalesByPFK: map[uint]struct {
-			pieces float64
-			kg     float64
-		}{
-			35: {pieces: 80, kg: 8},
-		},
-	}
-
-	svc := NewHppV2Service(repo)
-	result, err := svc.CalculateHppBreakdown(35, mustDate(t, "2026-04-19"))
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	componentTotals := map[string]float64{}
-	for _, component := range result.Components {
-		componentTotals[component.Code] = component.Total
-	}
-
-	if componentTotals[hppV2ComponentDocChickin] != 500 {
-		t.Fatalf("expected doc chickin total 500, got %v", componentTotals[hppV2ComponentDocChickin])
-	}
-	if componentTotals[hppV2ComponentDirectPulletPurchase] != 1000 {
-		t.Fatalf("expected direct pullet purchase total 1000, got %v", componentTotals[hppV2ComponentDirectPulletPurchase])
-	}
-	if result.TotalPulletCost != 500 {
-		t.Fatalf("expected total pullet cost 500, got %v", result.TotalPulletCost)
-	}
-	if result.TotalProductionCost != 1000 {
-		t.Fatalf("expected total production cost 1000, got %v", result.TotalProductionCost)
-	}
-	if result.Hpp.Estimation.HargaKg != 100 {
-		t.Fatalf("expected estimation harga/kg 100, got %v", result.Hpp.Estimation.HargaKg)
-	}
-}
-
-func TestHppV2CalculateHppBreakdown_IncludesBopRegularAndEkspedisi(t *testing.T) {
-	repo := &hppV2RepoStub{
-		contextByPFK: map[uint]*commonRepo.HppV2ProjectFlockKandangContext{
-			40: {
-				ProjectFlockKandangID: 40,
-				ProjectFlockID:        6,
-				ProjectFlockCategory:  "LAYING",
-				KandangID:             400,
-				KandangName:           "Kandang D",
-				LocationID:            19,
-			},
-		},
-		pfkIDsByProject: map[uint][]uint{
-			6: {40, 41},
-			7: {701, 702},
-		},
-		totalPopulationByKey: map[string]float64{
-			stubKey([]uint{701, 702}, nil): 1000,
-		},
-		transferSummaryByPFK: map[uint]struct {
-			projectFlockID uint
-			totalQty       float64
-		}{
-			40: {projectFlockID: 7, totalQty: 200},
-		},
-		expenseRowsByPFKKey: map[string][]commonRepo.HppV2ExpenseCostRow{
-			expenseStubKey([]uint{701, 702}, false): {
-				{ExpenseRealizationID: 1, NonstockID: 11, NonstockName: "Growing BOP", Qty: 1, Price: 500, TotalCost: 500, RealizationDate: mustTime(t, "2026-04-10")},
-			},
-			expenseStubKey([]uint{40}, false): {
-				{ExpenseRealizationID: 2, NonstockID: 12, NonstockName: "Laying BOP", Qty: 1, Price: 80, TotalCost: 80, RealizationDate: mustTime(t, "2026-04-19")},
-			},
-			expenseStubKey([]uint{701, 702}, true): {
-				{ExpenseRealizationID: 3, NonstockID: 13, NonstockName: "Growing Expedition", Qty: 1, Price: 100, TotalCost: 100, RealizationDate: mustTime(t, "2026-04-11")},
-			},
-			expenseStubKey([]uint{40}, true): {
-				{ExpenseRealizationID: 4, NonstockID: 14, NonstockName: "Laying Expedition", Qty: 1, Price: 40, TotalCost: 40, RealizationDate: mustTime(t, "2026-04-19")},
-			},
-		},
-		expenseRowsByFarmKey: map[string][]commonRepo.HppV2ExpenseCostRow{
-			expenseFarmKey(7, false): {
-				{ExpenseRealizationID: 5, NonstockID: 15, NonstockName: "Growing Farm BOP", Qty: 1, Price: 300, TotalCost: 300, RealizationDate: mustTime(t, "2026-04-12")},
-			},
-			expenseFarmKey(6, false): {
-				{ExpenseRealizationID: 6, NonstockID: 16, NonstockName: "Laying Farm BOP", Qty: 1, Price: 100, TotalCost: 100, RealizationDate: mustTime(t, "2026-04-19")},
-			},
-			expenseFarmKey(7, true): {
-				{ExpenseRealizationID: 7, NonstockID: 17, NonstockName: "Growing Farm Expedition", Qty: 1, Price: 50, TotalCost: 50, RealizationDate: mustTime(t, "2026-04-12")},
-			},
-			expenseFarmKey(6, true): {
-				{ExpenseRealizationID: 8, NonstockID: 18, NonstockName: "Laying Farm Expedition", Qty: 1, Price: 60, TotalCost: 60, RealizationDate: mustTime(t, "2026-04-19")},
-			},
-		},
-		eggProductionByPFK: map[uint]struct {
-			pieces float64
-			kg     float64
-		}{
-			40: {pieces: 30, kg: 3},
-			41: {pieces: 70, kg: 7},
-		},
-		eggSalesByPFK: map[uint]struct {
-			pieces float64
-			kg     float64
-		}{
-			40: {pieces: 50, kg: 5},
-		},
-	}
-
-	svc := NewHppV2Service(repo)
-	result, err := svc.CalculateHppBreakdown(40, mustDate(t, "2026-04-19"))
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	componentTotals := map[string]float64{}
-	for _, component := range result.Components {
-		componentTotals[component.Code] = component.Total
-	}
-
-	if componentTotals[hppV2ComponentBopRegular] != 270 {
-		t.Fatalf("expected regular BOP total 270, got %v", componentTotals[hppV2ComponentBopRegular])
-	}
-	if componentTotals[hppV2ComponentBopEksp] != 88 {
-		t.Fatalf("expected expedition BOP total 88, got %v", componentTotals[hppV2ComponentBopEksp])
-	}
-	if result.TotalPulletCost != 190 {
-		t.Fatalf("expected total pullet cost 190, got %v", result.TotalPulletCost)
-	}
-	if result.TotalProductionCost != 168 {
-		t.Fatalf("expected total production cost 168, got %v", result.TotalProductionCost)
-	}
-	if result.Hpp.Estimation.HargaKg != 56 {
-		t.Fatalf("expected estimation harga/kg 56, got %v", result.Hpp.Estimation.HargaKg)
-	}
-}
-
-func TestHppV2CalculateHppBreakdown_AddsDepreciationForNormalTransfer(t *testing.T) {
-	sourceChickIn := mustTime(t, "2026-01-01")
-	reportDate := sourceChickIn.AddDate(0, 0, 154)
-
-	repo := &hppV2RepoStub{
-		contextByPFK: map[uint]*commonRepo.HppV2ProjectFlockKandangContext{
-			50: {
-				ProjectFlockKandangID: 50,
-				ProjectFlockID:        10,
-				ProjectFlockCategory:  "LAYING",
-				KandangID:             500,
-				KandangName:           "Kandang F",
-				LocationID:            21,
-				HouseType:             "close_house",
-			},
-		},
-		pfkIDsByProject: map[uint][]uint{
-			11: {501},
-		},
-		latestTransferByPFK: map[uint]*commonRepo.HppV2LatestTransferInputRow{
-			50: {
-				ProjectFlockKandangID: 50,
-				SourceProjectFlockID:  11,
-				TransferDate:          mustTime(t, "2026-05-20"),
-				TransferQty:           100,
-				TransferID:            701,
-			},
-		},
-		chickInDateByProject: map[uint]*time.Time{
-			11: &sourceChickIn,
-		},
-		depreciationByHouse: map[string]map[int]float64{
-			"close_house": {
-				1: 10,
-			},
-		},
-		usageRowsByKey: map[string][]commonRepo.HppV2UsageCostRow{
-			stubKey([]uint{501}, []string{"PAKAN"}): {
-				{StockableType: "purchase_items", StockableID: 9301, SourceProductID: 41, SourceProductName: "Pakan Growing", Qty: 25, UnitPrice: 40, TotalCost: 1000},
-			},
-		},
-		totalPopulationByKey: map[string]float64{
-			stubKey([]uint{501}, nil): 100,
-		},
-		transferSummaryByPFK: map[uint]struct {
-			projectFlockID uint
-			totalQty       float64
-		}{
-			50: {projectFlockID: 11, totalQty: 100},
-		},
-		eggProductionByPFK: map[uint]struct {
-			pieces float64
-			kg     float64
-		}{
-			50: {pieces: 20, kg: 10},
-		},
-	}
-
-	svc := NewHppV2Service(repo)
-	result, err := svc.CalculateHppBreakdown(50, &reportDate)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	if result.TotalPulletCost != 1000 {
-		t.Fatalf("expected total pullet cost 1000, got %v", result.TotalPulletCost)
-	}
-	if result.TotalProductionCost != 100 {
-		t.Fatalf("expected total production cost 100, got %v", result.TotalProductionCost)
-	}
-
-	var depreciation *HppV2Component
-	for i := range result.Components {
-		if result.Components[i].Code == hppV2ComponentDepreciation {
-			depreciation = &result.Components[i]
-			break
-		}
-	}
-	if depreciation == nil {
-		t.Fatal("expected depreciation component")
-	}
-	if depreciation.Total != 100 {
-		t.Fatalf("expected depreciation total 100, got %v", depreciation.Total)
-	}
-	if len(depreciation.Parts) != 1 {
-		t.Fatalf("expected single depreciation part, got %d", len(depreciation.Parts))
-	}
-	if depreciation.Parts[0].Details["schedule_day"] != 1 {
-		t.Fatalf("expected schedule day 1, got %+v", depreciation.Parts[0].Details)
-	}
-	if depreciation.Parts[0].Details["origin_date"] != "2026-01-01" {
-		t.Fatalf("expected origin date 2026-01-01, got %+v", depreciation.Parts[0].Details)
-	}
-	if result.Hpp.Estimation.HargaKg != 10 {
-		t.Fatalf("expected estimation harga/kg 10, got %v", result.Hpp.Estimation.HargaKg)
-	}
-}
-
-func TestHppV2CalculateHppBreakdown_AddsDepreciationForManualCutoverFromCutoverDate(t *testing.T) {
-	originDate := mustTime(t, "2026-01-01")
-	cutoverDate := originDate.AddDate(0, 0, 155)
-
-	repo := &hppV2RepoStub{
-		contextByPFK: map[uint]*commonRepo.HppV2ProjectFlockKandangContext{
-			60: {
-				ProjectFlockKandangID: 60,
-				ProjectFlockID:        12,
-				ProjectFlockCategory:  "LAYING",
-				KandangID:             600,
-				KandangName:           "Kandang G",
-				LocationID:            22,
-				HouseType:             "close_house",
-			},
-		},
-		pfkIDsByProject: map[uint][]uint{
-			12: {60},
-		},
-		manualInputByProject: map[uint]*commonRepo.HppV2ManualDepreciationInputRow{
-			12: {
-				ID:             801,
-				ProjectFlockID: 12,
-				TotalCost:      1000,
-				CutoverDate:    cutoverDate,
-			},
-		},
-		chickInDateByProject: map[uint]*time.Time{
-			12: &originDate,
-		},
-		depreciationByHouse: map[string]map[int]float64{
-			"close_house": {
-				1: 10,
-				2: 20,
-			},
-		},
-		totalPopulationByKey: map[string]float64{
-			stubKey([]uint{60}, nil): 100,
-		},
-		eggProductionByPFK: map[uint]struct {
-			pieces float64
-			kg     float64
-		}{
-			60: {pieces: 20, kg: 10},
-		},
-	}
-
-	svc := NewHppV2Service(repo)
-	result, err := svc.CalculateHppBreakdown(60, &cutoverDate)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	if result.TotalPulletCost != 1000 {
-		t.Fatalf("expected total pullet cost 1000, got %v", result.TotalPulletCost)
-	}
-	if result.TotalProductionCost != 200 {
-		t.Fatalf("expected total production cost 200, got %v", result.TotalProductionCost)
-	}
-
-	componentTotals := map[string]float64{}
-	for _, component := range result.Components {
-		componentTotals[component.Code] = component.Total
-	}
-	if componentTotals[hppV2ComponentManualPulletCost] != 1000 {
-		t.Fatalf("expected manual pullet cost 1000, got %v", componentTotals[hppV2ComponentManualPulletCost])
-	}
-	if componentTotals[hppV2ComponentDepreciation] != 200 {
-		t.Fatalf("expected depreciation 200, got %v", componentTotals[hppV2ComponentDepreciation])
-	}
-
-	var depreciation *HppV2Component
-	for i := range result.Components {
-		if result.Components[i].Code == hppV2ComponentDepreciation {
-			depreciation = &result.Components[i]
-			break
-		}
-	}
-	if depreciation == nil || len(depreciation.Parts) != 1 {
-		t.Fatalf("expected one depreciation part, got %+v", depreciation)
-	}
-	if depreciation.Parts[0].Details["schedule_day"] != 2 {
-		t.Fatalf("expected schedule day 2, got %+v", depreciation.Parts[0].Details)
-	}
-	if depreciation.Parts[0].Details["start_schedule_day"] != 2 {
-		t.Fatalf("expected start schedule day 2, got %+v", depreciation.Parts[0].Details)
-	}
-	if result.Hpp.Estimation.HargaKg != 20 {
-		t.Fatalf("expected estimation harga/kg 20, got %v", result.Hpp.Estimation.HargaKg)
-	}
-}
-
-func TestHppV2CalculateHppBreakdown_UsesFarmSnapshotDepreciationProratedByEggProduction(t *testing.T) {
-	reportDate := mustTime(t, "2026-06-05")
-
-	repo := &hppV2RepoStub{
-		contextByPFK: map[uint]*commonRepo.HppV2ProjectFlockKandangContext{
-			70: {
-				ProjectFlockKandangID: 70,
-				ProjectFlockID:        15,
-				ProjectFlockCategory:  "LAYING",
-				KandangID:             700,
-				KandangName:           "Kandang Snapshot",
-				LocationID:            25,
-				HouseType:             "close_house",
-			},
-		},
-		pfkIDsByProject: map[uint][]uint{
-			15: {70, 71},
-		},
-		snapshotByProjectKey: map[string]*commonRepo.HppV2FarmDepreciationSnapshotRow{
-			"15|2026-06-05": {
-				ID:                           901,
-				ProjectFlockID:               15,
-				PeriodDate:                   reportDate,
-				DepreciationPercentEffective: 10,
-				DepreciationValue:            1000,
-				PulletCostDayNTotal:          10000,
-			},
-		},
-		eggProductionByPFK: map[uint]struct {
-			pieces float64
-			kg     float64
-		}{
-			70: {pieces: 200, kg: 20},
-			71: {pieces: 800, kg: 80},
-		},
-	}
-
-	svc := NewHppV2Service(repo)
-	result, err := svc.CalculateHppBreakdown(70, &reportDate)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if result == nil {
-		t.Fatal("expected breakdown result")
-	}
-
-	var depreciation *HppV2Component
-	for i := range result.Components {
-		if result.Components[i].Code == hppV2ComponentDepreciation {
-			depreciation = &result.Components[i]
-			break
-		}
-	}
-	if depreciation == nil {
-		t.Fatal("expected depreciation component")
-	}
-	if depreciation.Total != 200 {
-		t.Fatalf("expected depreciation total 200, got %v", depreciation.Total)
-	}
-	if result.TotalProductionCost != 200 {
-		t.Fatalf("expected total production cost 200, got %v", result.TotalProductionCost)
-	}
-	if len(depreciation.Parts) != 1 {
-		t.Fatalf("expected one depreciation part, got %d", len(depreciation.Parts))
-	}
-	if depreciation.Parts[0].Code != hppV2PartDepreciationFarmSnapshot {
-		t.Fatalf("expected farm snapshot depreciation part, got %s", depreciation.Parts[0].Code)
-	}
-	if depreciation.Parts[0].Proration == nil || depreciation.Parts[0].Proration.Ratio != 0.2 {
-		t.Fatalf("expected proration ratio 0.2, got %+v", depreciation.Parts[0].Proration)
-	}
-	if depreciation.Parts[0].Details["snapshot_id"] != uint(901) {
-		t.Fatalf("expected snapshot id 901, got %+v", depreciation.Parts[0].Details)
-	}
-}
-
-func stubKey(ids []uint, flags []string) string {
-	idParts := make([]string, 0, len(ids))
-	for _, id := range ids {
-		idParts = append(idParts, fmt.Sprintf("%d", id))
-	}
-	sort.Strings(idParts)
-
-	flagParts := append([]string{}, flags...)
-	sort.Strings(flagParts)
-
-	return strings.Join(idParts, ",") + "|" + strings.Join(flagParts, ",")
-}
-
-func mustDate(t *testing.T, raw string) *time.Time {
-	t.Helper()
-	loc, err := time.LoadLocation("Asia/Jakarta")
-	if err != nil {
-		t.Fatalf("failed to load timezone: %v", err)
-	}
-	value, err := time.ParseInLocation("2006-01-02", raw, loc)
-	if err != nil {
-		t.Fatalf("failed to parse date %s: %v", raw, err)
-	}
-	return &value
-}
-
-func mustTime(t *testing.T, raw string) time.Time {
-	t.Helper()
-	value := mustDate(t, raw)
-	return *value
-}
-
-func expenseStubKey(ids []uint, ekspedisi bool) string {
-	return stubKey(ids, []string{fmt.Sprintf("ekspedisi=%t", ekspedisi)})
-}
-
-func expenseFarmKey(projectFlockID uint, ekspedisi bool) string {
-	return fmt.Sprintf("farm=%d|ekspedisi=%t", projectFlockID, ekspedisi)
-}
-
-func chickinStubKey(ids []uint, flags []string, excludeTransferToLaying bool) string {
-	return stubKey(ids, append(append([]string{}, flags...), fmt.Sprintf("exclude_transfer_to_laying=%t", excludeTransferToLaying)))
-}

internal/common/service/depreciation_snapshot_invalidator.service.go

@@ -1,103 +0,0 @@
-package service
-
-import (
-	"context"
-	"time"
-
-	"gorm.io/gorm"
-)
-
-const farmDepreciationSnapshotTable = "farm_depreciation_snapshots"
-
-func NormalizeDateOnlyUTC(value time.Time) time.Time {
-	if value.IsZero() {
-		return value
-	}
-	v := value.UTC()
-	return time.Date(v.Year(), v.Month(), v.Day(), 0, 0, 0, 0, time.UTC)
-}
-
-func MinNonZeroDateOnlyUTC(values ...time.Time) time.Time {
-	var out time.Time
-	for _, value := range values {
-		if value.IsZero() {
-			continue
-		}
-		normalized := NormalizeDateOnlyUTC(value)
-		if out.IsZero() || normalized.Before(out) {
-			out = normalized
-		}
-	}
-	return out
-}
-
-func InvalidateFarmDepreciationSnapshotsFromDate(ctx context.Context, db *gorm.DB, farmIDs []uint, fromDate time.Time) error {
-	if db == nil {
-		return nil
-	}
-	if fromDate.IsZero() {
-		return nil
-	}
-
-	fromDate = NormalizeDateOnlyUTC(fromDate)
-	query := db.WithContext(ctx).
-		Table(farmDepreciationSnapshotTable).
-		Where("period_date >= ?", fromDate)
-	if len(farmIDs) > 0 {
-		query = query.Where("project_flock_id IN ?", farmIDs)
-	}
-	return query.Delete(nil).Error
-}
-
-func ResolveProjectFlockIDsByProjectFlockKandangIDs(ctx context.Context, db *gorm.DB, pfkIDs []uint) ([]uint, error) {
-	if db == nil || len(pfkIDs) == 0 {
-		return []uint{}, nil
-	}
-
-	var projectFlockIDs []uint
-	if err := db.WithContext(ctx).
-		Table("project_flock_kandangs").
-		Distinct("project_flock_id").
-		Where("id IN ?", pfkIDs).
-		Pluck("project_flock_id", &projectFlockIDs).Error; err != nil {
-		return nil, err
-	}
-
-	return projectFlockIDs, nil
-}
-
-func ResolveProjectFlockIDsByExpenseID(ctx context.Context, db *gorm.DB, expenseID uint) ([]uint, error) {
-	if db == nil || expenseID == 0 {
-		return []uint{}, nil
-	}
-
-	query := `
-WITH direct_farms AS (
-	SELECT DISTINCT pfk.project_flock_id
-	FROM expense_nonstocks ens
-	JOIN project_flock_kandangs pfk ON pfk.id = ens.project_flock_kandang_id
-	WHERE ens.expense_id = @expense_id
-),
-json_farms AS (
-	SELECT DISTINCT (jsonb_array_elements_text(e.project_flock_id::jsonb))::bigint AS project_flock_id
-	FROM expenses e
-	WHERE e.id = @expense_id
-	  AND e.project_flock_id IS NOT NULL
-)
-SELECT DISTINCT project_flock_id
-FROM (
-	SELECT project_flock_id FROM direct_farms
-	UNION ALL
-	SELECT project_flock_id FROM json_farms
-) x
-`
-
-	var ids []uint
-	if err := db.WithContext(ctx).Raw(query, map[string]any{
-		"expense_id": expenseID,
-	}).Scan(&ids).Error; err != nil {
-		return nil, err
-	}
-
-	return ids, nil
-}

internal/common/service/fifo_pending_policy.go

@@ -1,104 +0,0 @@
-package service
-
-import (
-	"context"
-	"errors"
-	"strings"
-
-	"gorm.io/gorm"
-)
-
-type FifoPendingPolicyInput struct {
-	Lane          string
-	FlagGroupCode string
-	FunctionCode  string
-	LegacyTypeKey string
-}
-
-type FifoPendingPolicyResult struct {
-	AllowPending bool
-	RuleSource   string
-	Found        bool
-}
-
-func ResolveFifoPendingPolicy(ctx context.Context, tx *gorm.DB, input FifoPendingPolicyInput) (*FifoPendingPolicyResult, error) {
-	if tx == nil {
-		return nil, gorm.ErrInvalidDB
-	}
-
-	lane := strings.ToUpper(strings.TrimSpace(input.Lane))
-	flagGroupCode := strings.ToUpper(strings.TrimSpace(input.FlagGroupCode))
-	functionCode := strings.ToUpper(strings.TrimSpace(input.FunctionCode))
-	legacyTypeKey := strings.ToUpper(strings.TrimSpace(input.LegacyTypeKey))
-	if lane == "" {
-		return &FifoPendingPolicyResult{
-			AllowPending: false,
-			RuleSource:   "SAFE_DEFAULT_BLOCK",
-			Found:        false,
-		}, nil
-	}
-
-	type overconsumeRuleRow struct {
-		Allow bool `gorm:"column:allow_overconsume"`
-	}
-	var overconsume overconsumeRuleRow
-	overconsumeErr := tx.WithContext(ctx).
-		Table("fifo_stock_v2_overconsume_rules").
-		Select("allow_overconsume").
-		Where("is_active = TRUE").
-		Where("lane = ?", lane).
-		Where("(flag_group_code IS NULL OR flag_group_code = ?)", flagGroupCode).
-		Where("(function_code IS NULL OR function_code = ?)", functionCode).
-		Order("CASE WHEN flag_group_code IS NULL THEN 1 ELSE 0 END ASC").
-		Order("CASE WHEN function_code IS NULL THEN 1 ELSE 0 END ASC").
-		Order("priority ASC, id ASC").
-		Limit(1).
-		Take(&overconsume).Error
-	if overconsumeErr == nil {
-		return &FifoPendingPolicyResult{
-			AllowPending: overconsume.Allow,
-			RuleSource:   "OVERCONSUME_RULE",
-			Found:        true,
-		}, nil
-	}
-	if !errors.Is(overconsumeErr, gorm.ErrRecordNotFound) {
-		return nil, overconsumeErr
-	}
-
-	type routeRuleRow struct {
-		AllowPendingDefault bool `gorm:"column:allow_pending_default"`
-	}
-	var routeRule routeRuleRow
-	routeQuery := tx.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules").
-		Select("allow_pending_default").
-		Where("is_active = TRUE").
-		Where("lane = ?", lane).
-		Where("flag_group_code = ?", flagGroupCode)
-	if legacyTypeKey != "" {
-		routeQuery = routeQuery.Where("legacy_type_key = ?", legacyTypeKey)
-	}
-	if functionCode != "" {
-		routeQuery = routeQuery.Where("function_code = ?", functionCode)
-	}
-	routeErr := routeQuery.
-		Order("id ASC").
-		Limit(1).
-		Take(&routeRule).Error
-	if routeErr == nil {
-		return &FifoPendingPolicyResult{
-			AllowPending: routeRule.AllowPendingDefault,
-			RuleSource:   "ROUTE_RULE_DEFAULT",
-			Found:        true,
-		}, nil
-	}
-	if !errors.Is(routeErr, gorm.ErrRecordNotFound) {
-		return nil, routeErr
-	}
-
-	return &FifoPendingPolicyResult{
-		AllowPending: false,
-		RuleSource:   "SAFE_DEFAULT_BLOCK",
-		Found:        false,
-	}, nil
-}

internal/common/service/fifo_stock_v2/RFC.md

@@ -1,58 +0,0 @@
-# RFC Ringkas: FIFO Stock V2
-
-## Tujuan
-`fifo_stock_v2` adalah engine FIFO baru berbasis konfigurasi `Flag Group + Jalur` yang berjalan paralel dengan v1 tanpa memutus kompatibilitas `stock_allocations`, HPP, dan closing/reporting existing.
-
-## Prinsip
-- V1 tidak dihapus, V2 jalan paralel.
-- Semua operasi transactional.
-- FIFO sorting deterministic lintas tabel.
-- Default over-consume `ALLOW` (pending), exception dapat `BLOCK`.
-- Reflow idempotent.
-- Recalculate bisa memperbaiki drift `product_warehouses.qty`.
-
-## Komponen
-- `fifo_stock_v2_flag_groups`: master grouping flag produk.
-- `fifo_stock_v2_flag_members`: pemetaan flag -> group.
-- `fifo_stock_v2_traits`: trait sort per `table:date_column` (+ optional join date source).
-- `fifo_stock_v2_route_rules`: rule per `flag_group + lane + function + table`.
-- `fifo_stock_v2_overconsume_rules`: policy pending/over-consume.
-- `fifo_stock_v2_operation_log`: idempotency + audit operasi.
-- `fifo_stock_v2_reflow_runs` + checkpoints + shadow allocations: bulk reflow resumable/observable.
-
-## API Service
-- `Gather`: union cross-table berdasarkan route rules + trait sorting.
-- `Allocate`: alokasi lot FIFO ke usable.
-- `Rollback`: batalkan alokasi aktif.
-- `Reflow`: rollback penuh lalu allocate ulang (idempotent).
-- `Recalculate`: rekonsiliasi qty warehouse dari ledger FIFO.
-
-## Deterministic Sorting
-Urutan gather:
-1. `sort_at ASC` (dari trait `date_column`)
-2. `sort_priority ASC`
-3. `source_table ASC`
-4. `source_id ASC`
-
-Fallback waktu: `1970-01-01 00:00:00+00` bila tanggal null.
-
-## Compat Strategy
-- Tetap menulis ke `stock_allocations` dengan tambahan metadata:
-  - `engine_version` (`v1`/`v2`)
-  - `flag_group_code`
-  - `function_code`
-  - `idempotency_key`
-- Query lama yang bergantung `stockable_type/usable_type` tetap berjalan.
-
-## Migration Strategy
-1. Deploy schema + seed v2.
-2. Aktifkan shadow-run comparator v1 vs v2.
-3. Canary cutover per flag group.
-4. Full cutover jika parity aman.
-5. Jalankan bulk reflow existing data.
-
-## Acceptance Criteria Singkat
-- Parity mismatch terkendali pada aggregate + detail alokasi.
-- Tidak ada regression closing/HPP.
-- Drift qty warehouse turun signifikan pasca reflow.
-- Rollback via feature flag memungkinkan kembali ke v1.

internal/common/service/fifo_stock_v2/allocate.go

@@ -1,802 +0,0 @@
-package fifo_stock_v2
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"math"
-	"strings"
-	"time"
-
-	"gorm.io/gorm"
-)
-
-type allocationRow struct {
-	ID                 uint      `gorm:"column:id"`
-	ProductWarehouseID uint      `gorm:"column:product_warehouse_id"`
-	StockableType      string    `gorm:"column:stockable_type"`
-	StockableID        uint      `gorm:"column:stockable_id"`
-	UsableType         string    `gorm:"column:usable_type"`
-	UsableID           uint      `gorm:"column:usable_id"`
-	Qty                float64   `gorm:"column:qty"`
-	Status             string    `gorm:"column:status"`
-	CreatedAt          time.Time `gorm:"column:created_at"`
-}
-
-type usableQtySnapshot struct {
-	Usage   float64 `gorm:"column:usage_qty"`
-	Pending float64 `gorm:"column:pending_qty"`
-}
-
-func (s *fifoStockV2Service) Allocate(ctx context.Context, req AllocateRequest) (*AllocateResult, error) {
-	if err := s.validateAllocateRequest(req); err != nil {
-		return nil, err
-	}
-
-	result := &AllocateResult{}
-	err := s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
-		if err := s.ensureStockAllocationColumns(tx); err != nil {
-			return err
-		}
-		if err := s.lockShard(tx, req.FlagGroupCode, req.ProductWarehouseID); err != nil {
-			return err
-		}
-
-		hash := requestHash(map[string]any{
-			"flag_group_code":      req.FlagGroupCode,
-			"product_warehouse_id": req.ProductWarehouseID,
-			"usable_type":          req.Usable.LegacyTypeKey,
-			"usable_id":            req.Usable.ID,
-			"need_qty":             req.NeedQty,
-			"as_of":                req.AsOf,
-			"allow_over_consume":   req.AllowOverConsume,
-		})
-		logRow, reused, err := s.beginOperation(
-			tx,
-			OperationAllocate,
-			req.IdempotencyKey,
-			hash,
-			req.ProductWarehouseID,
-			req.FlagGroupCode,
-			req.Usable.LegacyTypeKey,
-			req.Usable.ID,
-		)
-		if err != nil {
-			return err
-		}
-		if reused {
-			if len(logRow.ResultPayload) == 0 {
-				return fmt.Errorf("idempotent allocate has empty payload")
-			}
-			if err := json.Unmarshal(logRow.ResultPayload, result); err != nil {
-				return err
-			}
-			return nil
-		}
-		if logRow != nil {
-			defer func() {
-				if err != nil {
-					s.failOperation(tx, logRow, err)
-				}
-			}()
-		}
-
-		allocated, allocErr := s.allocateInternal(ctx, tx, req)
-		if allocErr != nil {
-			err = allocErr
-			return allocErr
-		}
-		*result = *allocated
-
-		if finishErr := s.finishOperation(tx, logRow, result); finishErr != nil {
-			err = finishErr
-			return finishErr
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-func (s *fifoStockV2Service) allocateInternal(ctx context.Context, tx *gorm.DB, req AllocateRequest) (*AllocateResult, error) {
-	usableRule, err := s.loadRouteRuleByLegacyType(ctx, tx, LaneUsable, req.FlagGroupCode, req.Usable.LegacyTypeKey)
-	if err != nil {
-		return nil, err
-	}
-
-	allowOverConsume := usableRule.AllowPendingDefault
-	if req.AllowOverConsume != nil {
-		allowOverConsume = *req.AllowOverConsume
-	} else {
-		allowOverConsume, err = s.resolveOverConsume(tx, req.FlagGroupCode, req.Usable.FunctionCode, LaneUsable, allowOverConsume)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	gatherRows, err := s.gatherRows(ctx, tx, GatherRequest{
-		FlagGroupCode:      req.FlagGroupCode,
-		Lane:               LaneStockable,
-		ProductWarehouseID: req.ProductWarehouseID,
-		AsOf:               req.AsOf,
-		Limit:              s.defaultGatherLimit,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	stockableRuleMap, err := s.loadStockableRuleMap(ctx, tx, req.FlagGroupCode)
-	if err != nil {
-		return nil, err
-	}
-
-	now := time.Now()
-	remaining := req.NeedQty
-	result := &AllocateResult{Details: make([]AllocationDetail, 0)}
-
-	for _, lot := range gatherRows {
-		if remaining <= 0 {
-			break
-		}
-		if shouldSkipStockableForUsable(req, lot.Ref.LegacyTypeKey) {
-			continue
-		}
-		if lot.AvailableQuantity <= 0 {
-			continue
-		}
-		portion := math.Min(remaining, lot.AvailableQuantity)
-		if nearlyZero(portion) {
-			continue
-		}
-
-		allocationInsert := map[string]any{
-			"product_warehouse_id": req.ProductWarehouseID,
-			"stockable_type":       lot.Ref.LegacyTypeKey,
-			"stockable_id":         lot.Ref.ID,
-			"usable_type":          req.Usable.LegacyTypeKey,
-			"usable_id":            req.Usable.ID,
-			"qty":                  portion,
-			"status":               activeAllocationStatus(),
-			"allocation_purpose":   defaultAllocationPurpose(),
-			"created_at":           now,
-			"updated_at":           now,
-			"engine_version":       "v2",
-			"flag_group_code":      req.FlagGroupCode,
-			"function_code":        req.Usable.FunctionCode,
-		}
-		if strings.TrimSpace(req.IdempotencyKey) != "" {
-			allocationInsert["idempotency_key"] = req.IdempotencyKey
-		}
-		if err := tx.Table("stock_allocations").Create(allocationInsert).Error; err != nil {
-			return nil, err
-		}
-
-		rule, ok := stockableRuleMap[lot.Ref.LegacyTypeKey]
-		if !ok {
-			return nil, fmt.Errorf("missing stockable route rule for type %s", lot.Ref.LegacyTypeKey)
-		}
-		if err := s.adjustStockableUsedQuantity(tx, rule, lot.Ref.ID, portion); err != nil {
-			return nil, err
-		}
-
-		result.Details = append(result.Details, AllocationDetail{
-			StockableType: lot.Ref.LegacyTypeKey,
-			StockableID:   lot.Ref.ID,
-			Qty:           portion,
-			SortAt:        lot.SortAt,
-		})
-
-		remaining -= portion
-		result.AllocatedQty += portion
-	}
-
-	if remaining > 0 {
-		if !allowOverConsume {
-			return nil, fmt.Errorf("%w: requested %.3f, allocated %.3f", ErrInsufficientStock, req.NeedQty, result.AllocatedQty)
-		}
-		result.PendingQty = remaining
-	}
-
-	if err := s.applyUsableDeltas(tx, *usableRule, req.Usable.ID, result.AllocatedQty, result.PendingQty); err != nil {
-		return nil, err
-	}
-	if err := s.adjustProductWarehouseQty(tx, req.ProductWarehouseID, -result.AllocatedQty); err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}
-
-func shouldSkipStockableForUsable(req AllocateRequest, stockableType string) bool {
-	usableType := strings.ToUpper(strings.TrimSpace(req.Usable.LegacyTypeKey))
-	functionCode := strings.ToUpper(strings.TrimSpace(req.Usable.FunctionCode))
-	stockable := strings.ToUpper(strings.TrimSpace(stockableType))
-
-	// CHICKIN_OUT must consume physical stock sources, not population lots,
-	// otherwise approved chickin can consume its own just-created population.
-	if (usableType == "PROJECT_CHICKIN" || functionCode == "CHICKIN_OUT") && stockable == "PROJECT_FLOCK_POPULATION" {
-		return true
-	}
-	if (usableType == "STOCK_TRANSFER_OUT" || functionCode == "STOCK_TRANSFER_OUT") && stockable == "PROJECT_FLOCK_POPULATION" {
-		return true
-	}
-
-	return false
-}
-
-func (s *fifoStockV2Service) Rollback(ctx context.Context, req RollbackRequest) (*RollbackResult, error) {
-	if err := s.validateRollbackRequest(req); err != nil {
-		return nil, err
-	}
-
-	result := &RollbackResult{}
-	err := s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
-		if err := s.ensureStockAllocationColumns(tx); err != nil {
-			return err
-		}
-
-		flagGroupCode, err := s.resolveRollbackFlagGroup(ctx, tx, req)
-		if err != nil {
-			return err
-		}
-		if err := s.lockShard(tx, flagGroupCode, req.ProductWarehouseID); err != nil {
-			return err
-		}
-
-		hash := requestHash(map[string]any{
-			"product_warehouse_id": req.ProductWarehouseID,
-			"usable_type":          req.Usable.LegacyTypeKey,
-			"usable_id":            req.Usable.ID,
-			"release_qty":          req.ReleaseQty,
-			"reason":               req.Reason,
-			"flag_group_code":      flagGroupCode,
-		})
-		logRow, reused, beginErr := s.beginOperation(
-			tx,
-			OperationRollback,
-			req.IdempotencyKey,
-			hash,
-			req.ProductWarehouseID,
-			flagGroupCode,
-			req.Usable.LegacyTypeKey,
-			req.Usable.ID,
-		)
-		if beginErr != nil {
-			return beginErr
-		}
-		if reused {
-			if len(logRow.ResultPayload) == 0 {
-				return fmt.Errorf("idempotent rollback has empty payload")
-			}
-			if err := json.Unmarshal(logRow.ResultPayload, result); err != nil {
-				return err
-			}
-			return nil
-		}
-		if logRow != nil {
-			defer func() {
-				if err != nil {
-					s.failOperation(tx, logRow, err)
-				}
-			}()
-		}
-
-		rolled, rollbackErr := s.rollbackInternal(ctx, tx, req, flagGroupCode)
-		if rollbackErr != nil {
-			err = rollbackErr
-			return rollbackErr
-		}
-		*result = *rolled
-
-		if finishErr := s.finishOperation(tx, logRow, result); finishErr != nil {
-			err = finishErr
-			return finishErr
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-func (s *fifoStockV2Service) rollbackInternal(
-	ctx context.Context,
-	tx *gorm.DB,
-	req RollbackRequest,
-	flagGroupCode string,
-) (*RollbackResult, error) {
-	usableRule, err := s.loadRouteRuleByLegacyType(ctx, tx, LaneUsable, flagGroupCode, req.Usable.LegacyTypeKey)
-	if err != nil {
-		return nil, err
-	}
-
-	allocations, err := s.loadActiveAllocations(tx, req.Usable.LegacyTypeKey, req.Usable.ID, req.ProductWarehouseID)
-	if err != nil {
-		return nil, err
-	}
-	if len(allocations) == 0 {
-		if req.ReleaseQty == nil {
-			if err := s.resetUsableQuantities(tx, *usableRule, req.Usable.ID); err != nil {
-				return nil, err
-			}
-		}
-		return &RollbackResult{}, nil
-	}
-
-	stockableRuleMap, err := s.loadStockableRuleMap(ctx, tx, flagGroupCode)
-	if err != nil {
-		return nil, err
-	}
-
-	target := 0.0
-	for _, alloc := range allocations {
-		target += alloc.Qty
-	}
-	if req.ReleaseQty != nil {
-		if *req.ReleaseQty < 0 {
-			return nil, fmt.Errorf("%w: release qty must be >= 0", ErrInvalidRequest)
-		}
-		target = *req.ReleaseQty
-	}
-	if nearlyZero(target) {
-		return &RollbackResult{}, nil
-	}
-
-	result := &RollbackResult{Details: make([]AllocationDetail, 0)}
-	now := time.Now()
-	remaining := target
-
-	for _, alloc := range allocations {
-		if remaining <= 0 {
-			break
-		}
-		portion := math.Min(remaining, alloc.Qty)
-		if nearlyZero(portion) {
-			continue
-		}
-
-		if nearlyZero(alloc.Qty - portion) {
-			updates := map[string]any{
-				"status":      releasedAllocationStatus(),
-				"released_at": now,
-				"updated_at":  now,
-			}
-			if strings.TrimSpace(req.Reason) != "" {
-				updates["note"] = req.Reason
-			}
-			if err := tx.Table("stock_allocations").Where("id = ?", alloc.ID).Updates(updates).Error; err != nil {
-				return nil, err
-			}
-		} else {
-			if err := tx.Table("stock_allocations").
-				Where("id = ?", alloc.ID).
-				Updates(map[string]any{
-					"qty":        alloc.Qty - portion,
-					"updated_at": now,
-				}).Error; err != nil {
-				return nil, err
-			}
-		}
-
-		stockableRule, ok := stockableRuleMap[alloc.StockableType]
-		if !ok {
-			return nil, fmt.Errorf("missing stockable route rule for type %s", alloc.StockableType)
-		}
-		if err := s.adjustStockableUsedQuantity(tx, stockableRule, alloc.StockableID, -portion); err != nil {
-			return nil, err
-		}
-
-		result.ReleasedQty += portion
-		remaining -= portion
-		result.Details = append(result.Details, AllocationDetail{
-			StockableType: alloc.StockableType,
-			StockableID:   alloc.StockableID,
-			Qty:           portion,
-			SortAt:        alloc.CreatedAt,
-		})
-	}
-
-	if req.ReleaseQty != nil && remaining > 1e-6 {
-		return nil, fmt.Errorf("unable to release %.3f; only %.3f allocation exists", target, result.ReleasedQty)
-	}
-
-	if req.ReleaseQty == nil {
-		if err := s.resetUsableQuantities(tx, *usableRule, req.Usable.ID); err != nil {
-			return nil, err
-		}
-	} else {
-		if err := s.applyUsableDeltas(tx, *usableRule, req.Usable.ID, -result.ReleasedQty, 0); err != nil {
-			return nil, err
-		}
-	}
-
-	if err := s.adjustProductWarehouseQty(tx, req.ProductWarehouseID, result.ReleasedQty); err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}
-
-func (s *fifoStockV2Service) Reflow(ctx context.Context, req ReflowRequest) (*ReflowResult, error) {
-	if strings.TrimSpace(req.FlagGroupCode) == "" || req.ProductWarehouseID == 0 {
-		return nil, fmt.Errorf("%w: invalid reflow request", ErrInvalidRequest)
-	}
-
-	result := &ReflowResult{}
-	err := s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
-		if err := s.ensureStockAllocationColumns(tx); err != nil {
-			return err
-		}
-		if err := s.lockShard(tx, req.FlagGroupCode, req.ProductWarehouseID); err != nil {
-			return err
-		}
-
-		hash := requestHash(map[string]any{
-			"flag_group_code":      req.FlagGroupCode,
-			"product_warehouse_id": req.ProductWarehouseID,
-			"as_of":                req.AsOf,
-		})
-		logRow, reused, err := s.beginOperation(
-			tx,
-			OperationReflow,
-			req.IdempotencyKey,
-			hash,
-			req.ProductWarehouseID,
-			req.FlagGroupCode,
-			"",
-			0,
-		)
-		if err != nil {
-			return err
-		}
-		if reused {
-			if len(logRow.ResultPayload) == 0 {
-				return fmt.Errorf("idempotent reflow has empty payload")
-			}
-			if err := json.Unmarshal(logRow.ResultPayload, result); err != nil {
-				return err
-			}
-			return nil
-		}
-		if logRow != nil {
-			defer func() {
-				if err != nil {
-					s.failOperation(tx, logRow, err)
-				}
-			}()
-		}
-
-		usableRows, gatherErr := s.gatherAllRows(ctx, tx, GatherRequest{
-			FlagGroupCode:      req.FlagGroupCode,
-			Lane:               LaneUsable,
-			ProductWarehouseID: req.ProductWarehouseID,
-			Limit:              s.defaultGatherLimit,
-		})
-		if gatherErr != nil {
-			err = gatherErr
-			return gatherErr
-		}
-		result.ProcessedUsables = len(usableRows)
-
-		for _, usableRow := range usableRows {
-			desiredQty := usableRow.Quantity + usableRow.PendingQuantity
-
-			rollbackRes, rollbackErr := s.rollbackInternal(ctx, tx, RollbackRequest{
-				ProductWarehouseID: req.ProductWarehouseID,
-				Usable:             usableRow.Ref,
-				ReleaseQty:         nil,
-				Reason:             "reflow reset",
-			}, req.FlagGroupCode)
-			if rollbackErr != nil {
-				err = rollbackErr
-				return rollbackErr
-			}
-			result.Rollback.ReleasedQty += rollbackRes.ReleasedQty
-			if len(rollbackRes.Details) > 0 {
-				result.Rollback.Details = append(result.Rollback.Details, rollbackRes.Details...)
-			}
-
-			if desiredQty <= 0 {
-				continue
-			}
-			allocateRes, allocateErr := s.allocateInternal(ctx, tx, AllocateRequest{
-				FlagGroupCode:      req.FlagGroupCode,
-				ProductWarehouseID: req.ProductWarehouseID,
-				Usable:             usableRow.Ref,
-				NeedQty:            desiredQty,
-				AsOf:               nil,
-			})
-			if allocateErr != nil {
-				err = allocateErr
-				return allocateErr
-			}
-			result.Allocate.AllocatedQty += allocateRes.AllocatedQty
-			result.Allocate.PendingQty += allocateRes.PendingQty
-			if len(allocateRes.Details) > 0 {
-				result.Allocate.Details = append(result.Allocate.Details, allocateRes.Details...)
-			}
-		}
-
-		expectedQty, calcErr := s.calculateWarehouseAvailableForGroup(ctx, tx, req.ProductWarehouseID, req.FlagGroupCode, nil)
-		if calcErr != nil {
-			err = calcErr
-			return calcErr
-		}
-		actualQty, loadErr := s.loadWarehouseQty(ctx, tx, req.ProductWarehouseID)
-		if loadErr != nil {
-			err = loadErr
-			return loadErr
-		}
-		drift := expectedQty - actualQty
-		if math.Abs(drift) >= 1e-6 {
-			if adjustErr := s.adjustProductWarehouseQty(tx, req.ProductWarehouseID, drift); adjustErr != nil {
-				err = adjustErr
-				return adjustErr
-			}
-		}
-
-		if finishErr := s.finishOperation(tx, logRow, result); finishErr != nil {
-			err = finishErr
-			return finishErr
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-func (s *fifoStockV2Service) gatherAllRows(
-	ctx context.Context,
-	tx *gorm.DB,
-	req GatherRequest,
-) ([]GatherRow, error) {
-	limit := req.Limit
-	if limit <= 0 {
-		limit = s.defaultGatherLimit
-	}
-	if limit <= 0 {
-		limit = 1000
-	}
-
-	req.Limit = limit
-	out := make([]GatherRow, 0, limit)
-
-	var cursorSortAt *time.Time
-	cursorSourceTable := ""
-	var cursorSourceID uint
-
-	for {
-		req.AfterSortAt = cursorSortAt
-		req.AfterSourceTable = cursorSourceTable
-		req.AfterSourceID = cursorSourceID
-
-		rows, err := s.gatherRows(ctx, tx, req)
-		if err != nil {
-			return nil, err
-		}
-		if len(rows) == 0 {
-			break
-		}
-
-		out = append(out, rows...)
-		if len(rows) < limit {
-			break
-		}
-
-		last := rows[len(rows)-1]
-		lastSortAt := last.SortAt
-		cursorSortAt = &lastSortAt
-		cursorSourceTable = last.SourceTable
-		cursorSourceID = last.SourceID
-	}
-
-	return out, nil
-}
-
-func (s *fifoStockV2Service) loadActiveAllocations(
-	tx *gorm.DB,
-	usableType string,
-	usableID uint,
-	productWarehouseID uint,
-) ([]allocationRow, error) {
-	query := tx.Table("stock_allocations").
-		Select("id, product_warehouse_id, stockable_type, stockable_id, usable_type, usable_id, qty, status, created_at").
-		Where("usable_type = ? AND usable_id = ? AND status = ? AND allocation_purpose = ?", usableType, usableID, activeAllocationStatus(), defaultAllocationPurpose())
-	if productWarehouseID > 0 {
-		query = query.Where("product_warehouse_id = ?", productWarehouseID)
-	}
-	query = query.Order("created_at DESC, id DESC")
-
-	var rows []allocationRow
-	if err := query.Find(&rows).Error; err != nil {
-		return nil, err
-	}
-	return rows, nil
-}
-
-func (s *fifoStockV2Service) loadStockableRuleMap(ctx context.Context, tx *gorm.DB, flagGroupCode string) (map[string]routeRule, error) {
-	rules, err := s.loadRouteRules(ctx, tx, flagGroupCode, LaneStockable)
-	if err != nil {
-		return nil, err
-	}
-	m := make(map[string]routeRule, len(rules))
-	for _, rule := range rules {
-		m[rule.LegacyTypeKey] = rule
-	}
-	return m, nil
-}
-
-func (s *fifoStockV2Service) adjustStockableUsedQuantity(tx *gorm.DB, rule routeRule, sourceID uint, delta float64) error {
-	if nearlyZero(delta) || sourceID == 0 {
-		return nil
-	}
-	if rule.UsedQuantityCol == nil || strings.TrimSpace(*rule.UsedQuantityCol) == "" {
-		return nil
-	}
-
-	usedCol, _ := mustSafeIdentifier(*rule.UsedQuantityCol)
-	sourceIDCol, _ := mustSafeIdentifier(rule.SourceIDColumn)
-	sourceTable, _ := mustSafeIdentifier(rule.SourceTable)
-
-	expr := fmt.Sprintf("GREATEST(0, COALESCE(%s,0) + ?)", usedCol)
-	return tx.Table(sourceTable).
-		Where(fmt.Sprintf("%s = ?", sourceIDCol), sourceID).
-		Update(usedCol, gorm.Expr(expr, delta)).Error
-}
-
-func (s *fifoStockV2Service) applyUsableDeltas(tx *gorm.DB, rule routeRule, sourceID uint, usageDelta, pendingDelta float64) error {
-	if sourceID == 0 || (nearlyZero(usageDelta) && nearlyZero(pendingDelta)) {
-		return nil
-	}
-	sourceTable, _ := mustSafeIdentifier(rule.SourceTable)
-	sourceIDCol, _ := mustSafeIdentifier(rule.SourceIDColumn)
-	usageCol, _ := mustSafeIdentifier(rule.QuantityCol)
-
-	updates := map[string]any{}
-	if !nearlyZero(usageDelta) {
-		expr := fmt.Sprintf("GREATEST(0, COALESCE(%s,0) + ?)", usageCol)
-		updates[usageCol] = gorm.Expr(expr, usageDelta)
-	}
-	if rule.PendingQuantityCol != nil && strings.TrimSpace(*rule.PendingQuantityCol) != "" && !nearlyZero(pendingDelta) {
-		pendingCol, _ := mustSafeIdentifier(*rule.PendingQuantityCol)
-		expr := fmt.Sprintf("GREATEST(0, COALESCE(%s,0) + ?)", pendingCol)
-		updates[pendingCol] = gorm.Expr(expr, pendingDelta)
-	}
-	if len(updates) == 0 {
-		return nil
-	}
-
-	return tx.Table(sourceTable).
-		Where(fmt.Sprintf("%s = ?", sourceIDCol), sourceID).
-		Updates(updates).Error
-}
-
-func (s *fifoStockV2Service) resetUsableQuantities(tx *gorm.DB, rule routeRule, sourceID uint) error {
-	if sourceID == 0 {
-		return nil
-	}
-	sourceTable, _ := mustSafeIdentifier(rule.SourceTable)
-	sourceIDCol, _ := mustSafeIdentifier(rule.SourceIDColumn)
-	usageCol, _ := mustSafeIdentifier(rule.QuantityCol)
-
-	updates := map[string]any{usageCol: 0}
-	if rule.PendingQuantityCol != nil && strings.TrimSpace(*rule.PendingQuantityCol) != "" {
-		pendingCol, _ := mustSafeIdentifier(*rule.PendingQuantityCol)
-		updates[pendingCol] = 0
-	}
-
-	return tx.Table(sourceTable).
-		Where(fmt.Sprintf("%s = ?", sourceIDCol), sourceID).
-		Updates(updates).Error
-}
-
-func (s *fifoStockV2Service) resolveRollbackFlagGroup(ctx context.Context, tx *gorm.DB, req RollbackRequest) (string, error) {
-	type row struct {
-		FlagGroupCode string `gorm:"column:flag_group_code"`
-	}
-	var latest row
-	latestQuery := tx.WithContext(ctx).
-		Table("stock_allocations").
-		Select("flag_group_code").
-		Where("usable_type = ? AND usable_id = ?", req.Usable.LegacyTypeKey, req.Usable.ID).
-		Where("engine_version = 'v2'").
-		Where("allocation_purpose = ?", defaultAllocationPurpose()).
-		Where("flag_group_code IS NOT NULL AND flag_group_code <> ''")
-	if code := strings.TrimSpace(req.Usable.FunctionCode); code != "" {
-		latestQuery = latestQuery.Where("function_code = ?", code)
-	}
-	err := latestQuery.Order("id DESC").Limit(1).Take(&latest).Error
-	if err == nil && strings.TrimSpace(latest.FlagGroupCode) != "" {
-		return latest.FlagGroupCode, nil
-	}
-	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-		return "", err
-	}
-
-	rulesQuery := tx.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules").
-		Where("is_active = TRUE").
-		Where("lane = ?", string(LaneUsable)).
-		Where("legacy_type_key = ?", req.Usable.LegacyTypeKey)
-	if code := strings.TrimSpace(req.Usable.FunctionCode); code != "" {
-		rulesQuery = rulesQuery.Where("function_code = ?", code)
-	}
-
-	var rules []routeRule
-	err = rulesQuery.Find(&rules).Error
-	if err != nil {
-		return "", err
-	}
-	if len(rules) == 0 {
-		return "", fmt.Errorf("cannot resolve flag group for usable type %s", req.Usable.LegacyTypeKey)
-	}
-	if len(rules) > 1 && req.ProductWarehouseID != 0 {
-		type candidateRow struct {
-			FlagGroupCode string `gorm:"column:flag_group_code"`
-		}
-		var candidates []candidateRow
-		byProductQuery := tx.WithContext(ctx).
-			Table("fifo_stock_v2_route_rules rr").
-			Select("DISTINCT rr.flag_group_code").
-			Joins("JOIN fifo_stock_v2_flag_groups fg ON fg.code = rr.flag_group_code AND fg.is_active = TRUE").
-			Where("rr.is_active = TRUE").
-			Where("rr.lane = ?", string(LaneUsable)).
-			Where("rr.legacy_type_key = ?", req.Usable.LegacyTypeKey).
-			Where(`
-				EXISTS (
-					SELECT 1
-					FROM product_warehouses pw
-					JOIN flags f ON f.flagable_id = pw.product_id
-					JOIN fifo_stock_v2_flag_members fm ON fm.flag_name = f.name AND fm.is_active = TRUE
-					WHERE pw.id = ?
-					  AND f.flagable_type = 'products'
-					  AND fm.flag_group_code = rr.flag_group_code
-				)
-			`, req.ProductWarehouseID)
-		if code := strings.TrimSpace(req.Usable.FunctionCode); code != "" {
-			byProductQuery = byProductQuery.Where("rr.function_code = ?", code)
-		}
-		if err := byProductQuery.Order("rr.flag_group_code ASC").Scan(&candidates).Error; err != nil {
-			return "", err
-		}
-		if len(candidates) == 1 {
-			return strings.TrimSpace(candidates[0].FlagGroupCode), nil
-		}
-	}
-	if len(rules) > 1 {
-		return "", fmt.Errorf("ambiguous rollback flag group for usable type %s", req.Usable.LegacyTypeKey)
-	}
-	return rules[0].FlagGroupCode, nil
-}
-
-func (s *fifoStockV2Service) validateAllocateRequest(req AllocateRequest) error {
-	if strings.TrimSpace(req.FlagGroupCode) == "" || req.ProductWarehouseID == 0 {
-		return fmt.Errorf("%w: missing flag group or product warehouse", ErrInvalidRequest)
-	}
-	if req.Usable.ID == 0 || strings.TrimSpace(req.Usable.LegacyTypeKey) == "" {
-		return fmt.Errorf("%w: usable id and type are required", ErrInvalidRequest)
-	}
-	if req.NeedQty < 0 {
-		return fmt.Errorf("%w: need qty must be >= 0", ErrInvalidRequest)
-	}
-	return nil
-}
-
-func (s *fifoStockV2Service) validateRollbackRequest(req RollbackRequest) error {
-	if req.ProductWarehouseID == 0 {
-		return fmt.Errorf("%w: product warehouse is required", ErrInvalidRequest)
-	}
-	if req.Usable.ID == 0 || strings.TrimSpace(req.Usable.LegacyTypeKey) == "" {
-		return fmt.Errorf("%w: usable id and type are required", ErrInvalidRequest)
-	}
-	if req.ReleaseQty != nil && *req.ReleaseQty < 0 {
-		return fmt.Errorf("%w: release qty must be >= 0", ErrInvalidRequest)
-	}
-	return nil
-}

internal/common/service/fifo_stock_v2/config.go

@@ -1,170 +0,0 @@
-package fifo_stock_v2
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"gorm.io/gorm"
-)
-
-type routeRule struct {
-	ID                  uint    `gorm:"column:id"`
-	FlagGroupCode       string  `gorm:"column:flag_group_code"`
-	Lane                string  `gorm:"column:lane"`
-	FunctionCode        string  `gorm:"column:function_code"`
-	SourceTable         string  `gorm:"column:source_table"`
-	SourceIDColumn      string  `gorm:"column:source_id_column"`
-	ProductWarehouseCol string  `gorm:"column:product_warehouse_col"`
-	QuantityCol         string  `gorm:"column:quantity_col"`
-	UsedQuantityCol     *string `gorm:"column:used_quantity_col"`
-	PendingQuantityCol  *string `gorm:"column:pending_quantity_col"`
-	ScopeSQL            *string `gorm:"column:scope_sql"`
-	LegacyTypeKey       string  `gorm:"column:legacy_type_key"`
-	AllowPendingDefault bool    `gorm:"column:allow_pending_default"`
-}
-
-type traitRule struct {
-	ID                 uint    `gorm:"column:id"`
-	SourceTable        string  `gorm:"column:source_table"`
-	Lane               string  `gorm:"column:lane"`
-	DateTable          *string `gorm:"column:date_table"`
-	DateJoinLeftCol    *string `gorm:"column:date_join_left_col"`
-	DateJoinRightCol   *string `gorm:"column:date_join_right_col"`
-	DateColumn         string  `gorm:"column:date_column"`
-	FallbackDateColumn *string `gorm:"column:fallback_date_column"`
-	SortPriority       int     `gorm:"column:sort_priority"`
-	IDColumn           string  `gorm:"column:id_column"`
-}
-
-func (s *fifoStockV2Service) loadRouteRules(ctx context.Context, tx *gorm.DB, flagGroupCode string, lane Lane) ([]routeRule, error) {
-	var rules []routeRule
-	err := tx.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules").
-		Where("is_active = TRUE").
-		Where("flag_group_code = ?", flagGroupCode).
-		Where("lane = ?", string(lane)).
-		Order("id ASC").
-		Find(&rules).Error
-	if err != nil {
-		return nil, err
-	}
-	for _, rule := range rules {
-		if err := validateRouteRule(rule); err != nil {
-			return nil, err
-		}
-	}
-	return rules, nil
-}
-
-func (s *fifoStockV2Service) loadRouteRuleByLegacyType(
-	ctx context.Context,
-	tx *gorm.DB,
-	lane Lane,
-	flagGroupCode string,
-	legacyTypeKey string,
-) (*routeRule, error) {
-	var rule routeRule
-	err := tx.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules").
-		Where("is_active = TRUE").
-		Where("lane = ?", string(lane)).
-		Where("flag_group_code = ?", flagGroupCode).
-		Where("legacy_type_key = ?", legacyTypeKey).
-		Order("id ASC").
-		Limit(1).
-		Take(&rule).Error
-	if err != nil {
-		return nil, err
-	}
-	if err := validateRouteRule(rule); err != nil {
-		return nil, err
-	}
-	return &rule, nil
-}
-
-func (s *fifoStockV2Service) loadTraitMap(
-	ctx context.Context,
-	tx *gorm.DB,
-	lane Lane,
-	sourceTables []string,
-) (map[string]traitRule, error) {
-	if len(sourceTables) == 0 {
-		return map[string]traitRule{}, nil
-	}
-
-	var traits []traitRule
-	err := tx.WithContext(ctx).
-		Table("fifo_stock_v2_traits").
-		Where("is_active = TRUE").
-		Where("lane = ?", string(lane)).
-		Where("source_table IN ?", sourceTables).
-		Find(&traits).Error
-	if err != nil {
-		return nil, err
-	}
-
-	out := make(map[string]traitRule, len(traits))
-	for _, tr := range traits {
-		if err := validateTraitRule(tr); err != nil {
-			return nil, err
-		}
-		out[tr.SourceTable] = tr
-	}
-	return out, nil
-}
-
-func validateRouteRule(rule routeRule) error {
-	fields := []string{rule.SourceTable, rule.SourceIDColumn, rule.ProductWarehouseCol, rule.QuantityCol}
-	for _, value := range fields {
-		if _, err := mustSafeIdentifier(value); err != nil {
-			return err
-		}
-	}
-	if rule.UsedQuantityCol != nil {
-		if _, err := mustSafeIdentifier(*rule.UsedQuantityCol); err != nil {
-			return err
-		}
-	}
-	if rule.PendingQuantityCol != nil {
-		if _, err := mustSafeIdentifier(*rule.PendingQuantityCol); err != nil {
-			return err
-		}
-	}
-	if strings.TrimSpace(rule.LegacyTypeKey) == "" {
-		return fmt.Errorf("route rule has empty legacy type key")
-	}
-	return nil
-}
-
-func validateTraitRule(rule traitRule) error {
-	if _, err := mustSafeIdentifier(rule.SourceTable); err != nil {
-		return err
-	}
-	if _, err := mustSafeIdentifier(rule.DateColumn); err != nil {
-		return err
-	}
-	if _, err := mustSafeIdentifier(rule.IDColumn); err != nil {
-		return err
-	}
-	if rule.DateTable != nil {
-		if _, err := mustSafeIdentifier(*rule.DateTable); err != nil {
-			return err
-		}
-		if rule.DateJoinLeftCol == nil || rule.DateJoinRightCol == nil {
-			return fmt.Errorf("trait %s requires date join columns", rule.SourceTable)
-		}
-		if _, err := mustSafeIdentifier(*rule.DateJoinLeftCol); err != nil {
-			return err
-		}
-		if _, err := mustSafeIdentifier(*rule.DateJoinRightCol); err != nil {
-			return err
-		}
-	}
-	if rule.FallbackDateColumn != nil {
-		if _, err := mustSafeIdentifier(*rule.FallbackDateColumn); err != nil {
-			return err
-		}
-	}
-	return nil
-}

internal/common/service/fifo_stock_v2/errors.go

@@ -1,8 +0,0 @@
-package fifo_stock_v2
-
-import "errors"
-
-var (
-	ErrInvalidRequest    = errors.New("invalid fifo stock v2 request")
-	ErrInsufficientStock = errors.New("insufficient stock")
-)

internal/common/service/fifo_stock_v2/gather.go

@@ -1,293 +0,0 @@
-package fifo_stock_v2
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gorm.io/gorm"
-)
-
-type gatherSQLRow struct {
-	SourceTable        string    `gorm:"column:source_table"`
-	LegacyTypeKey      string    `gorm:"column:legacy_type_key"`
-	FunctionCode       string    `gorm:"column:function_code"`
-	SourceID           uint      `gorm:"column:source_id"`
-	ProductWarehouseID uint      `gorm:"column:product_warehouse_id"`
-	SortAt             time.Time `gorm:"column:sort_at"`
-	SortPriority       int       `gorm:"column:sort_priority"`
-	Quantity           float64   `gorm:"column:quantity"`
-	UsedQuantity       float64   `gorm:"column:used_quantity"`
-	PendingQuantity    float64   `gorm:"column:pending_quantity"`
-	AvailableQuantity  float64   `gorm:"column:available_quantity"`
-}
-
-func (s *fifoStockV2Service) Gather(ctx context.Context, req GatherRequest) ([]GatherRow, error) {
-	if strings.TrimSpace(req.FlagGroupCode) == "" || req.ProductWarehouseID == 0 {
-		return nil, fmt.Errorf("%w: flag group and product warehouse are required", ErrInvalidRequest)
-	}
-	if req.Lane != LaneStockable && req.Lane != LaneUsable {
-		return nil, fmt.Errorf("%w: unsupported lane %q", ErrInvalidRequest, req.Lane)
-	}
-
-	var out []GatherRow
-	err := s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
-		rows, err := s.gatherRows(ctx, tx, req)
-		if err != nil {
-			return err
-		}
-		out = rows
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (s *fifoStockV2Service) gatherRows(ctx context.Context, tx *gorm.DB, req GatherRequest) ([]GatherRow, error) {
-	req.AllocationPurpose = normalizeAllocationPurpose(req.AllocationPurpose)
-
-	rules, err := s.loadRouteRules(ctx, tx, req.FlagGroupCode, req.Lane)
-	if err != nil {
-		return nil, err
-	}
-	if len(rules) == 0 {
-		return []GatherRow{}, nil
-	}
-
-	tables := make([]string, 0, len(rules))
-	for _, rule := range rules {
-		tables = append(tables, rule.SourceTable)
-	}
-
-	traits, err := s.loadTraitMap(ctx, tx, req.Lane, tables)
-	if err != nil {
-		return nil, err
-	}
-
-	subqueries := make([]string, 0, len(rules))
-	args := make([]any, 0, len(rules)*10)
-
-	for _, rule := range rules {
-		trait, ok := traits[rule.SourceTable]
-		if !ok {
-			return nil, fmt.Errorf("missing trait for table %s lane %s", rule.SourceTable, req.Lane)
-		}
-		subSQL, subArgs, err := s.buildGatherSubquery(rule, trait, req)
-		if err != nil {
-			return nil, err
-		}
-		subqueries = append(subqueries, subSQL)
-		args = append(args, subArgs...)
-	}
-
-	if len(subqueries) == 0 {
-		return []GatherRow{}, nil
-	}
-
-	limit := req.Limit
-	if limit <= 0 {
-		limit = s.defaultGatherLimit
-	}
-	if limit <= 0 {
-		limit = 1000
-	}
-
-	query := "SELECT * FROM (" + strings.Join(subqueries, " UNION ALL ") + ") AS g"
-	if req.AfterSortAt != nil {
-		query += `
-			 WHERE
-			 	(g.sort_at > ?)
-			 	OR (g.sort_at = ? AND g.source_table > ?)
-			 	OR (g.sort_at = ? AND g.source_table = ? AND g.source_id > ?)
-		`
-		args = append(args,
-			*req.AfterSortAt,
-			*req.AfterSortAt, req.AfterSourceTable,
-			*req.AfterSortAt, req.AfterSourceTable, req.AfterSourceID,
-		)
-	}
-	query += " ORDER BY g.sort_at ASC, g.sort_priority ASC, g.source_table ASC, g.source_id ASC LIMIT ?"
-	args = append(args, limit)
-
-	var rows []gatherSQLRow
-	if err := tx.WithContext(ctx).Raw(query, args...).Scan(&rows).Error; err != nil {
-		return nil, err
-	}
-
-	out := make([]GatherRow, 0, len(rows))
-	for _, row := range rows {
-		out = append(out, GatherRow{
-			Ref: Ref{
-				Table:         row.SourceTable,
-				ID:            row.SourceID,
-				LegacyTypeKey: row.LegacyTypeKey,
-				FunctionCode:  row.FunctionCode,
-			},
-			FlagGroupCode:      req.FlagGroupCode,
-			ProductWarehouseID: row.ProductWarehouseID,
-			SortAt:             row.SortAt,
-			SortPriority:       row.SortPriority,
-			Quantity:           row.Quantity,
-			UsedQuantity:       row.UsedQuantity,
-			PendingQuantity:    row.PendingQuantity,
-			AvailableQuantity:  row.AvailableQuantity,
-			SourceTable:        row.SourceTable,
-			SourceID:           row.SourceID,
-		})
-	}
-
-	return out, nil
-}
-
-func (s *fifoStockV2Service) buildGatherSubquery(rule routeRule, trait traitRule, req GatherRequest) (string, []any, error) {
-	sourceTable, _ := mustSafeIdentifier(rule.SourceTable)
-	sourceIDCol, _ := mustSafeIdentifier(rule.SourceIDColumn)
-	productWarehouseCol, _ := mustSafeIdentifier(rule.ProductWarehouseCol)
-	quantityCol, _ := mustSafeIdentifier(rule.QuantityCol)
-
-	baseQtyExpr := fmt.Sprintf("COALESCE(src.%s,0)::numeric", quantityCol)
-	usedExpr := "0::numeric"
-	pendingExpr := "0::numeric"
-	availableExpr := baseQtyExpr
-	extraArgs := make([]any, 0, 2)
-	whereExtraArgs := make([]any, 0, 1)
-
-	if req.Lane == LaneStockable {
-		if !req.IgnoreSourceUsed && rule.UsedQuantityCol != nil && strings.TrimSpace(*rule.UsedQuantityCol) != "" {
-			usedCol, _ := mustSafeIdentifier(*rule.UsedQuantityCol)
-			usedExpr = fmt.Sprintf("COALESCE(src.%s,0)::numeric", usedCol)
-		} else {
-			// NOTE:
-			// usedExpr is referenced twice in the generated SELECT:
-			// 1) as used_quantity
-			// 2) inside available_quantity = base - usedExpr
-			// plus once in stockable WHERE clause via availableExpr > 0.
-			// We split the args because the WHERE placeholder order appears
-			// after product/flag filter placeholders in the final SQL.
-			usedExpr = fmt.Sprintf(
-				"(SELECT COALESCE(SUM(sa.qty),0)::numeric FROM stock_allocations sa WHERE sa.stockable_type = ? AND sa.stockable_id = src.%s AND sa.status = '%s' AND sa.allocation_purpose = ?)",
-				sourceIDCol,
-				activeAllocationStatus(),
-			)
-			extraArgs = append(extraArgs, rule.LegacyTypeKey, req.AllocationPurpose)
-			extraArgs = append(extraArgs, rule.LegacyTypeKey, req.AllocationPurpose)
-			whereExtraArgs = append(whereExtraArgs, rule.LegacyTypeKey, req.AllocationPurpose)
-		}
-		availableExpr = fmt.Sprintf("(%s - %s)", baseQtyExpr, usedExpr)
-	} else {
-		if rule.PendingQuantityCol != nil && strings.TrimSpace(*rule.PendingQuantityCol) != "" {
-			pendingCol, _ := mustSafeIdentifier(*rule.PendingQuantityCol)
-			pendingExpr = fmt.Sprintf("COALESCE(src.%s,0)::numeric", pendingCol)
-		}
-		availableExpr = baseQtyExpr
-	}
-
-	sortExpr, joinClause, err := buildSortExpr(trait)
-	if err != nil {
-		return "", nil, err
-	}
-
-	functionCodeExpr := "?::text"
-	functionCodeArgs := []any{rule.FunctionCode}
-	if rule.SourceTable == "adjustment_stocks" {
-		functionCodeExpr = "COALESCE(NULLIF(src.function_code,''), ?::text)"
-	}
-
-	whereParts := []string{
-		fmt.Sprintf("src.%s = ?", productWarehouseCol),
-		fmt.Sprintf(`EXISTS (
-			SELECT 1
-			FROM product_warehouses pw
-			JOIN flags f ON f.flagable_type = ? AND f.flagable_id = pw.product_id
-			JOIN fifo_stock_v2_flag_members fm ON fm.flag_name = f.name AND fm.is_active = TRUE
-			WHERE pw.id = src.%s AND fm.flag_group_code = ?
-		)`, productWarehouseCol),
-	}
-
-	if req.Lane == LaneStockable {
-		whereParts = append(whereParts, fmt.Sprintf("%s > 0", availableExpr))
-	}
-
-	if req.AsOf != nil {
-		whereParts = append(whereParts, fmt.Sprintf("%s <= ?", sortExpr))
-	}
-	if req.From != nil {
-		whereParts = append(whereParts, fmt.Sprintf("%s >= ?", sortExpr))
-	}
-
-	if rule.ScopeSQL != nil && strings.TrimSpace(*rule.ScopeSQL) != "" {
-		whereParts = append(whereParts, fmt.Sprintf("(%s)", normalizeScopeSQL(*rule.ScopeSQL)))
-	}
-
-	subquery := fmt.Sprintf(`
-		SELECT
-			?::text AS source_table,
-			?::text AS legacy_type_key,
-			%s AS function_code,
-			src.%s AS source_id,
-			src.%s AS product_warehouse_id,
-			%s AS sort_at,
-			?::int AS sort_priority,
-			%s AS quantity,
-			%s AS used_quantity,
-			%s AS pending_quantity,
-			%s AS available_quantity
-		FROM %s src
-		%s
-		WHERE %s
-	`, functionCodeExpr, sourceIDCol, productWarehouseCol, sortExpr, baseQtyExpr, usedExpr, pendingExpr, availableExpr, sourceTable, joinClause, strings.Join(whereParts, " AND "))
-
-	args := []any{
-		rule.SourceTable,
-		rule.LegacyTypeKey,
-	}
-	args = append(args, functionCodeArgs...)
-	args = append(args, trait.SortPriority)
-	args = append(args, extraArgs...)
-	args = append(args,
-		req.ProductWarehouseID,
-		entity.FlagableTypeProduct,
-		req.FlagGroupCode,
-	)
-	args = append(args, whereExtraArgs...)
-
-	if req.AsOf != nil {
-		args = append(args, *req.AsOf)
-	}
-	if req.From != nil {
-		args = append(args, *req.From)
-	}
-
-	return subquery, args, nil
-}
-
-func buildSortExpr(trait traitRule) (string, string, error) {
-	dateCol, _ := mustSafeIdentifier(trait.DateColumn)
-	idCol, _ := mustSafeIdentifier(trait.IDColumn)
-	_ = idCol
-
-	joinClause := ""
-	sortBase := fmt.Sprintf("src.%s", dateCol)
-	if trait.DateTable != nil && strings.TrimSpace(*trait.DateTable) != "" {
-		dateTable, _ := mustSafeIdentifier(*trait.DateTable)
-		if trait.DateJoinLeftCol == nil || trait.DateJoinRightCol == nil {
-			return "", "", fmt.Errorf("trait %s requires date join columns", trait.SourceTable)
-		}
-		leftCol, _ := mustSafeIdentifier(*trait.DateJoinLeftCol)
-		rightCol, _ := mustSafeIdentifier(*trait.DateJoinRightCol)
-		joinClause = fmt.Sprintf("LEFT JOIN %s dt ON src.%s = dt.%s", dateTable, leftCol, rightCol)
-		sortBase = fmt.Sprintf("dt.%s", dateCol)
-	}
-
-	if trait.FallbackDateColumn != nil && strings.TrimSpace(*trait.FallbackDateColumn) != "" {
-		fallbackCol, _ := mustSafeIdentifier(*trait.FallbackDateColumn)
-		sortBase = fmt.Sprintf("COALESCE(%s, src.%s)", sortBase, fallbackCol)
-	}
-
-	sortExpr := fmt.Sprintf("COALESCE(%s, '1970-01-01 00:00:00+00'::timestamptz)", sortBase)
-	return sortExpr, joinClause, nil
-}

internal/common/service/fifo_stock_v2/population_allocation.go

@@ -1,131 +0,0 @@
-package fifo_stock_v2
-
-import (
-	"context"
-	"errors"
-	"math"
-	"sort"
-
-	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
-
-	"github.com/gofiber/fiber/v2"
-	"gorm.io/gorm"
-)
-
-func ReleasePopulationConsumptionByUsable(
-	ctx context.Context,
-	tx *gorm.DB,
-	usableType string,
-	usableID uint,
-) error {
-	if tx == nil {
-		return errors.New("transaction is required")
-	}
-	if usableType == "" || usableID == 0 {
-		return errors.New("usable type and id are required")
-	}
-
-	stockAllocationRepo := commonRepo.NewStockAllocationRepository(tx)
-	allocations, err := stockAllocationRepo.FindActiveByUsable(ctx, usableType, usableID, nil)
-	if err != nil {
-		return err
-	}
-
-	for _, allocation := range allocations {
-		if allocation.StockableType != fifo.StockableKeyProjectFlockPopulation.String() || allocation.StockableId == 0 || allocation.Qty <= 0 {
-			continue
-		}
-		if err := tx.WithContext(ctx).
-			Model(&entity.ProjectFlockPopulation{}).
-			Where("id = ?", allocation.StockableId).
-			Update("total_used_qty", gorm.Expr("GREATEST(total_used_qty - ?, 0)", allocation.Qty)).Error; err != nil {
-			return err
-		}
-	}
-
-	return stockAllocationRepo.ReleaseByUsable(ctx, usableType, usableID, nil, nil)
-}
-
-func AllocatePopulationConsumption(
-	ctx context.Context,
-	tx *gorm.DB,
-	populations []entity.ProjectFlockPopulation,
-	productWarehouseID uint,
-	usableType string,
-	usableID uint,
-	consumeQty float64,
-) error {
-	if consumeQty <= 0 {
-		return nil
-	}
-	if tx == nil {
-		return errors.New("transaction is required")
-	}
-	if productWarehouseID == 0 {
-		return fiber.NewError(fiber.StatusBadRequest, "Product warehouse tidak valid")
-	}
-	if usableType == "" || usableID == 0 {
-		return errors.New("usable type and id are required")
-	}
-	if len(populations) == 0 {
-		return fiber.NewError(fiber.StatusBadRequest, "Populasi tidak ditemukan")
-	}
-
-	if err := ReleasePopulationConsumptionByUsable(ctx, tx, usableType, usableID); err != nil {
-		return err
-	}
-
-	sort.Slice(populations, func(i, j int) bool {
-		if populations[i].CreatedAt.Equal(populations[j].CreatedAt) {
-			return populations[i].Id < populations[j].Id
-		}
-		return populations[i].CreatedAt.Before(populations[j].CreatedAt)
-	})
-
-	stockAllocationRepo := commonRepo.NewStockAllocationRepository(tx)
-	remaining := consumeQty
-	for _, pop := range populations {
-		available := pop.TotalQty - pop.TotalUsedQty
-		if available <= 0 {
-			continue
-		}
-		portion := math.Min(available, remaining)
-		if portion <= 0 {
-			continue
-		}
-
-		allocation := &entity.StockAllocation{
-			ProductWarehouseId: productWarehouseID,
-			StockableType:      fifo.StockableKeyProjectFlockPopulation.String(),
-			StockableId:        pop.Id,
-			UsableType:         usableType,
-			UsableId:           usableID,
-			Qty:                portion,
-			Status:             entity.StockAllocationStatusActive,
-			AllocationPurpose:  entity.StockAllocationPurposeConsume,
-		}
-		if err := stockAllocationRepo.CreateOne(ctx, allocation, nil); err != nil {
-			return err
-		}
-
-		if err := tx.WithContext(ctx).
-			Model(&entity.ProjectFlockPopulation{}).
-			Where("id = ?", pop.Id).
-			Update("total_used_qty", gorm.Expr("total_used_qty + ?", portion)).Error; err != nil {
-			return err
-		}
-
-		remaining -= portion
-		if remaining <= 1e-6 {
-			break
-		}
-	}
-
-	if remaining > 1e-6 {
-		return fiber.NewError(fiber.StatusBadRequest, "Populasi tidak mencukupi")
-	}
-
-	return nil
-}

internal/common/service/fifo_stock_v2/recalculate.go

@@ -1,177 +0,0 @@
-package fifo_stock_v2
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"math"
-	"time"
-
-	"gorm.io/gorm"
-)
-
-func (s *fifoStockV2Service) Recalculate(ctx context.Context, req RecalculateRequest) (*RecalculateResult, error) {
-	result := &RecalculateResult{Drifts: make([]WarehouseDrift, 0)}
-
-	err := s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
-		hash := requestHash(map[string]any{
-			"product_warehouse_ids": req.ProductWarehouseIDs,
-			"flag_group_codes":      req.FlagGroupCodes,
-			"as_of":                 req.AsOf,
-			"fix_drift":             req.FixDrift,
-		})
-		logRow, reused, err := s.beginOperation(
-			tx,
-			OperationRecalculate,
-			req.IdempotencyKey,
-			hash,
-			0,
-			"RECALCULATE",
-			"",
-			0,
-		)
-		if err != nil {
-			return err
-		}
-		if reused {
-			if len(logRow.ResultPayload) == 0 {
-				return fmt.Errorf("idempotent recalculate has empty payload")
-			}
-			if err := json.Unmarshal(logRow.ResultPayload, result); err != nil {
-				return err
-			}
-			return nil
-		}
-		if logRow != nil {
-			defer func() {
-				if err != nil {
-					s.failOperation(tx, logRow, err)
-				}
-			}()
-		}
-
-		warehouseIDs, err := s.resolveRecalculateWarehouseIDs(ctx, tx, req.ProductWarehouseIDs)
-		if err != nil {
-			return err
-		}
-		groupCodes, err := s.resolveRecalculateGroupCodes(ctx, tx, req.FlagGroupCodes)
-		if err != nil {
-			return err
-		}
-
-		for _, warehouseID := range warehouseIDs {
-			expected := 0.0
-			for _, flagGroup := range groupCodes {
-				available, calcErr := s.calculateWarehouseAvailableForGroup(ctx, tx, warehouseID, flagGroup, req.AsOf)
-				if calcErr != nil {
-					return calcErr
-				}
-				expected += available
-			}
-
-			actual, actualErr := s.loadWarehouseQty(ctx, tx, warehouseID)
-			if actualErr != nil {
-				return actualErr
-			}
-
-			delta := expected - actual
-			result.Checked++
-			if math.Abs(delta) < 1e-6 {
-				continue
-			}
-
-			drift := WarehouseDrift{
-				ProductWarehouseID: warehouseID,
-				ExpectedQty:        expected,
-				ActualQty:          actual,
-				Delta:              delta,
-			}
-			result.Drifts = append(result.Drifts, drift)
-
-			if req.FixDrift {
-				if err := s.adjustProductWarehouseQty(tx, warehouseID, delta); err != nil {
-					return err
-				}
-				result.Fixed++
-			}
-		}
-
-		if err := s.finishOperation(tx, logRow, result); err != nil {
-			return err
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-func (s *fifoStockV2Service) resolveRecalculateWarehouseIDs(ctx context.Context, tx *gorm.DB, provided []uint) ([]uint, error) {
-	if len(provided) > 0 {
-		return provided, nil
-	}
-	var ids []uint
-	err := tx.WithContext(ctx).Table("product_warehouses").Select("id").Order("id ASC").Scan(&ids).Error
-	if err != nil {
-		return nil, err
-	}
-	return ids, nil
-}
-
-func (s *fifoStockV2Service) resolveRecalculateGroupCodes(ctx context.Context, tx *gorm.DB, provided []string) ([]string, error) {
-	if len(provided) > 0 {
-		return provided, nil
-	}
-	var groups []string
-	err := tx.WithContext(ctx).
-		Table("fifo_stock_v2_flag_groups").
-		Select("code").
-		Where("is_active = TRUE").
-		Order("priority ASC, code ASC").
-		Scan(&groups).Error
-	if err != nil {
-		return nil, err
-	}
-	return groups, nil
-}
-
-func (s *fifoStockV2Service) calculateWarehouseAvailableForGroup(
-	ctx context.Context,
-	tx *gorm.DB,
-	warehouseID uint,
-	flagGroupCode string,
-	asOf *time.Time,
-) (float64, error) {
-	rows, err := s.gatherRows(ctx, tx, GatherRequest{
-		FlagGroupCode:      flagGroupCode,
-		Lane:               LaneStockable,
-		ProductWarehouseID: warehouseID,
-		AsOf:               asOf,
-		Limit:              50000,
-	})
-	if err != nil {
-		return 0, err
-	}
-	total := 0.0
-	for _, row := range rows {
-		total += row.AvailableQuantity
-	}
-	return total, nil
-}
-
-func (s *fifoStockV2Service) loadWarehouseQty(ctx context.Context, tx *gorm.DB, warehouseID uint) (float64, error) {
-	type row struct {
-		Qty float64 `gorm:"column:qty"`
-	}
-	var out row
-	err := tx.WithContext(ctx).
-		Table("product_warehouses").
-		Select("COALESCE(qty,0) AS qty").
-		Where("id = ?", warehouseID).
-		Take(&out).Error
-	if err != nil {
-		return 0, err
-	}
-	return out.Qty, nil
-}

internal/common/service/fifo_stock_v2/scope_sql.go

@@ -1,100 +0,0 @@
-package fifo_stock_v2
-
-import "strings"
-
-func normalizeScopeSQL(scopeSQL string) string {
-	scopeSQL = strings.TrimSpace(scopeSQL)
-	if scopeSQL == "" {
-		return scopeSQL
-	}
-
-	var out strings.Builder
-	out.Grow(len(scopeSQL) + 16)
-
-	inSingleQuote := false
-	inDoubleQuote := false
-
-	for i := 0; i < len(scopeSQL); {
-		ch := scopeSQL[i]
-
-		if inSingleQuote {
-			out.WriteByte(ch)
-			i++
-			if ch == '\'' {
-				if i < len(scopeSQL) && scopeSQL[i] == '\'' {
-					out.WriteByte(scopeSQL[i])
-					i++
-				} else {
-					inSingleQuote = false
-				}
-			}
-			continue
-		}
-
-		if inDoubleQuote {
-			out.WriteByte(ch)
-			i++
-			if ch == '"' {
-				inDoubleQuote = false
-			}
-			continue
-		}
-
-		if ch == '\'' {
-			inSingleQuote = true
-			out.WriteByte(ch)
-			i++
-			continue
-		}
-
-		if ch == '"' {
-			inDoubleQuote = true
-			out.WriteByte(ch)
-			i++
-			continue
-		}
-
-		if isIdentifierStart(ch) {
-			start := i
-			i++
-			for i < len(scopeSQL) && isIdentifierPart(scopeSQL[i]) {
-				i++
-			}
-
-			token := scopeSQL[start:i]
-			if strings.EqualFold(token, "deleted_at") && !hasAliasQualifier(scopeSQL, start) {
-				out.WriteString("src.deleted_at")
-			} else {
-				out.WriteString(token)
-			}
-			continue
-		}
-
-		out.WriteByte(ch)
-		i++
-	}
-
-	return out.String()
-}
-
-func hasAliasQualifier(scopeSQL string, tokenStart int) bool {
-	for i := tokenStart - 1; i >= 0; i-- {
-		switch scopeSQL[i] {
-		case ' ', '\t', '\n', '\r':
-			continue
-		case '.':
-			return true
-		default:
-			return false
-		}
-	}
-	return false
-}
-
-func isIdentifierStart(ch byte) bool {
-	return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_'
-}
-
-func isIdentifierPart(ch byte) bool {
-	return isIdentifierStart(ch) || (ch >= '0' && ch <= '9')
-}

internal/common/service/fifo_stock_v2/service.go

@@ -1,277 +0,0 @@
-package fifo_stock_v2
-
-import (
-	"context"
-	"crypto/sha256"
-	"encoding/hex"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"hash/fnv"
-	"math"
-	"regexp"
-	"strings"
-
-	"github.com/sirupsen/logrus"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gorm.io/gorm"
-)
-
-var identifierPattern = regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_]*$`)
-
-type fifoStockV2Service struct {
-	db                 *gorm.DB
-	logger             *logrus.Logger
-	defaultGatherLimit int
-}
-
-func NewService(db *gorm.DB, logger *logrus.Logger) Service {
-	if logger == nil {
-		logger = logrus.StandardLogger()
-	}
-
-	return &fifoStockV2Service{
-		db:                 db,
-		logger:             logger,
-		defaultGatherLimit: 1000,
-	}
-}
-
-func (s *fifoStockV2Service) withTransaction(
-	ctx context.Context,
-	tx *gorm.DB,
-	fn func(*gorm.DB) error,
-) error {
-	if tx != nil {
-		return fn(tx.WithContext(ctx))
-	}
-	return s.db.WithContext(ctx).Transaction(func(inner *gorm.DB) error {
-		return fn(inner)
-	})
-}
-
-func isSafeIdentifier(v string) bool {
-	return identifierPattern.MatchString(strings.TrimSpace(v))
-}
-
-func mustSafeIdentifier(v string) (string, error) {
-	v = strings.TrimSpace(v)
-	if !isSafeIdentifier(v) {
-		return "", fmt.Errorf("unsafe identifier: %s", v)
-	}
-	return v, nil
-}
-
-func requestHash(v any) string {
-	payload, _ := json.Marshal(v)
-	sum := sha256.Sum256(payload)
-	return hex.EncodeToString(sum[:])
-}
-
-func shardLockKey(flagGroupCode string, productWarehouseID uint) int64 {
-	h := fnv.New64a()
-	_, _ = h.Write([]byte(strings.TrimSpace(strings.ToUpper(flagGroupCode))))
-	_, _ = h.Write([]byte("|"))
-	_, _ = h.Write([]byte(fmt.Sprintf("%d", productWarehouseID)))
-	return int64(h.Sum64())
-}
-
-func (s *fifoStockV2Service) lockShard(tx *gorm.DB, flagGroupCode string, productWarehouseID uint) error {
-	if strings.TrimSpace(flagGroupCode) == "" || productWarehouseID == 0 {
-		return fmt.Errorf("lock shard requires flag group and product warehouse")
-	}
-	return tx.Exec("SELECT pg_advisory_xact_lock(?)", shardLockKey(flagGroupCode, productWarehouseID)).Error
-}
-
-type operationLogRow struct {
-	ID            uint            `gorm:"column:id"`
-	Status        string          `gorm:"column:status"`
-	RequestHash   string          `gorm:"column:request_hash"`
-	ResultPayload json.RawMessage `gorm:"column:result_payload"`
-}
-
-func (s *fifoStockV2Service) beginOperation(
-	tx *gorm.DB,
-	op Operation,
-	idempotencyKey string,
-	requestHashValue string,
-	productWarehouseID uint,
-	flagGroupCode string,
-	usableType string,
-	usableID uint,
-) (*operationLogRow, bool, error) {
-	if strings.TrimSpace(idempotencyKey) == "" {
-		return nil, false, nil
-	}
-
-	inserted := operationLogRow{}
-	insertSQL := `
-		INSERT INTO fifo_stock_v2_operation_log
-			(idempotency_key, operation, product_warehouse_id, flag_group_code, usable_type, usable_id, request_hash, status, created_at)
-		VALUES (?, ?, ?, ?, NULLIF(?, ''), NULLIF(?, 0), ?, 'RUNNING', NOW())
-		ON CONFLICT (idempotency_key, operation) DO NOTHING
-		RETURNING id, status, request_hash
-	`
-	if err := tx.Raw(insertSQL,
-		idempotencyKey,
-		string(op),
-		productWarehouseID,
-		flagGroupCode,
-		usableType,
-		usableID,
-		requestHashValue,
-	).Scan(&inserted).Error; err != nil {
-		return nil, false, err
-	}
-	if inserted.ID != 0 {
-		return &inserted, false, nil
-	}
-
-	existing := operationLogRow{}
-	if err := tx.Table("fifo_stock_v2_operation_log").
-		Select("id, status, request_hash, result_payload").
-		Where("idempotency_key = ? AND operation = ?", idempotencyKey, string(op)).
-		Take(&existing).Error; err != nil {
-		return nil, false, err
-	}
-
-	if existing.RequestHash != requestHashValue {
-		return nil, false, fmt.Errorf("idempotency key %s reused with different payload", idempotencyKey)
-	}
-
-	switch strings.ToUpper(existing.Status) {
-	case "DONE":
-		return &existing, true, nil
-	case "RUNNING":
-		return nil, false, fmt.Errorf("operation %s with idempotency key %s is still running", op, idempotencyKey)
-	case "FAILED":
-		if err := tx.Table("fifo_stock_v2_operation_log").
-			Where("id = ?", existing.ID).
-			Updates(map[string]any{
-				"status":      "RUNNING",
-				"error_text":  nil,
-				"finished_at": nil,
-			}).Error; err != nil {
-			return nil, false, err
-		}
-		existing.Status = "RUNNING"
-		return &existing, false, nil
-	default:
-		return nil, false, fmt.Errorf("unknown operation status: %s", existing.Status)
-	}
-}
-
-func (s *fifoStockV2Service) finishOperation(tx *gorm.DB, logRow *operationLogRow, payload any) error {
-	if logRow == nil || logRow.ID == 0 {
-		return nil
-	}
-
-	encoded, err := json.Marshal(payload)
-	if err != nil {
-		return err
-	}
-
-	return tx.Table("fifo_stock_v2_operation_log").
-		Where("id = ?", logRow.ID).
-		Updates(map[string]any{
-			"status":         "DONE",
-			"result_payload": encoded,
-			"finished_at":    gorm.Expr("NOW()"),
-		}).Error
-}
-
-func (s *fifoStockV2Service) failOperation(tx *gorm.DB, logRow *operationLogRow, failure error) {
-	if logRow == nil || logRow.ID == 0 || failure == nil {
-		return
-	}
-	_ = tx.Table("fifo_stock_v2_operation_log").
-		Where("id = ?", logRow.ID).
-		Updates(map[string]any{
-			"status":      "FAILED",
-			"error_text":  failure.Error(),
-			"finished_at": gorm.Expr("NOW()"),
-		}).Error
-}
-
-func (s *fifoStockV2Service) resolveOverConsume(
-	tx *gorm.DB,
-	flagGroupCode string,
-	functionCode string,
-	lane Lane,
-	defaultValue bool,
-) (bool, error) {
-	type row struct {
-		Allow bool `gorm:"column:allow_overconsume"`
-	}
-	selected := row{}
-	err := tx.Table("fifo_stock_v2_overconsume_rules").
-		Select("allow_overconsume").
-		Where("is_active = TRUE").
-		Where("lane = ?", string(lane)).
-		Where("(flag_group_code IS NULL OR flag_group_code = ?)", flagGroupCode).
-		Where("(function_code IS NULL OR function_code = ?)", functionCode).
-		Order("CASE WHEN flag_group_code IS NULL THEN 1 ELSE 0 END ASC").
-		Order("CASE WHEN function_code IS NULL THEN 1 ELSE 0 END ASC").
-		Order("priority ASC, id ASC").
-		Limit(1).
-		Take(&selected).Error
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return defaultValue, nil
-		}
-		return false, err
-	}
-	return selected.Allow, nil
-}
-
-func (s *fifoStockV2Service) adjustProductWarehouseQty(tx *gorm.DB, productWarehouseID uint, delta float64) error {
-	if productWarehouseID == 0 || delta == 0 {
-		return nil
-	}
-	return tx.Table("product_warehouses").
-		Where("id = ?", productWarehouseID).
-		Update("qty", gorm.Expr("COALESCE(qty,0) + ?", delta)).Error
-}
-
-func nearlyZero(v float64) bool {
-	return math.Abs(v) < 1e-6
-}
-
-func (s *fifoStockV2Service) ensureStockAllocationColumns(tx *gorm.DB) error {
-	checkCols := []string{"engine_version", "flag_group_code", "function_code", "idempotency_key", "allocation_purpose"}
-	for _, col := range checkCols {
-		var count int64
-		err := tx.Raw(`
-			SELECT COUNT(1)
-			FROM information_schema.columns
-			WHERE table_schema = 'public' AND table_name = 'stock_allocations' AND column_name = ?
-		`, col).Scan(&count).Error
-		if err != nil {
-			return err
-		}
-		if count == 0 {
-			return fmt.Errorf("stock_allocations.%s does not exist, run fifo_stock_v2 migration first", col)
-		}
-	}
-	return nil
-}
-
-func activeAllocationStatus() string {
-	return entity.StockAllocationStatusActive
-}
-
-func releasedAllocationStatus() string {
-	return entity.StockAllocationStatusReleased
-}
-
-func defaultAllocationPurpose() string {
-	return entity.StockAllocationPurposeConsume
-}
-
-func normalizeAllocationPurpose(purpose string) string {
-	purpose = strings.TrimSpace(strings.ToUpper(purpose))
-	if purpose == "" {
-		return defaultAllocationPurpose()
-	}
-	return purpose
-}

internal/common/service/fifo_stock_v2/types.go

@@ -1,143 +0,0 @@
-package fifo_stock_v2
-
-import (
-	"context"
-	"time"
-
-	"gorm.io/gorm"
-)
-
-type Lane string
-
-const (
-	LaneStockable Lane = "STOCKABLE"
-	LaneUsable    Lane = "USABLE"
-)
-
-type Operation string
-
-const (
-	OperationAllocate    Operation = "ALLOCATE"
-	OperationRollback    Operation = "ROLLBACK"
-	OperationReflow      Operation = "REFLOW"
-	OperationRecalculate Operation = "RECALCULATE"
-)
-
-type Ref struct {
-	Table         string
-	ID            uint
-	LegacyTypeKey string
-	FunctionCode  string
-}
-
-type GatherRequest struct {
-	FlagGroupCode      string
-	Lane               Lane
-	AllocationPurpose  string
-	IgnoreSourceUsed   bool
-	ProductWarehouseID uint
-	From               *time.Time
-	AsOf               *time.Time
-	Limit              int
-	AfterSortAt        *time.Time
-	AfterSourceTable   string
-	AfterSourceID      uint
-	ForUpdate          bool
-	Tx                 *gorm.DB
-}
-
-type GatherRow struct {
-	Ref                Ref
-	FlagGroupCode      string
-	ProductWarehouseID uint
-	SortAt             time.Time
-	SortPriority       int
-	Quantity           float64
-	UsedQuantity       float64
-	PendingQuantity    float64
-	AvailableQuantity  float64
-	SourceTable        string
-	SourceID           uint
-}
-
-type AllocateRequest struct {
-	FlagGroupCode      string
-	ProductWarehouseID uint
-	Usable             Ref
-	NeedQty            float64
-	AllowOverConsume   *bool
-	IdempotencyKey     string
-	AsOf               *time.Time
-	Tx                 *gorm.DB
-}
-
-type AllocationDetail struct {
-	StockableType string
-	StockableID   uint
-	Qty           float64
-	SortAt        time.Time
-}
-
-type AllocateResult struct {
-	AllocatedQty float64
-	PendingQty   float64
-	Details      []AllocationDetail
-}
-
-type RollbackRequest struct {
-	ProductWarehouseID uint
-	Usable             Ref
-	ReleaseQty         *float64
-	Reason             string
-	IdempotencyKey     string
-	Tx                 *gorm.DB
-}
-
-type RollbackResult struct {
-	ReleasedQty float64
-	Details     []AllocationDetail
-}
-
-type ReflowRequest struct {
-	FlagGroupCode      string
-	ProductWarehouseID uint
-	AsOf               *time.Time
-	IdempotencyKey     string
-	Tx                 *gorm.DB
-}
-
-type ReflowResult struct {
-	ProcessedUsables int
-	Rollback         RollbackResult
-	Allocate         AllocateResult
-}
-
-type RecalculateRequest struct {
-	ProductWarehouseIDs []uint
-	FlagGroupCodes      []string
-	AsOf                *time.Time
-	FixDrift            bool
-	IdempotencyKey      string
-	Tx                  *gorm.DB
-}
-
-type WarehouseDrift struct {
-	ProductWarehouseID uint
-	ExpectedQty        float64
-	ActualQty          float64
-	Delta              float64
-}
-
-type RecalculateResult struct {
-	Checked int
-	Fixed   int
-	Drifts  []WarehouseDrift
-}
-
-type Service interface {
-	Gather(ctx context.Context, req GatherRequest) ([]GatherRow, error)
-	Allocate(ctx context.Context, req AllocateRequest) (*AllocateResult, error)
-	Rollback(ctx context.Context, req RollbackRequest) (*RollbackResult, error)
-	Reflow(ctx context.Context, req ReflowRequest) (*ReflowResult, error)
-	Recalculate(ctx context.Context, req RecalculateRequest) (*RecalculateResult, error)
-}

internal/config/config.go

@@ -22,71 +22,69 @@ type SSOClientConfig struct {
 }
 
 var (
-	IsProd                         bool
+	IsProd                  bool
-	AppEnv                         string
+	AppHost                 string
-	AppHost                        string
+	Version                 string
-	Version                        string
+	LogLevel                string
-	LogLevel                       string
+	AppPort                 int
-	AppPort                        int
+	DBHost                  string
-	DBHost                         string
+	DBUser                  string
-	DBUser                         string
+	DBPassword              string
-	DBPassword                     string
+	DBName                  string
-	DBName                         string
+	DBPort                  int
-	DBPort                         int
+	DBSSLMode               string
-	DBSSLMode                      string
+	DBSSLRootCert           string
-	DBSSLRootCert                  string
+	DBSSLCert               string
-	DBSSLCert                      string
+	DBSSLKey                string
-	DBSSLKey                       string
+	JWTSecret               string
-	JWTSecret                      string
+	JWTAccessExp            int
-	JWTAccessExp                   int
+	JWTRefreshExp           int
-	JWTRefreshExp                  int
+	JWTResetPasswordExp     int
-	JWTResetPasswordExp            int
+	JWTVerifyEmailExp       int
-	JWTVerifyEmailExp              int
+	RedisURL                string
-	RedisURL                       string
+	CORSAllowOrigins        []string
-	CORSAllowOrigins               []string
+	CORSAllowMethods        []string
-	CORSAllowMethods               []string
+	CORSAllowHeaders        []string
-	CORSAllowHeaders               []string
+	CORSExposeHeaders       []string
-	CORSExposeHeaders              []string
+	CORSAllowCredentials    bool
-	CORSAllowCredentials           bool
+	CORSMaxAge              int
-	CORSMaxAge                     int
+	SSOIssuer               string
-	SSOIssuer                      string
+	SSOJWKSURL              string
-	SSOJWKSURL                     string
+	SSOHMACSecret           string
-	SSOAllowedAudiences            []string
+	SSOAllowedAudiences     []string
-	SSOAuthorizeURL                string
+	SSOAuthorizeURL         string
-	SSOTokenURL                    string
+	SSOTokenURL             string
-	SSOGetMeURL                    string
+	SSOGetMeURL             string
-	SSOPortalURL                   string
+	SSOPortalURL            string
-	SSOClients                     map[string]SSOClientConfig
+	SSOClients              map[string]SSOClientConfig
-	SSOAccessCookieName            string
+	SSOAccessCookieName     string
-	SSOAccessCookieFallback        []string
+	SSOAccessCookieFallback []string
-	SSORefreshCookieName           string
+	SSORefreshCookieName    string
-	SSOCookieDomain                string
+	SSOCookieDomain         string
-	SSOCookieSecure                bool
+	SSOCookieSecure         bool
-	SSOCookieSameSite              string
+	SSOCookieSameSite       string
-	SSOAccessTokenMaxBytes         int
+	SSOAccessTokenMaxBytes  int
-	SSOTokenBlacklistPrefix        string
+	SSOTokenBlacklistPrefix string
-	SSOPKCETTL                     time.Duration
+	SSOPKCETTL              time.Duration
-	SSOUserSyncDrift               time.Duration
+	SSOUserSyncDrift        time.Duration
-	SSOUserSyncNonceTTL            time.Duration
+	SSOUserSyncNonceTTL     time.Duration
-	SSOUserSyncMaxBodyBytes        int
+	SSOUserSyncMaxBodyBytes int
-	S3Endpoint                     string
+	S3Endpoint              string
-	S3Region                       string
+	S3Region                string
-	S3Bucket                       string
+	S3Bucket                string
-	S3AccessKey                    string
+	S3AccessKey             string
-	S3SecretKey                    string
+	S3SecretKey             string
-	S3ForcePathStyle               bool
+	S3ForcePathStyle        bool
-	S3PublicBaseURL                string
+	S3PublicBaseURL         string
-	S3EnvPrefix                    string
+	S3EnvPrefix             string
-	S3DocumentKeyPrefix            string
+	S3DocumentKeyPrefix     string
-	TransferToLayingGrowingMaxWeek int
 )
 
 func init() {
 	loadConfig()
 
 	// server configuration
-	AppEnv = defaultString(strings.TrimSpace(viper.GetString("APP_ENV")), "development")
+	IsProd = viper.GetString("APP_ENV") == "prod"
-	IsProd = AppEnv == "prod"
 	AppHost = viper.GetString("APP_HOST")
 	AppPort = viper.GetInt("APP_PORT")
 	Version = viper.GetString("VERSION")
@@ -110,10 +108,10 @@ func init() {
 	JWTResetPasswordExp = viper.GetInt("JWT_RESET_PASSWORD_EXP_MINUTES")
 	JWTVerifyEmailExp = viper.GetInt("JWT_VERIFY_EMAIL_EXP_MINUTES")
 
-	// Cors
+	//Cors
 	CORSAllowOrigins = parseList("CORS_ALLOW_ORIGINS")
 	CORSAllowMethods = parseListWithDefault("CORS_ALLOW_METHODS", "GET,POST,PUT,PATCH,DELETE,OPTIONS")
-	CORSAllowHeaders = parseListWithDefault("CORS_ALLOW_HEADERS", "Content-Type,Authorization,X-API-Key,X-Requested-With")
+	CORSAllowHeaders = parseListWithDefault("CORS_ALLOW_HEADERS", "Content-Type,Authorization,X-Requested-With")
 	CORSExposeHeaders = parseList("CORS_EXPOSE_HEADERS")
 	CORSAllowCredentials = viper.GetBool("CORS_ALLOW_CREDENTIALS")
 	CORSMaxAge = viper.GetInt("CORS_MAX_AGE")
@@ -121,11 +119,6 @@ func init() {
 	// Redis
 	RedisURL = viper.GetString("REDIS_URL")
 
-	TransferToLayingGrowingMaxWeek = viper.GetInt("TRANSFER_TO_LAYING_GROWING_MAX_WEEK")
-	if TransferToLayingGrowingMaxWeek <= 0 {
-		TransferToLayingGrowingMaxWeek = 19
-	}
-
 	// Object storage
 	S3Endpoint = strings.TrimSpace(viper.GetString("S3_ENDPOINT"))
 	S3Region = strings.TrimSpace(viper.GetString("S3_REGION"))
@@ -144,6 +137,7 @@ func init() {
 	// SSO integration
 	SSOIssuer = viper.GetString("SSO_ISSUER")
 	SSOJWKSURL = viper.GetString("SSO_JWKS_URL")
+	SSOHMACSecret = viper.GetString("SSO_HS_SECRET")
 	SSOAllowedAudiences = parseList("SSO_ALLOWED_AUDIENCES")
 	SSOAuthorizeURL = viper.GetString("SSO_AUTHORIZE_URL")
 	SSOTokenURL = viper.GetString("SSO_TOKEN_URL")
@@ -263,10 +257,6 @@ func defaultString(v, def string) string {
 	return v
 }
 
-func LayingWeekStart() int {
-	return TransferToLayingGrowingMaxWeek
-}
-
 func joinPath(parts ...string) string {
 	out := make([]string, 0, len(parts))
 	for _, part := range parts {
@@ -282,6 +272,9 @@ func ensureProdConfig() {
 	if SSOAuthorizeURL == "" || !strings.HasPrefix(SSOAuthorizeURL, "https://") {
 		panic("SSO_AUTHORIZE_URL must be https in production")
 	}
+	if strings.TrimSpace(SSOHMACSecret) == "" && strings.TrimSpace(SSOJWKSURL) == "" {
+		panic("SSO_JWKS_URL or SSO_HS_SECRET must be configured in production")
+	}
 	if SSOTokenURL == "" || !strings.HasPrefix(SSOTokenURL, "https://") {
 		panic("SSO_TOKEN_URL must be https in production")
 	}

internal/database/database.go

@@ -37,7 +37,7 @@ func Connect(dbHost, dbName string) *gorm.DB {
 	db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
 		Logger:                 logger.Default.LogMode(logger.Info),
 		SkipDefaultTransaction: true,
-		PrepareStmt:            false,
+		PrepareStmt:            true,
 		TranslateError:         true,
 	})
 	if err != nil {

internal/database/migrations/20251018120649_create_project_chick_ins_table.up.sql

@@ -1,57 +0,0 @@
-CREATE TABLE IF NOT EXISTS project_chickins (
-    id BIGSERIAL PRIMARY KEY,
-    project_flock_kandang_id BIGINT NOT NULL,
-    product_warehouse_id BIGINT NOT NULL,
-    chick_in_date DATE NOT NULL,
-    usage_qty NUMERIC(15, 3) NOT NULL,
-    pending_usage_qty NUMERIC(15, 3) DEFAULT 0,
-    notes TEXT,
-    created_by BIGINT NOT NULL,
-    created_at TIMESTAMPTZ DEFAULT now(),
-    updated_at TIMESTAMPTZ DEFAULT now(),
-    deleted_at TIMESTAMPTZ
-);
-
-DO $$
-BEGIN
-    IF to_regclass('project_flock_kandangs') IS NOT NULL THEN
-        ALTER TABLE project_chickins
-            ADD CONSTRAINT fk_project_chickins_kandang
-            FOREIGN KEY (project_flock_kandang_id)
-            REFERENCES project_flock_kandangs(id)
-            ON DELETE RESTRICT ON UPDATE CASCADE;
-    END IF;
-
-    IF to_regclass('product_warehouses') IS NOT NULL THEN
-        ALTER TABLE project_chickins
-            ADD CONSTRAINT fk_project_chickins_warehouse
-            FOREIGN KEY (product_warehouse_id)
-            REFERENCES product_warehouses(id)
-            ON DELETE CASCADE ON UPDATE CASCADE;
-    END IF;
-
-    IF to_regclass('users') IS NOT NULL THEN
-        ALTER TABLE project_chickins
-            ADD CONSTRAINT fk_project_chickins_created_by
-            FOREIGN KEY (created_by)
-            REFERENCES users(id)
-            ON DELETE RESTRICT ON UPDATE CASCADE;
-    END IF;
-END $$;
-
-CREATE INDEX IF NOT EXISTS idx_chickins_kandang_id ON project_chickins (project_flock_kandang_id)
-WHERE
-    deleted_at IS NULL;
-
-CREATE INDEX IF NOT EXISTS idx_chickins_warehouse_id ON project_chickins (product_warehouse_id)
-WHERE
-    deleted_at IS NULL;
-
-CREATE INDEX IF NOT EXISTS idx_chickins_created_by ON project_chickins (created_by);
-
-CREATE INDEX IF NOT EXISTS idx_chickins_kandang_deleted ON project_chickins (
-    project_flock_kandang_id,
-    deleted_at
-);
-
-CREATE INDEX IF NOT EXISTS idx_chickins_deleted_at ON project_chickins (deleted_at);

internal/database/migrations/20251020022357_create_project_flock_populations_table.up.sql

@@ -1,60 +0,0 @@
-CREATE TABLE IF NOT EXISTS project_flock_populations (
-    id BIGSERIAL PRIMARY KEY,
-    project_chickin_id BIGINT NOT NULL,
-    product_warehouse_id BIGINT NOT NULL,
-    total_qty NUMERIC(15, 3) NOT NULL,
-    total_used_qty NUMERIC(15, 3) DEFAULT 0,
-    notes TEXT,
-    created_by BIGINT NOT NULL,
-    created_at TIMESTAMPTZ DEFAULT now(),
-    updated_at TIMESTAMPTZ DEFAULT now(),
-    deleted_at TIMESTAMPTZ
-);
-
-DO $$
-BEGIN
-    IF to_regclass('project_chickins') IS NOT NULL THEN
-        ALTER TABLE project_flock_populations
-            ADD CONSTRAINT fk_project_flock_populations_chickin
-            FOREIGN KEY (project_chickin_id)
-            REFERENCES project_chickins(id)
-            ON DELETE RESTRICT ON UPDATE CASCADE;
-    END IF;
-
-    IF to_regclass('product_warehouses') IS NOT NULL THEN
-        ALTER TABLE project_flock_populations
-            ADD CONSTRAINT fk_project_flock_populations_warehouse
-            FOREIGN KEY (product_warehouse_id)
-            REFERENCES product_warehouses(id)
-            ON DELETE RESTRICT ON UPDATE CASCADE;
-    END IF;
-
-    IF to_regclass('users') IS NOT NULL THEN
-        ALTER TABLE project_flock_populations
-            ADD CONSTRAINT fk_project_flock_populations_created_by
-            FOREIGN KEY (created_by)
-            REFERENCES users(id)
-            ON DELETE RESTRICT ON UPDATE CASCADE;
-    END IF;
-END $$;
-
-CREATE INDEX IF NOT EXISTS idx_populations_chickin_id ON project_flock_populations (project_chickin_id)
-WHERE
-    deleted_at IS NULL;
-
-CREATE INDEX IF NOT EXISTS idx_populations_warehouse_id ON project_flock_populations (product_warehouse_id)
-WHERE
-    deleted_at IS NULL;
-
-CREATE INDEX IF NOT EXISTS idx_populations_created_by ON project_flock_populations (created_by);
-
-CREATE INDEX IF NOT EXISTS idx_populations_chickin_deleted ON project_flock_populations (
-    project_chickin_id,
-    deleted_at
-);
-
-CREATE INDEX IF NOT EXISTS idx_populations_deleted_at ON project_flock_populations (deleted_at);
-
-CREATE UNIQUE INDEX IF NOT EXISTS idx_populations_chickin_unique ON project_flock_populations (project_chickin_id)
-WHERE
-    deleted_at IS NULL;

internal/database/migrations/20251022024829_create_project_chickin_details.up.sql

@@ -12,7 +12,7 @@ CREATE TABLE IF NOT EXISTS project_chickin_details (
 
 DO $$
 BEGIN
-    IF to_regclass('project_chickins') IS NOT NULL THEN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'project_chickins') THEN
         ALTER TABLE project_chickin_details
             ADD CONSTRAINT fk_project_chickin_id
             FOREIGN KEY (project_chickin_id)
@@ -20,7 +20,7 @@ BEGIN
             ON DELETE CASCADE ON UPDATE CASCADE;
     END IF;
 
-    IF to_regclass('product_warehouses') IS NOT NULL THEN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'product_warehouses') THEN
         ALTER TABLE project_chickin_details
             ADD CONSTRAINT fk_product_warehouse_id
             FOREIGN KEY (product_warehouse_id)
@@ -28,7 +28,7 @@ BEGIN
             ON DELETE RESTRICT ON UPDATE CASCADE;
     END IF;
 
-    IF to_regclass('users') IS NOT NULL THEN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'users') THEN
         ALTER TABLE project_chickin_details
             ADD CONSTRAINT fk_created_by
             FOREIGN KEY (created_by)
@@ -42,4 +42,4 @@ CREATE INDEX IF NOT EXISTS idx_project_chickin_details_project_chickin_id ON pro
 
 CREATE INDEX IF NOT EXISTS idx_project_chickin_details_product_warehouse_id ON project_chickin_details (product_warehouse_id);
 
-CREATE INDEX IF NOT EXISTS idx_project_chickin_details_created_by ON project_chickin_details (created_by);
+CREATE INDEX IF NOT EXISTS idx_project_chickin_details_created_by ON project_chickin_details (created_by);

internal/database/migrations/20260217000000_bootstrap_fifo_stock_v2_core_pre_seed.down.sql

@@ -1,24 +0,0 @@
-BEGIN;
-
-DROP INDEX IF EXISTS idx_stock_allocations_idempotency;
-DROP INDEX IF EXISTS idx_stock_allocations_flag_group;
-DROP INDEX IF EXISTS idx_stock_allocations_engine_version;
-
-ALTER TABLE stock_allocations
-    DROP COLUMN IF EXISTS idempotency_key,
-    DROP COLUMN IF EXISTS reflow_run_id,
-    DROP COLUMN IF EXISTS function_code,
-    DROP COLUMN IF EXISTS flag_group_code,
-    DROP COLUMN IF EXISTS engine_version;
-
-DROP TABLE IF EXISTS fifo_stock_v2_shadow_allocations;
-DROP TABLE IF EXISTS fifo_stock_v2_reflow_checkpoints;
-DROP TABLE IF EXISTS fifo_stock_v2_reflow_runs;
-DROP TABLE IF EXISTS fifo_stock_v2_operation_log;
-DROP TABLE IF EXISTS fifo_stock_v2_overconsume_rules;
-DROP TABLE IF EXISTS fifo_stock_v2_route_rules;
-DROP TABLE IF EXISTS fifo_stock_v2_traits;
-DROP TABLE IF EXISTS fifo_stock_v2_flag_members;
-DROP TABLE IF EXISTS fifo_stock_v2_flag_groups;
-
-COMMIT;

internal/database/migrations/20260217000000_bootstrap_fifo_stock_v2_core_pre_seed.up.sql

@@ -1,154 +0,0 @@
-BEGIN;
-
--- Bootstrap FIFO v2 core tables before seed migration (20260218090010).
--- Keep definitions aligned with 20260304033546_create_fifo_stock_v2_core.
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_flag_groups (
-    code VARCHAR(64) PRIMARY KEY,
-    name VARCHAR(128) NOT NULL,
-    priority INT NOT NULL DEFAULT 100,
-    is_active BOOLEAN NOT NULL DEFAULT TRUE,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_flag_members (
-    flag_name VARCHAR(64) PRIMARY KEY,
-    flag_group_code VARCHAR(64) NOT NULL REFERENCES fifo_stock_v2_flag_groups(code),
-    priority INT NOT NULL DEFAULT 100,
-    is_active BOOLEAN NOT NULL DEFAULT TRUE,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_traits (
-    id BIGSERIAL PRIMARY KEY,
-    source_table VARCHAR(64) NOT NULL,
-    lane VARCHAR(16) NOT NULL CHECK (lane IN ('STOCKABLE', 'USABLE')),
-    date_table VARCHAR(64) NULL,
-    date_join_left_col VARCHAR(64) NULL,
-    date_join_right_col VARCHAR(64) NULL,
-    date_column VARCHAR(64) NOT NULL,
-    fallback_date_column VARCHAR(64) NULL,
-    sort_priority INT NOT NULL DEFAULT 100,
-    id_column VARCHAR(64) NOT NULL DEFAULT 'id',
-    is_active BOOLEAN NOT NULL DEFAULT TRUE,
-    UNIQUE (source_table, lane)
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_route_rules (
-    id BIGSERIAL PRIMARY KEY,
-    flag_group_code VARCHAR(64) NOT NULL REFERENCES fifo_stock_v2_flag_groups(code),
-    lane VARCHAR(16) NOT NULL CHECK (lane IN ('STOCKABLE', 'USABLE')),
-    function_code VARCHAR(64) NOT NULL,
-    source_table VARCHAR(64) NOT NULL,
-    source_id_column VARCHAR(64) NOT NULL DEFAULT 'id',
-    product_warehouse_col VARCHAR(64) NOT NULL,
-    quantity_col VARCHAR(64) NOT NULL,
-    used_quantity_col VARCHAR(64) NULL,
-    pending_quantity_col VARCHAR(64) NULL,
-    scope_sql TEXT NULL,
-    legacy_type_key VARCHAR(100) NOT NULL,
-    allow_pending_default BOOLEAN NOT NULL DEFAULT TRUE,
-    is_active BOOLEAN NOT NULL DEFAULT TRUE,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    UNIQUE (flag_group_code, lane, function_code, source_table)
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_overconsume_rules (
-    id BIGSERIAL PRIMARY KEY,
-    flag_group_code VARCHAR(64) NULL REFERENCES fifo_stock_v2_flag_groups(code),
-    function_code VARCHAR(64) NULL,
-    lane VARCHAR(16) NOT NULL DEFAULT 'USABLE' CHECK (lane IN ('STOCKABLE', 'USABLE')),
-    allow_overconsume BOOLEAN NOT NULL,
-    priority INT NOT NULL DEFAULT 100,
-    reason TEXT NULL,
-    is_active BOOLEAN NOT NULL DEFAULT TRUE
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_operation_log (
-    id BIGSERIAL PRIMARY KEY,
-    idempotency_key VARCHAR(128) NOT NULL,
-    operation VARCHAR(16) NOT NULL CHECK (operation IN ('ALLOCATE', 'ROLLBACK', 'REFLOW', 'RECALCULATE')),
-    product_warehouse_id BIGINT NOT NULL,
-    flag_group_code VARCHAR(64) NOT NULL,
-    usable_type VARCHAR(100) NULL,
-    usable_id BIGINT NULL,
-    request_hash VARCHAR(64) NOT NULL,
-    status VARCHAR(16) NOT NULL CHECK (status IN ('RUNNING', 'DONE', 'FAILED')),
-    result_payload JSONB NULL,
-    error_text TEXT NULL,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    finished_at TIMESTAMPTZ NULL,
-    UNIQUE (idempotency_key, operation)
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_reflow_runs (
-    id BIGSERIAL PRIMARY KEY,
-    mode VARCHAR(16) NOT NULL CHECK (mode IN ('DRY_RUN', 'APPLY')),
-    status VARCHAR(16) NOT NULL CHECK (status IN ('RUNNING', 'PAUSED', 'DONE', 'FAILED', 'CANCELLED')),
-    as_of TIMESTAMPTZ NULL,
-    started_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    finished_at TIMESTAMPTZ NULL,
-    total_shards INT NOT NULL DEFAULT 0,
-    processed_shards INT NOT NULL DEFAULT 0,
-    processed_rows BIGINT NOT NULL DEFAULT 0,
-    mismatch_rows BIGINT NOT NULL DEFAULT 0,
-    created_by BIGINT NULL,
-    note TEXT NULL
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_reflow_checkpoints (
-    id BIGSERIAL PRIMARY KEY,
-    run_id BIGINT NOT NULL REFERENCES fifo_stock_v2_reflow_runs(id) ON DELETE CASCADE,
-    flag_group_code VARCHAR(64) NOT NULL,
-    product_warehouse_id BIGINT NOT NULL,
-    last_sort_at TIMESTAMPTZ NULL,
-    last_source_table VARCHAR(64) NULL,
-    last_source_id BIGINT NULL,
-    status VARCHAR(16) NOT NULL CHECK (status IN ('PENDING', 'RUNNING', 'DONE', 'FAILED')) DEFAULT 'PENDING',
-    retry_count INT NOT NULL DEFAULT 0,
-    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    UNIQUE (run_id, flag_group_code, product_warehouse_id)
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_shadow_allocations (
-    id BIGSERIAL PRIMARY KEY,
-    run_id BIGINT NOT NULL REFERENCES fifo_stock_v2_reflow_runs(id) ON DELETE CASCADE,
-    product_warehouse_id BIGINT NOT NULL,
-    stockable_type VARCHAR(100) NOT NULL,
-    stockable_id BIGINT NOT NULL,
-    usable_type VARCHAR(100) NOT NULL,
-    usable_id BIGINT NOT NULL,
-    qty NUMERIC(15,3) NOT NULL,
-    status VARCHAR(20) NOT NULL DEFAULT 'ACTIVE',
-    sort_at TIMESTAMPTZ NULL,
-    source_table VARCHAR(64) NULL,
-    source_id BIGINT NULL,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-
-CREATE INDEX IF NOT EXISTS idx_fifo_v2_shadow_run_usable
-    ON fifo_stock_v2_shadow_allocations(run_id, usable_type, usable_id);
-
-CREATE INDEX IF NOT EXISTS idx_fifo_v2_shadow_run_stockable
-    ON fifo_stock_v2_shadow_allocations(run_id, stockable_type, stockable_id);
-
-ALTER TABLE stock_allocations
-    ADD COLUMN IF NOT EXISTS engine_version VARCHAR(8) NOT NULL DEFAULT 'v1',
-    ADD COLUMN IF NOT EXISTS flag_group_code VARCHAR(64) NULL,
-    ADD COLUMN IF NOT EXISTS function_code VARCHAR(64) NULL,
-    ADD COLUMN IF NOT EXISTS reflow_run_id BIGINT NULL,
-    ADD COLUMN IF NOT EXISTS idempotency_key VARCHAR(128) NULL;
-
-CREATE INDEX IF NOT EXISTS idx_stock_allocations_engine_version
-    ON stock_allocations(engine_version);
-
-CREATE INDEX IF NOT EXISTS idx_stock_allocations_flag_group
-    ON stock_allocations(flag_group_code);
-
-CREATE INDEX IF NOT EXISTS idx_stock_allocations_idempotency
-    ON stock_allocations(idempotency_key);
-
-COMMIT;

internal/database/migrations/20260218090010_seed_fifo_stock_v2_config.down.sql

@@ -1,60 +0,0 @@
-BEGIN;
-
-DO $$
-BEGIN
-    IF to_regclass('public.fifo_stock_v2_overconsume_rules') IS NOT NULL THEN
-        EXECUTE '
-            DELETE FROM fifo_stock_v2_overconsume_rules
-            WHERE reason IN (
-                ''fifo_v2_default_allow'',
-                ''fifo_v2_exception_ayam_depletion_block'',
-                ''fifo_v2_exception_marketing_block'',
-                ''fifo_v2_exception_transfer_block'',
-                ''fifo_v2_exception_adjustment_block'',
-                ''fifo_v2_exception_transfer_laying_block''
-            )
-        ';
-    END IF;
-
-    IF to_regclass('public.fifo_stock_v2_route_rules') IS NOT NULL THEN
-        EXECUTE '
-            DELETE FROM fifo_stock_v2_route_rules
-            WHERE flag_group_code IN (''AYAM'', ''AFKIR_CULLING_MATI'', ''PAKAN'', ''OVK'', ''TELUR'', ''TELUR_GRADE'')
-        ';
-    END IF;
-
-    IF to_regclass('public.fifo_stock_v2_traits') IS NOT NULL THEN
-        EXECUTE '
-            DELETE FROM fifo_stock_v2_traits
-            WHERE source_table IN (
-                ''purchase_items'',
-                ''stock_transfer_details'',
-                ''laying_transfer_targets'',
-                ''laying_transfer_sources'',
-                ''adjustment_stocks'',
-                ''recording_stocks'',
-                ''recording_depletions'',
-                ''recording_eggs'',
-                ''marketing_delivery_products'',
-                ''project_chickins'',
-                ''project_flock_populations''
-            )
-        ';
-    END IF;
-
-    IF to_regclass('public.fifo_stock_v2_flag_members') IS NOT NULL THEN
-        EXECUTE '
-            DELETE FROM fifo_stock_v2_flag_members
-            WHERE flag_group_code IN (''AYAM'', ''AFKIR_CULLING_MATI'', ''PAKAN'', ''OVK'', ''TELUR'', ''TELUR_GRADE'')
-        ';
-    END IF;
-
-    IF to_regclass('public.fifo_stock_v2_flag_groups') IS NOT NULL THEN
-        EXECUTE '
-            DELETE FROM fifo_stock_v2_flag_groups
-            WHERE code IN (''AYAM'', ''AFKIR_CULLING_MATI'', ''PAKAN'', ''OVK'', ''TELUR'', ''TELUR_GRADE'')
-        ';
-    END IF;
-END $$;
-
-COMMIT;

internal/database/migrations/20260218090010_seed_fifo_stock_v2_config.up.sql

@@ -1,6 +0,0 @@
-BEGIN;
-
--- no-op: moved to 20260306090010_seed_fifo_stock_v2_config_after_core.up.sql
--- to ensure FIFO core tables exist before seeding on fresh migrations.
-
-COMMIT;

internal/database/migrations/20260225073024_adjustment_stocks_add_fifo_v2_columns.down.sql

@@ -1,12 +0,0 @@
-BEGIN;
-
-DROP INDEX IF EXISTS idx_adjustment_stocks_function_code;
-DROP INDEX IF EXISTS idx_adjustment_stocks_transaction_type;
-
-ALTER TABLE adjustment_stocks
-    DROP COLUMN IF EXISTS grand_total,
-    DROP COLUMN IF EXISTS price,
-    DROP COLUMN IF EXISTS function_code,
-    DROP COLUMN IF EXISTS transaction_type;
-
-COMMIT;

internal/database/migrations/20260225073024_adjustment_stocks_add_fifo_v2_columns.up.sql

@@ -1,23 +0,0 @@
-BEGIN;
-
-ALTER TABLE adjustment_stocks
-    ADD COLUMN IF NOT EXISTS transaction_type VARCHAR(100) NOT NULL DEFAULT 'LEGACY',
-    ADD COLUMN IF NOT EXISTS function_code VARCHAR(64),
-    ADD COLUMN IF NOT EXISTS price NUMERIC(15, 3) NOT NULL DEFAULT 0,
-    ADD COLUMN IF NOT EXISTS grand_total NUMERIC(15, 3) NOT NULL DEFAULT 0;
-
-UPDATE adjustment_stocks
-SET function_code = CASE
-    WHEN COALESCE(total_qty, 0) > 0 THEN 'ADJUSTMENT_IN'
-    WHEN COALESCE(usage_qty, 0) > 0 THEN 'ADJUSTMENT_OUT'
-    ELSE 'ADJUSTMENT_IN'
-END
-WHERE function_code IS NULL OR function_code = '';
-
-CREATE INDEX IF NOT EXISTS idx_adjustment_stocks_transaction_type
-    ON adjustment_stocks(transaction_type);
-
-CREATE INDEX IF NOT EXISTS idx_adjustment_stocks_function_code
-    ON adjustment_stocks(function_code);
-
-COMMIT;

internal/database/migrations/20260228143207_disable_chickin_fifo_consumption.down.sql

@@ -1,5 +0,0 @@
-BEGIN;
-
--- no-op: moved to 20260306090011_disable_chickin_fifo_consumption_after_core.down.sql
-
-COMMIT;

internal/database/migrations/20260228143207_disable_chickin_fifo_consumption.up.sql

@@ -1,6 +0,0 @@
-BEGIN;
-
--- no-op: moved to 20260306090011_disable_chickin_fifo_consumption_after_core.up.sql
--- to ensure FIFO core + seed are applied before this data update migration.
-
-COMMIT;

internal/database/migrations/20260302064432_add_allocation_purpose_to_stock_allocations.down.sql

@@ -1,13 +0,0 @@
-BEGIN;
-
-DROP INDEX IF EXISTS idx_stock_allocations_purpose_stockable_active;
-DROP INDEX IF EXISTS idx_stock_allocations_purpose_usable_active;
-DROP INDEX IF EXISTS idx_stock_allocations_purpose_status;
-
-ALTER TABLE stock_allocations
-    DROP CONSTRAINT IF EXISTS stock_allocations_allocation_purpose_check;
-
-ALTER TABLE stock_allocations
-    DROP COLUMN IF EXISTS allocation_purpose;
-
-COMMIT;

internal/database/migrations/20260302064432_add_allocation_purpose_to_stock_allocations.up.sql

@@ -1,33 +0,0 @@
-BEGIN;
-
-ALTER TABLE stock_allocations
-    ADD COLUMN IF NOT EXISTS allocation_purpose VARCHAR(32);
-
-UPDATE stock_allocations
-SET allocation_purpose = 'CONSUME'
-WHERE allocation_purpose IS NULL
-   OR BTRIM(allocation_purpose) = '';
-
-ALTER TABLE stock_allocations
-    ALTER COLUMN allocation_purpose SET DEFAULT 'CONSUME',
-    ALTER COLUMN allocation_purpose SET NOT NULL;
-
-ALTER TABLE stock_allocations
-    DROP CONSTRAINT IF EXISTS stock_allocations_allocation_purpose_check;
-
-ALTER TABLE stock_allocations
-    ADD CONSTRAINT stock_allocations_allocation_purpose_check
-    CHECK (allocation_purpose IN ('CONSUME', 'TRACE_CHICKIN'));
-
-CREATE INDEX IF NOT EXISTS idx_stock_allocations_purpose_status
-    ON stock_allocations (allocation_purpose, status);
-
-CREATE INDEX IF NOT EXISTS idx_stock_allocations_purpose_usable_active
-    ON stock_allocations (allocation_purpose, usable_type, usable_id)
-    WHERE status = 'ACTIVE';
-
-CREATE INDEX IF NOT EXISTS idx_stock_allocations_purpose_stockable_active
-    ON stock_allocations (allocation_purpose, stockable_type, stockable_id)
-    WHERE status = 'ACTIVE';
-
-COMMIT;

internal/database/migrations/20260304033546_create_fifo_stock_v2_core.down.sql

@@ -1,24 +0,0 @@
-BEGIN;
-
-DROP INDEX IF EXISTS idx_stock_allocations_idempotency;
-DROP INDEX IF EXISTS idx_stock_allocations_flag_group;
-DROP INDEX IF EXISTS idx_stock_allocations_engine_version;
-
-ALTER TABLE stock_allocations
-    DROP COLUMN IF EXISTS idempotency_key,
-    DROP COLUMN IF EXISTS reflow_run_id,
-    DROP COLUMN IF EXISTS function_code,
-    DROP COLUMN IF EXISTS flag_group_code,
-    DROP COLUMN IF EXISTS engine_version;
-
-DROP TABLE IF EXISTS fifo_stock_v2_shadow_allocations;
-DROP TABLE IF EXISTS fifo_stock_v2_reflow_checkpoints;
-DROP TABLE IF EXISTS fifo_stock_v2_reflow_runs;
-DROP TABLE IF EXISTS fifo_stock_v2_operation_log;
-DROP TABLE IF EXISTS fifo_stock_v2_overconsume_rules;
-DROP TABLE IF EXISTS fifo_stock_v2_route_rules;
-DROP TABLE IF EXISTS fifo_stock_v2_traits;
-DROP TABLE IF EXISTS fifo_stock_v2_flag_members;
-DROP TABLE IF EXISTS fifo_stock_v2_flag_groups;
-
-COMMIT;

internal/database/migrations/20260304033546_create_fifo_stock_v2_core.up.sql

@@ -1,151 +0,0 @@
-BEGIN;
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_flag_groups (
-    code VARCHAR(64) PRIMARY KEY,
-    name VARCHAR(128) NOT NULL,
-    priority INT NOT NULL DEFAULT 100,
-    is_active BOOLEAN NOT NULL DEFAULT TRUE,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_flag_members (
-    flag_name VARCHAR(64) PRIMARY KEY,
-    flag_group_code VARCHAR(64) NOT NULL REFERENCES fifo_stock_v2_flag_groups(code),
-    priority INT NOT NULL DEFAULT 100,
-    is_active BOOLEAN NOT NULL DEFAULT TRUE,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_traits (
-    id BIGSERIAL PRIMARY KEY,
-    source_table VARCHAR(64) NOT NULL,
-    lane VARCHAR(16) NOT NULL CHECK (lane IN ('STOCKABLE', 'USABLE')),
-    date_table VARCHAR(64) NULL,
-    date_join_left_col VARCHAR(64) NULL,
-    date_join_right_col VARCHAR(64) NULL,
-    date_column VARCHAR(64) NOT NULL,
-    fallback_date_column VARCHAR(64) NULL,
-    sort_priority INT NOT NULL DEFAULT 100,
-    id_column VARCHAR(64) NOT NULL DEFAULT 'id',
-    is_active BOOLEAN NOT NULL DEFAULT TRUE,
-    UNIQUE (source_table, lane)
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_route_rules (
-    id BIGSERIAL PRIMARY KEY,
-    flag_group_code VARCHAR(64) NOT NULL REFERENCES fifo_stock_v2_flag_groups(code),
-    lane VARCHAR(16) NOT NULL CHECK (lane IN ('STOCKABLE', 'USABLE')),
-    function_code VARCHAR(64) NOT NULL,
-    source_table VARCHAR(64) NOT NULL,
-    source_id_column VARCHAR(64) NOT NULL DEFAULT 'id',
-    product_warehouse_col VARCHAR(64) NOT NULL,
-    quantity_col VARCHAR(64) NOT NULL,
-    used_quantity_col VARCHAR(64) NULL,
-    pending_quantity_col VARCHAR(64) NULL,
-    scope_sql TEXT NULL,
-    legacy_type_key VARCHAR(100) NOT NULL,
-    allow_pending_default BOOLEAN NOT NULL DEFAULT TRUE,
-    is_active BOOLEAN NOT NULL DEFAULT TRUE,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    UNIQUE (flag_group_code, lane, function_code, source_table)
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_overconsume_rules (
-    id BIGSERIAL PRIMARY KEY,
-    flag_group_code VARCHAR(64) NULL REFERENCES fifo_stock_v2_flag_groups(code),
-    function_code VARCHAR(64) NULL,
-    lane VARCHAR(16) NOT NULL DEFAULT 'USABLE' CHECK (lane IN ('STOCKABLE', 'USABLE')),
-    allow_overconsume BOOLEAN NOT NULL,
-    priority INT NOT NULL DEFAULT 100,
-    reason TEXT NULL,
-    is_active BOOLEAN NOT NULL DEFAULT TRUE
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_operation_log (
-    id BIGSERIAL PRIMARY KEY,
-    idempotency_key VARCHAR(128) NOT NULL,
-    operation VARCHAR(16) NOT NULL CHECK (operation IN ('ALLOCATE', 'ROLLBACK', 'REFLOW', 'RECALCULATE')),
-    product_warehouse_id BIGINT NOT NULL,
-    flag_group_code VARCHAR(64) NOT NULL,
-    usable_type VARCHAR(100) NULL,
-    usable_id BIGINT NULL,
-    request_hash VARCHAR(64) NOT NULL,
-    status VARCHAR(16) NOT NULL CHECK (status IN ('RUNNING', 'DONE', 'FAILED')),
-    result_payload JSONB NULL,
-    error_text TEXT NULL,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    finished_at TIMESTAMPTZ NULL,
-    UNIQUE (idempotency_key, operation)
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_reflow_runs (
-    id BIGSERIAL PRIMARY KEY,
-    mode VARCHAR(16) NOT NULL CHECK (mode IN ('DRY_RUN', 'APPLY')),
-    status VARCHAR(16) NOT NULL CHECK (status IN ('RUNNING', 'PAUSED', 'DONE', 'FAILED', 'CANCELLED')),
-    as_of TIMESTAMPTZ NULL,
-    started_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    finished_at TIMESTAMPTZ NULL,
-    total_shards INT NOT NULL DEFAULT 0,
-    processed_shards INT NOT NULL DEFAULT 0,
-    processed_rows BIGINT NOT NULL DEFAULT 0,
-    mismatch_rows BIGINT NOT NULL DEFAULT 0,
-    created_by BIGINT NULL,
-    note TEXT NULL
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_reflow_checkpoints (
-    id BIGSERIAL PRIMARY KEY,
-    run_id BIGINT NOT NULL REFERENCES fifo_stock_v2_reflow_runs(id) ON DELETE CASCADE,
-    flag_group_code VARCHAR(64) NOT NULL,
-    product_warehouse_id BIGINT NOT NULL,
-    last_sort_at TIMESTAMPTZ NULL,
-    last_source_table VARCHAR(64) NULL,
-    last_source_id BIGINT NULL,
-    status VARCHAR(16) NOT NULL CHECK (status IN ('PENDING', 'RUNNING', 'DONE', 'FAILED')) DEFAULT 'PENDING',
-    retry_count INT NOT NULL DEFAULT 0,
-    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-    UNIQUE (run_id, flag_group_code, product_warehouse_id)
-);
-
-CREATE TABLE IF NOT EXISTS fifo_stock_v2_shadow_allocations (
-    id BIGSERIAL PRIMARY KEY,
-    run_id BIGINT NOT NULL REFERENCES fifo_stock_v2_reflow_runs(id) ON DELETE CASCADE,
-    product_warehouse_id BIGINT NOT NULL,
-    stockable_type VARCHAR(100) NOT NULL,
-    stockable_id BIGINT NOT NULL,
-    usable_type VARCHAR(100) NOT NULL,
-    usable_id BIGINT NOT NULL,
-    qty NUMERIC(15,3) NOT NULL,
-    status VARCHAR(20) NOT NULL DEFAULT 'ACTIVE',
-    sort_at TIMESTAMPTZ NULL,
-    source_table VARCHAR(64) NULL,
-    source_id BIGINT NULL,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-
-CREATE INDEX IF NOT EXISTS idx_fifo_v2_shadow_run_usable
-    ON fifo_stock_v2_shadow_allocations(run_id, usable_type, usable_id);
-
-CREATE INDEX IF NOT EXISTS idx_fifo_v2_shadow_run_stockable
-    ON fifo_stock_v2_shadow_allocations(run_id, stockable_type, stockable_id);
-
-ALTER TABLE stock_allocations
-    ADD COLUMN IF NOT EXISTS engine_version VARCHAR(8) NOT NULL DEFAULT 'v1',
-    ADD COLUMN IF NOT EXISTS flag_group_code VARCHAR(64) NULL,
-    ADD COLUMN IF NOT EXISTS function_code VARCHAR(64) NULL,
-    ADD COLUMN IF NOT EXISTS reflow_run_id BIGINT NULL,
-    ADD COLUMN IF NOT EXISTS idempotency_key VARCHAR(128) NULL;
-
-CREATE INDEX IF NOT EXISTS idx_stock_allocations_engine_version
-    ON stock_allocations(engine_version);
-
-CREATE INDEX IF NOT EXISTS idx_stock_allocations_flag_group
-    ON stock_allocations(flag_group_code);
-
-CREATE INDEX IF NOT EXISTS idx_stock_allocations_idempotency
-    ON stock_allocations(idempotency_key);
-
-COMMIT;

internal/database/migrations/20260304033605_add_deferred_execution_to_laying_transfers.down.sql

@@ -1,15 +0,0 @@
-BEGIN;
-
-DROP INDEX IF EXISTS idx_laying_transfers_executed_by;
-DROP INDEX IF EXISTS idx_laying_transfers_executed_at;
-DROP INDEX IF EXISTS idx_laying_transfers_effective_move_date;
-
-ALTER TABLE laying_transfers
-    DROP CONSTRAINT IF EXISTS fk_laying_transfers_executed_by;
-
-ALTER TABLE laying_transfers
-    DROP COLUMN IF EXISTS executed_by,
-    DROP COLUMN IF EXISTS executed_at,
-    DROP COLUMN IF EXISTS effective_move_date;
-
-COMMIT;

internal/database/migrations/20260304033605_add_deferred_execution_to_laying_transfers.up.sql

@@ -1,50 +0,0 @@
-BEGIN;
-
-ALTER TABLE laying_transfers
-    ADD COLUMN IF NOT EXISTS effective_move_date DATE,
-    ADD COLUMN IF NOT EXISTS executed_at TIMESTAMPTZ,
-    ADD COLUMN IF NOT EXISTS executed_by BIGINT;
-
-DO $$
-BEGIN
-    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'users')
-        AND NOT EXISTS (
-            SELECT 1
-            FROM pg_constraint
-            WHERE conname = 'fk_laying_transfers_executed_by'
-        ) THEN
-        ALTER TABLE laying_transfers
-            ADD CONSTRAINT fk_laying_transfers_executed_by
-            FOREIGN KEY (executed_by)
-            REFERENCES users(id)
-            ON DELETE SET NULL
-            ON UPDATE CASCADE;
-    END IF;
-END $$;
-
-CREATE INDEX IF NOT EXISTS idx_laying_transfers_effective_move_date
-    ON laying_transfers(effective_move_date);
-
-CREATE INDEX IF NOT EXISTS idx_laying_transfers_executed_at
-    ON laying_transfers(executed_at);
-
-CREATE INDEX IF NOT EXISTS idx_laying_transfers_executed_by
-    ON laying_transfers(executed_by);
-
--- Backfill historical approved transfers. Before deferred execution,
--- approved transfers were executed immediately during approval.
-UPDATE laying_transfers lt
-SET
-    effective_move_date = COALESCE(lt.effective_move_date, lt.transfer_date),
-    executed_at = COALESCE(lt.executed_at, lt.updated_at),
-    executed_by = COALESCE(lt.executed_by, lt.created_by)
-WHERE (
-    SELECT a.action
-    FROM approvals a
-    WHERE a.approvable_type = 'TRANSFER_TO_LAYINGS'
-      AND a.approvable_id = lt.id
-    ORDER BY a.id DESC
-    LIMIT 1
-) = 'APPROVED';
-
-COMMIT;

internal/database/migrations/20260304063215_fix_fifo_chickin_out.down.sql

@@ -1,5 +0,0 @@
-BEGIN;
-
--- no-op: moved to 20260306090012_fix_fifo_chickin_out_after_seed.down.sql
-
-COMMIT;

internal/database/migrations/20260304063215_fix_fifo_chickin_out.up.sql

@@ -1,6 +0,0 @@
-BEGIN;
-
--- no-op: moved to 20260306090012_fix_fifo_chickin_out_after_seed.up.sql
--- to ensure AYAM flag group exists before route-rule upsert.
-
-COMMIT;

internal/database/migrations/20260304101500_add_economic_cutoff_date_to_laying_transfers.down.sql

@@ -1,8 +0,0 @@
-BEGIN;
-
-DROP INDEX IF EXISTS idx_laying_transfers_economic_cutoff_date;
-
-ALTER TABLE laying_transfers
-    DROP COLUMN IF EXISTS economic_cutoff_date;
-
-COMMIT;

internal/database/migrations/20260304101500_add_economic_cutoff_date_to_laying_transfers.up.sql

@@ -1,13 +0,0 @@
-BEGIN;
-
-ALTER TABLE laying_transfers
-    ADD COLUMN IF NOT EXISTS economic_cutoff_date DATE;
-
-CREATE INDEX IF NOT EXISTS idx_laying_transfers_economic_cutoff_date
-    ON laying_transfers(economic_cutoff_date);
-
-UPDATE laying_transfers
-SET economic_cutoff_date = COALESCE(economic_cutoff_date, effective_move_date, transfer_date)
-WHERE economic_cutoff_date IS NULL;
-
-COMMIT;

internal/database/migrations/20260305105044_add_ayam_flag_member_fifo_v2.down.sql

@@ -1,5 +0,0 @@
-BEGIN;
-
--- no-op: moved to 20260306090013_add_ayam_flag_member_fifo_v2_after_seed.down.sql
-
-COMMIT;

internal/database/migrations/20260305105044_add_ayam_flag_member_fifo_v2.up.sql

@@ -1,6 +0,0 @@
-BEGIN;
-
--- no-op: moved to 20260306090013_add_ayam_flag_member_fifo_v2_after_seed.up.sql
--- to ensure AYAM flag group exists before inserting AYAM member.
-
-COMMIT;

internal/database/migrations/20260306090010_seed_fifo_stock_v2_config_after_core.down.sql

@@ -1,37 +0,0 @@
-BEGIN;
-
-DELETE FROM fifo_stock_v2_overconsume_rules
-WHERE reason IN (
-    'fifo_v2_default_allow',
-    'fifo_v2_exception_ayam_depletion_block',
-    'fifo_v2_exception_marketing_block',
-    'fifo_v2_exception_transfer_block',
-    'fifo_v2_exception_adjustment_block',
-    'fifo_v2_exception_transfer_laying_block'
-);
-
-DELETE FROM fifo_stock_v2_route_rules
-WHERE flag_group_code IN ('AYAM', 'AFKIR_CULLING_MATI', 'PAKAN', 'OVK', 'TELUR', 'TELUR_GRADE');
-
-DELETE FROM fifo_stock_v2_traits
-WHERE source_table IN (
-    'purchase_items',
-    'stock_transfer_details',
-    'laying_transfer_targets',
-    'laying_transfer_sources',
-    'adjustment_stocks',
-    'recording_stocks',
-    'recording_depletions',
-    'recording_eggs',
-    'marketing_delivery_products',
-    'project_chickins',
-    'project_flock_populations'
-);
-
-DELETE FROM fifo_stock_v2_flag_members
-WHERE flag_group_code IN ('AYAM', 'AFKIR_CULLING_MATI', 'PAKAN', 'OVK', 'TELUR', 'TELUR_GRADE');
-
-DELETE FROM fifo_stock_v2_flag_groups
-WHERE code IN ('AYAM', 'AFKIR_CULLING_MATI', 'PAKAN', 'OVK', 'TELUR', 'TELUR_GRADE');
-
-COMMIT;

internal/database/migrations/20260306090010_seed_fifo_stock_v2_config_after_core.up.sql

@@ -1,250 +0,0 @@
-BEGIN;
-
-INSERT INTO fifo_stock_v2_flag_groups(code, name, priority)
-VALUES
-    ('AYAM', 'AYAM', 10),
-    ('AFKIR_CULLING_MATI', 'AFKIR/CULLING/MATI', 20),
-    ('PAKAN', 'PAKAN', 30),
-    ('OVK', 'OVK', 40),
-    ('TELUR', 'TELUR', 50),
-    ('TELUR_GRADE', 'UTUH/PUTIH/RETAK/PECAH/PAPACAL/JUMBO', 60)
-ON CONFLICT (code) DO UPDATE
-SET
-    name = EXCLUDED.name,
-    priority = EXCLUDED.priority,
-    updated_at = NOW();
-
-INSERT INTO fifo_stock_v2_flag_members(flag_name, flag_group_code, priority)
-VALUES
-    ('DOC', 'AYAM', 10),
-    ('PULLET', 'AYAM', 20),
-    ('LAYER', 'AYAM', 30),
-
-    ('AYAM-AFKIR', 'AFKIR_CULLING_MATI', 10),
-    ('AYAM-CULLING', 'AFKIR_CULLING_MATI', 20),
-    ('AYAM-MATI', 'AFKIR_CULLING_MATI', 30),
-
-    ('PAKAN', 'PAKAN', 10),
-    ('PRE-STARTER', 'PAKAN', 20),
-    ('STARTER', 'PAKAN', 30),
-    ('FINISHER', 'PAKAN', 40),
-
-    ('OVK', 'OVK', 10),
-    ('OBAT', 'OVK', 20),
-    ('VITAMIN', 'OVK', 30),
-    ('KIMIA', 'OVK', 40),
-
-    ('TELUR', 'TELUR', 10),
-
-    ('TELUR-UTUH', 'TELUR_GRADE', 10),
-    ('TELUR-PUTIH', 'TELUR_GRADE', 20),
-    ('TELUR-RETAK', 'TELUR_GRADE', 30),
-    ('TELUR-PECAH', 'TELUR_GRADE', 40),
-    ('TELUR-PAPACAL', 'TELUR_GRADE', 50),
-    ('TELUR-JUMBO', 'TELUR_GRADE', 60)
-ON CONFLICT (flag_name) DO UPDATE
-SET
-    flag_group_code = EXCLUDED.flag_group_code,
-    priority = EXCLUDED.priority,
-    updated_at = NOW();
-
-INSERT INTO fifo_stock_v2_traits(
-    source_table,
-    lane,
-    date_table,
-    date_join_left_col,
-    date_join_right_col,
-    date_column,
-    fallback_date_column,
-    sort_priority,
-    id_column
-)
-VALUES
-    ('purchase_items', 'STOCKABLE', NULL, NULL, NULL, 'received_date', NULL, 10, 'id'),
-
-    ('stock_transfer_details', 'STOCKABLE', 'stock_transfers', 'stock_transfer_id', 'id', 'transfer_date', NULL, 20, 'id'),
-    ('stock_transfer_details', 'USABLE', 'stock_transfers', 'stock_transfer_id', 'id', 'transfer_date', NULL, 20, 'id'),
-
-    ('laying_transfer_targets', 'STOCKABLE', 'laying_transfers', 'laying_transfer_id', 'id', 'transfer_date', NULL, 25, 'id'),
-    ('laying_transfer_sources', 'USABLE', 'laying_transfers', 'laying_transfer_id', 'id', 'transfer_date', NULL, 25, 'id'),
-
-    ('adjustment_stocks', 'STOCKABLE', NULL, NULL, NULL, 'created_at', NULL, 30, 'id'),
-    ('adjustment_stocks', 'USABLE', NULL, NULL, NULL, 'created_at', NULL, 30, 'id'),
-
-    ('recording_stocks', 'USABLE', 'recordings', 'recording_id', 'id', 'record_datetime', NULL, 35, 'id'),
-    ('recording_depletions', 'USABLE', 'recordings', 'recording_id', 'id', 'record_datetime', NULL, 35, 'id'),
-    ('recording_depletions', 'STOCKABLE', 'recordings', 'recording_id', 'id', 'record_datetime', NULL, 35, 'id'),
-
-    ('recording_eggs', 'STOCKABLE', 'recordings', 'recording_id', 'id', 'record_datetime', 'created_at', 40, 'id'),
-
-    ('marketing_delivery_products', 'USABLE', NULL, NULL, NULL, 'delivery_date', 'created_at', 45, 'id'),
-
-    ('project_chickins', 'USABLE', NULL, NULL, NULL, 'chick_in_date', 'created_at', 50, 'id'),
-    ('project_flock_populations', 'STOCKABLE', 'project_chickins', 'project_chickin_id', 'id', 'chick_in_date', 'created_at', 55, 'id')
-ON CONFLICT (source_table, lane) DO UPDATE
-SET
-    date_table = EXCLUDED.date_table,
-    date_join_left_col = EXCLUDED.date_join_left_col,
-    date_join_right_col = EXCLUDED.date_join_right_col,
-    date_column = EXCLUDED.date_column,
-    fallback_date_column = EXCLUDED.fallback_date_column,
-    sort_priority = EXCLUDED.sort_priority,
-    id_column = EXCLUDED.id_column,
-    is_active = TRUE;
-
-INSERT INTO fifo_stock_v2_route_rules(
-    flag_group_code,
-    lane,
-    function_code,
-    source_table,
-    source_id_column,
-    product_warehouse_col,
-    quantity_col,
-    used_quantity_col,
-    pending_quantity_col,
-    scope_sql,
-    legacy_type_key,
-    allow_pending_default,
-    is_active
-)
-VALUES
-    -- AYAM STOCKABLE
-    ('AYAM', 'STOCKABLE', 'ADJUSTMENT_IN', 'adjustment_stocks', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'ADJUSTMENT_IN', TRUE, TRUE),
-    ('AYAM', 'STOCKABLE', 'STOCK_TRANSFER_IN', 'stock_transfer_details', 'id', 'dest_product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'STOCK_TRANSFER_IN', TRUE, TRUE),
-    ('AYAM', 'STOCKABLE', 'PURCHASE_IN', 'purchase_items', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'PURCHASE_ITEMS', TRUE, TRUE),
-    ('AYAM', 'STOCKABLE', 'TRANSFER_TO_LAYING_IN', 'laying_transfer_targets', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'TRANSFERTOLAYING_IN', TRUE, TRUE),
-    ('AYAM', 'STOCKABLE', 'POPULATION_IN', 'project_flock_populations', 'id', 'product_warehouse_id', 'total_qty', 'total_used_qty', NULL, NULL, 'PROJECT_FLOCK_POPULATION', TRUE, TRUE),
-
-    -- AYAM USABLE
-    ('AYAM', 'USABLE', 'ADJUSTMENT_OUT', 'adjustment_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'ADJUSTMENT_OUT', TRUE, TRUE),
-    ('AYAM', 'USABLE', 'STOCK_TRANSFER_OUT', 'stock_transfer_details', 'id', 'source_product_warehouse_id', 'usage_qty', NULL, 'pending_qty', 'deleted_at IS NULL', 'STOCK_TRANSFER_OUT', TRUE, TRUE),
-    ('AYAM', 'USABLE', 'CHICKIN_OUT', 'project_chickins', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_usage_qty', 'deleted_at IS NULL', 'PROJECT_CHICKIN', TRUE, TRUE),
-    ('AYAM', 'USABLE', 'RECORDING_DEPLETION_OUT', 'recording_depletions', 'id', 'source_product_warehouse_id', 'qty', NULL, 'pending_qty', NULL, 'RECORDING_DEPLETION', TRUE, TRUE),
-    ('AYAM', 'USABLE', 'MARKETING_OUT', 'marketing_delivery_products', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'MARKETING_DELIVERY', TRUE, TRUE),
-    ('AYAM', 'USABLE', 'TRANSFER_TO_LAYING_OUT', 'laying_transfer_sources', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_usage_qty', 'deleted_at IS NULL', 'TRANSFERTOLAYING_OUT', TRUE, TRUE),
-
-    -- AFKIR/CULLING/MATI STOCKABLE
-    ('AFKIR_CULLING_MATI', 'STOCKABLE', 'ADJUSTMENT_IN', 'adjustment_stocks', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'ADJUSTMENT_IN', TRUE, TRUE),
-    ('AFKIR_CULLING_MATI', 'STOCKABLE', 'STOCK_TRANSFER_IN', 'stock_transfer_details', 'id', 'dest_product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'STOCK_TRANSFER_IN', TRUE, TRUE),
-    ('AFKIR_CULLING_MATI', 'STOCKABLE', 'RECORDING_DEPLETION_IN', 'recording_depletions', 'id', 'product_warehouse_id', 'qty', NULL, NULL, NULL, 'RECORDING_DEPLETION', TRUE, TRUE),
-
-    -- AFKIR/CULLING/MATI USABLE
-    ('AFKIR_CULLING_MATI', 'USABLE', 'ADJUSTMENT_OUT', 'adjustment_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'ADJUSTMENT_OUT', TRUE, TRUE),
-    ('AFKIR_CULLING_MATI', 'USABLE', 'STOCK_TRANSFER_OUT', 'stock_transfer_details', 'id', 'source_product_warehouse_id', 'usage_qty', NULL, 'pending_qty', 'deleted_at IS NULL', 'STOCK_TRANSFER_OUT', TRUE, TRUE),
-    ('AFKIR_CULLING_MATI', 'USABLE', 'MARKETING_OUT', 'marketing_delivery_products', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'MARKETING_DELIVERY', TRUE, TRUE),
-
-    -- PAKAN STOCKABLE
-    ('PAKAN', 'STOCKABLE', 'ADJUSTMENT_IN', 'adjustment_stocks', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'ADJUSTMENT_IN', TRUE, TRUE),
-    ('PAKAN', 'STOCKABLE', 'STOCK_TRANSFER_IN', 'stock_transfer_details', 'id', 'dest_product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'STOCK_TRANSFER_IN', TRUE, TRUE),
-    ('PAKAN', 'STOCKABLE', 'PURCHASE_IN', 'purchase_items', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'PURCHASE_ITEMS', TRUE, TRUE),
-
-    -- PAKAN USABLE
-    ('PAKAN', 'USABLE', 'ADJUSTMENT_OUT', 'adjustment_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'ADJUSTMENT_OUT', TRUE, TRUE),
-    ('PAKAN', 'USABLE', 'STOCK_TRANSFER_OUT', 'stock_transfer_details', 'id', 'source_product_warehouse_id', 'usage_qty', NULL, 'pending_qty', 'deleted_at IS NULL', 'STOCK_TRANSFER_OUT', TRUE, TRUE),
-    ('PAKAN', 'USABLE', 'RECORDING_STOCK_OUT', 'recording_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'RECORDING_STOCK', TRUE, TRUE),
-    ('PAKAN', 'USABLE', 'MARKETING_OUT', 'marketing_delivery_products', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'MARKETING_DELIVERY', TRUE, TRUE),
-
-    -- OVK STOCKABLE
-    ('OVK', 'STOCKABLE', 'ADJUSTMENT_IN', 'adjustment_stocks', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'ADJUSTMENT_IN', TRUE, TRUE),
-    ('OVK', 'STOCKABLE', 'STOCK_TRANSFER_IN', 'stock_transfer_details', 'id', 'dest_product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'STOCK_TRANSFER_IN', TRUE, TRUE),
-    ('OVK', 'STOCKABLE', 'PURCHASE_IN', 'purchase_items', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'PURCHASE_ITEMS', TRUE, TRUE),
-
-    -- OVK USABLE
-    ('OVK', 'USABLE', 'ADJUSTMENT_OUT', 'adjustment_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'ADJUSTMENT_OUT', TRUE, TRUE),
-    ('OVK', 'USABLE', 'STOCK_TRANSFER_OUT', 'stock_transfer_details', 'id', 'source_product_warehouse_id', 'usage_qty', NULL, 'pending_qty', 'deleted_at IS NULL', 'STOCK_TRANSFER_OUT', TRUE, TRUE),
-    ('OVK', 'USABLE', 'RECORDING_STOCK_OUT', 'recording_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'RECORDING_STOCK', TRUE, TRUE),
-    ('OVK', 'USABLE', 'MARKETING_OUT', 'marketing_delivery_products', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'MARKETING_DELIVERY', TRUE, TRUE),
-
-    -- TELUR STOCKABLE
-    ('TELUR', 'STOCKABLE', 'ADJUSTMENT_IN', 'adjustment_stocks', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'ADJUSTMENT_IN', TRUE, TRUE),
-    ('TELUR', 'STOCKABLE', 'STOCK_TRANSFER_IN', 'stock_transfer_details', 'id', 'dest_product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'STOCK_TRANSFER_IN', TRUE, TRUE),
-    ('TELUR', 'STOCKABLE', 'RECORDING_EGG_IN', 'recording_eggs', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'RECORDING_EGG', TRUE, TRUE),
-
-    -- TELUR USABLE
-    ('TELUR', 'USABLE', 'ADJUSTMENT_OUT', 'adjustment_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'ADJUSTMENT_OUT', TRUE, TRUE),
-    ('TELUR', 'USABLE', 'STOCK_TRANSFER_OUT', 'stock_transfer_details', 'id', 'source_product_warehouse_id', 'usage_qty', NULL, 'pending_qty', 'deleted_at IS NULL', 'STOCK_TRANSFER_OUT', TRUE, TRUE),
-    ('TELUR', 'USABLE', 'MARKETING_OUT', 'marketing_delivery_products', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'MARKETING_DELIVERY', TRUE, TRUE),
-
-    -- TELUR_GRADE STOCKABLE
-    ('TELUR_GRADE', 'STOCKABLE', 'ADJUSTMENT_IN', 'adjustment_stocks', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'ADJUSTMENT_IN', TRUE, TRUE),
-    ('TELUR_GRADE', 'STOCKABLE', 'STOCK_TRANSFER_IN', 'stock_transfer_details', 'id', 'dest_product_warehouse_id', 'total_qty', 'total_used', NULL, 'deleted_at IS NULL', 'STOCK_TRANSFER_IN', TRUE, TRUE),
-    ('TELUR_GRADE', 'STOCKABLE', 'RECORDING_EGG_IN', 'recording_eggs', 'id', 'product_warehouse_id', 'total_qty', 'total_used', NULL, NULL, 'RECORDING_EGG', TRUE, TRUE),
-
-    -- TELUR_GRADE USABLE
-    ('TELUR_GRADE', 'USABLE', 'ADJUSTMENT_OUT', 'adjustment_stocks', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'ADJUSTMENT_OUT', TRUE, TRUE),
-    ('TELUR_GRADE', 'USABLE', 'STOCK_TRANSFER_OUT', 'stock_transfer_details', 'id', 'source_product_warehouse_id', 'usage_qty', NULL, 'pending_qty', 'deleted_at IS NULL', 'STOCK_TRANSFER_OUT', TRUE, TRUE),
-    ('TELUR_GRADE', 'USABLE', 'MARKETING_OUT', 'marketing_delivery_products', 'id', 'product_warehouse_id', 'usage_qty', NULL, 'pending_qty', NULL, 'MARKETING_DELIVERY', TRUE, TRUE)
-ON CONFLICT (flag_group_code, lane, function_code, source_table) DO UPDATE
-SET
-    source_id_column = EXCLUDED.source_id_column,
-    product_warehouse_col = EXCLUDED.product_warehouse_col,
-    quantity_col = EXCLUDED.quantity_col,
-    used_quantity_col = EXCLUDED.used_quantity_col,
-    pending_quantity_col = EXCLUDED.pending_quantity_col,
-    scope_sql = EXCLUDED.scope_sql,
-    legacy_type_key = EXCLUDED.legacy_type_key,
-    allow_pending_default = EXCLUDED.allow_pending_default,
-    is_active = EXCLUDED.is_active,
-    updated_at = NOW();
-
-INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active)
-SELECT NULL, NULL, 'USABLE', TRUE, 999, 'fifo_v2_default_allow', TRUE
-WHERE NOT EXISTS (
-    SELECT 1 FROM fifo_stock_v2_overconsume_rules
-    WHERE flag_group_code IS NULL
-      AND function_code IS NULL
-      AND lane = 'USABLE'
-      AND reason = 'fifo_v2_default_allow'
-);
-
-INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active)
-SELECT 'AYAM', 'RECORDING_DEPLETION_OUT', 'USABLE', FALSE, 10, 'fifo_v2_exception_ayam_depletion_block', TRUE
-WHERE NOT EXISTS (
-    SELECT 1 FROM fifo_stock_v2_overconsume_rules
-    WHERE flag_group_code = 'AYAM'
-      AND function_code = 'RECORDING_DEPLETION_OUT'
-      AND lane = 'USABLE'
-      AND reason = 'fifo_v2_exception_ayam_depletion_block'
-);
-
-INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active)
-SELECT NULL, 'MARKETING_OUT', 'USABLE', FALSE, 20, 'fifo_v2_exception_marketing_block', TRUE
-WHERE NOT EXISTS (
-    SELECT 1 FROM fifo_stock_v2_overconsume_rules
-    WHERE flag_group_code IS NULL
-      AND function_code = 'MARKETING_OUT'
-      AND lane = 'USABLE'
-      AND reason = 'fifo_v2_exception_marketing_block'
-);
-
-INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active)
-SELECT NULL, 'STOCK_TRANSFER_OUT', 'USABLE', FALSE, 30, 'fifo_v2_exception_transfer_block', TRUE
-WHERE NOT EXISTS (
-    SELECT 1 FROM fifo_stock_v2_overconsume_rules
-    WHERE flag_group_code IS NULL
-      AND function_code = 'STOCK_TRANSFER_OUT'
-      AND lane = 'USABLE'
-      AND reason = 'fifo_v2_exception_transfer_block'
-);
-
-INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active)
-SELECT NULL, 'ADJUSTMENT_OUT', 'USABLE', FALSE, 40, 'fifo_v2_exception_adjustment_block', TRUE
-WHERE NOT EXISTS (
-    SELECT 1 FROM fifo_stock_v2_overconsume_rules
-    WHERE flag_group_code IS NULL
-      AND function_code = 'ADJUSTMENT_OUT'
-      AND lane = 'USABLE'
-      AND reason = 'fifo_v2_exception_adjustment_block'
-);
-
-INSERT INTO fifo_stock_v2_overconsume_rules(flag_group_code, function_code, lane, allow_overconsume, priority, reason, is_active)
-SELECT NULL, 'TRANSFER_TO_LAYING_OUT', 'USABLE', FALSE, 50, 'fifo_v2_exception_transfer_laying_block', TRUE
-WHERE NOT EXISTS (
-    SELECT 1 FROM fifo_stock_v2_overconsume_rules
-    WHERE flag_group_code IS NULL
-      AND function_code = 'TRANSFER_TO_LAYING_OUT'
-      AND lane = 'USABLE'
-      AND reason = 'fifo_v2_exception_transfer_laying_block'
-);
-
-COMMIT;

internal/database/migrations/20260306090011_disable_chickin_fifo_consumption_after_core.down.sql

@@ -1,13 +0,0 @@
-BEGIN;
-
--- Restore CHICKIN route if rollback is required.
--- NOTE: released PROJECT_CHICKIN allocations are not restored by this down migration.
-UPDATE fifo_stock_v2_route_rules
-SET is_active = TRUE,
-    updated_at = NOW()
-WHERE flag_group_code = 'AYAM'
-  AND lane = 'USABLE'
-  AND function_code = 'CHICKIN_OUT'
-  AND source_table = 'project_chickins';
-
-COMMIT;

internal/database/migrations/20260306090011_disable_chickin_fifo_consumption_after_core.up.sql

@@ -1,151 +0,0 @@
-BEGIN;
-
--- Disable CHICKIN as FIFO USABLE so chick-in acts as business tagging/conversion,
--- not physical stock consumption.
-UPDATE fifo_stock_v2_route_rules
-SET is_active = FALSE,
-    updated_at = NOW()
-WHERE flag_group_code = 'AYAM'
-  AND lane = 'USABLE'
-  AND function_code = 'CHICKIN_OUT'
-  AND source_table = 'project_chickins'
-  AND is_active = TRUE;
-
--- Release existing active allocations created by PROJECT_CHICKIN
--- and return warehouse qty back.
-WITH released AS (
-    UPDATE stock_allocations
-    SET status = 'RELEASED',
-        released_at = COALESCE(released_at, NOW()),
-        updated_at = NOW(),
-        note = CASE
-            WHEN COALESCE(note, '') = '' THEN 'fifo_v2_chickin_conversion_release'
-            ELSE note || '; fifo_v2_chickin_conversion_release'
-        END
-    WHERE usable_type = 'PROJECT_CHICKIN'
-      AND status = 'ACTIVE'
-    RETURNING product_warehouse_id, qty
-),
-pw_delta AS (
-    SELECT product_warehouse_id, COALESCE(SUM(qty), 0) AS qty_delta
-    FROM released
-    GROUP BY product_warehouse_id
-)
-UPDATE product_warehouses pw
-SET qty = COALESCE(pw.qty, 0) + d.qty_delta
-FROM pw_delta d
-WHERE pw.id = d.product_warehouse_id;
-
--- Resync stockable total_used columns from remaining ACTIVE allocations.
-
--- purchase_items (PURCHASE_ITEMS)
-UPDATE purchase_items pi
-SET total_used = COALESCE(a.used, 0)
-FROM (
-    SELECT stockable_id, SUM(qty) AS used
-    FROM stock_allocations
-    WHERE status = 'ACTIVE'
-      AND stockable_type = 'PURCHASE_ITEMS'
-    GROUP BY stockable_id
-) a
-WHERE pi.id = a.stockable_id;
-
-UPDATE purchase_items pi
-SET total_used = 0
-WHERE NOT EXISTS (
-    SELECT 1
-    FROM stock_allocations sa
-    WHERE sa.status = 'ACTIVE'
-      AND sa.stockable_type = 'PURCHASE_ITEMS'
-      AND sa.stockable_id = pi.id
-);
-
--- stock_transfer_details (STOCK_TRANSFER_IN)
-UPDATE stock_transfer_details std
-SET total_used = COALESCE(a.used, 0)
-FROM (
-    SELECT stockable_id, SUM(qty) AS used
-    FROM stock_allocations
-    WHERE status = 'ACTIVE'
-      AND stockable_type = 'STOCK_TRANSFER_IN'
-    GROUP BY stockable_id
-) a
-WHERE std.id = a.stockable_id;
-
-UPDATE stock_transfer_details std
-SET total_used = 0
-WHERE NOT EXISTS (
-    SELECT 1
-    FROM stock_allocations sa
-    WHERE sa.status = 'ACTIVE'
-      AND sa.stockable_type = 'STOCK_TRANSFER_IN'
-      AND sa.stockable_id = std.id
-);
-
--- adjustment_stocks (ADJUSTMENT_IN)
-UPDATE adjustment_stocks ast
-SET total_used = COALESCE(a.used, 0)
-FROM (
-    SELECT stockable_id, SUM(qty) AS used
-    FROM stock_allocations
-    WHERE status = 'ACTIVE'
-      AND stockable_type = 'ADJUSTMENT_IN'
-    GROUP BY stockable_id
-) a
-WHERE ast.id = a.stockable_id;
-
-UPDATE adjustment_stocks ast
-SET total_used = 0
-WHERE NOT EXISTS (
-    SELECT 1
-    FROM stock_allocations sa
-    WHERE sa.status = 'ACTIVE'
-      AND sa.stockable_type = 'ADJUSTMENT_IN'
-      AND sa.stockable_id = ast.id
-);
-
--- laying_transfer_targets (TRANSFERTOLAYING_IN)
-UPDATE laying_transfer_targets ltt
-SET total_used = COALESCE(a.used, 0)
-FROM (
-    SELECT stockable_id, SUM(qty) AS used
-    FROM stock_allocations
-    WHERE status = 'ACTIVE'
-      AND stockable_type = 'TRANSFERTOLAYING_IN'
-    GROUP BY stockable_id
-) a
-WHERE ltt.id = a.stockable_id;
-
-UPDATE laying_transfer_targets ltt
-SET total_used = 0
-WHERE NOT EXISTS (
-    SELECT 1
-    FROM stock_allocations sa
-    WHERE sa.status = 'ACTIVE'
-      AND sa.stockable_type = 'TRANSFERTOLAYING_IN'
-      AND sa.stockable_id = ltt.id
-);
-
--- recording_eggs (RECORDING_EGG)
-UPDATE recording_eggs re
-SET total_used = COALESCE(a.used, 0)
-FROM (
-    SELECT stockable_id, SUM(qty) AS used
-    FROM stock_allocations
-    WHERE status = 'ACTIVE'
-      AND stockable_type = 'RECORDING_EGG'
-    GROUP BY stockable_id
-) a
-WHERE re.id = a.stockable_id;
-
-UPDATE recording_eggs re
-SET total_used = 0
-WHERE NOT EXISTS (
-    SELECT 1
-    FROM stock_allocations sa
-    WHERE sa.status = 'ACTIVE'
-      AND sa.stockable_type = 'RECORDING_EGG'
-      AND sa.stockable_id = re.id
-);
-
-COMMIT;