ci: align mr development production triggers

.gitlab-ci.yml

@@ -1,35 +1,142 @@
+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}
+
+  DOCKER_HOST: unix:///var/run/docker.sock
+  DOCKER_TLS_CERTDIR: ""
+  DOCKER_BUILDKIT: "1"
+
 workflow:
   rules:
-    # MR pipeline
+    # run untuk branch utama & MR
-    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
+    - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == "development"'
-      when: always
+    - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == "production"'
-
+    - 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:
+# =========================
-  # khusus MR (notif)
+# Helper: login ECR
-  - local: "ci/merge_request.yml"
+# =========================
-    rules:
+.ecr_login: &ecr_login |
-      - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
+  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
 
-  # khusus push ke branch env
+  PASS="$(docker run --rm $AWS_CLI_ENV_ARGS public.ecr.aws/aws-cli/aws-cli:latest \
-  - local: "ci/development.yml"
+    ecr get-login-password --region "$AWS_REGION" || true)"
-    rules:
+  if [ -z "$PASS" ]; then
-      - if: '$CI_COMMIT_BRANCH == "development"'
+    echo "ERROR: Failed to get ECR login password."
+    exit 1
+  fi
+  echo "$PASS" | docker login --username AWS --password-stdin "$ECR_REGISTRY"
 
-  - local: "ci/staging.yml"
+# =========================
+# MR
+# =========================
+build_mr:
+  stage: build
+  image: public.ecr.aws/docker/library/docker:27
+  tags: [self-hosted-dev]
   rules:
-      - if: '$CI_COMMIT_BRANCH == "staging"'
+    - if: '$CI_PIPELINE_SOURCE == "merge_request_event" && $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "production"'
+  variables:
+    IMAGE_TAG: "prod-mr-${CI_COMMIT_SHORT_SHA}"
+  before_script:
+    - set -eu
+    - docker version
+    - docker info
+    - *ecr_login
+  script: |
+    set -eu
+    echo "Build (MR) : $ECR_REPOSITORY:$IMAGE_TAG"
+    docker build -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)
+# =========================
+build_push_dev:
+  stage: build
+  image: public.ecr.aws/docker/library/docker:27
+  tags: [self-hosted-dev]
   rules:
-      - if: '$CI_COMMIT_BRANCH == "production"'
+    - 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
+    echo "Build & push (dev): $ECR_REPOSITORY:$IMAGE_TAG"
+    docker build -f Dockerfile -t "$ECR_REPOSITORY:$IMAGE_TAG" .
+    docker push "$ECR_REPOSITORY:$IMAGE_TAG"
+
+# =========================
+# 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
+    echo "Build & push (prod): $ECR_REPOSITORY:$IMAGE_TAG"
+    docker build -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"

README.md

@@ -111,3 +111,4 @@ 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

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/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,649 +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/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
-}

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

@@ -51,8 +51,8 @@ func (r *HppRepositoryImpl) GetDocCost(ctx context.Context, projectFlockKandangI
 	var total float64
 	err := r.db.WithContext(ctx).
 		Table("project_chickins AS pc").
-		Select("COALESCE(SUM(sa.qty * COALESCE(pi.price, 0)), 0)").
+		Select("COALESCE(SUM(pc.usage_qty * COALESCE(pi.price, 0)), 0)").
-		Joins("JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = pc.id AND sa.stockable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?", fifo.UsableKeyProjectChickin.String(), fifo.StockableKeyPurchaseItems.String(), entity.StockAllocationStatusActive, entity.StockAllocationPurposeTraceChickin).
+		Joins("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()).
 		Joins("JOIN purchase_items AS pi ON pi.id = sa.stockable_id").
 		Where("pc.project_flock_kandang_id IN (?)", projectFlockKandangIDs).
 		Scan(&total).Error
@@ -103,11 +103,11 @@ func (r *HppRepositoryImpl) GetFeedUsageCost(ctx context.Context, projectFlockKa
 	var total float64
 	err := r.db.WithContext(ctx).
 		Table("recordings AS r").
-		Select("COALESCE(SUM(sa.qty * COALESCE(pi.price, 0)), 0)").
+		Select("COALESCE(SUM(rs.usage_qty * COALESCE(pi.price, 0)), 0)").
 		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("JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = rs.id AND sa.stockable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?", fifo.UsableKeyRecordingStock.String(), fifo.StockableKeyPurchaseItems.String(), entity.StockAllocationStatusActive, entity.StockAllocationPurposeConsume).
+		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()).
 		Joins("JOIN purchase_items AS pi ON pi.id = sa.stockable_id").
 		Where("r.project_flock_kandangs_id IN (?)", projectFlockKandangIDs).
 		Where("r.record_datetime <= ?", *date).
@@ -136,14 +136,15 @@ func (r *HppRepositoryImpl) GetOvkUsageCost(ctx context.Context, projectFlockKan
 	var total float64
 	err := r.db.WithContext(ctx).
 		Table("recordings AS r").
-		Select("COALESCE(SUM(sa.qty * COALESCE(pi.price, 0)), 0)").
+		Select("COALESCE(SUM(rs.usage_qty * COALESCE(pi.price, 0)), 0)").
 		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 stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = rs.id AND sa.stockable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?", fifo.UsableKeyRecordingStock.String(), fifo.StockableKeyPurchaseItems.String(), entity.StockAllocationStatusActive, entity.StockAllocationPurposeConsume).
+		Joins("JOIN flags AS f ON f.flagable_id = pw.product_id AND f.flagable_type = ?", entity.FlagableTypeProduct).
+		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()).
 		Joins("JOIN purchase_items AS pi ON pi.id = sa.stockable_id").
 		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).
+		Where("f.name IN ?", flags).
 		Scan(&total).Error
 	if err != nil {
 		return 0, err
@@ -175,15 +176,15 @@ func (r *HppRepositoryImpl) GetPulletCost(ctx context.Context, projectFlockKanda
 	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(tpi.price, 0)
 				ELSE 0
 			END), 0)`,
 			stockablePurchase, stockableTransferIn).
-		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("JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = pc.id", usableProjectChickin).
 		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").
 		Where("pc.project_flock_kandang_id = ?", projectFlockKandangId).
 		Scan(&total).Error
@@ -245,11 +246,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).

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/service/common.fifo.service.go

@@ -26,7 +26,6 @@ type FifoService interface {
 	Consume(ctx context.Context, req StockConsumeRequest) (*StockConsumeResult, error)
 	ReleaseUsage(ctx context.Context, req StockReleaseRequest) error
 	AdjustStockableQuantity(ctx context.Context, req StockAdjustRequest) error
-	ResolvePending(ctx context.Context, req PendingResolveRequest) ([]PendingResolution, error)
 }
 
 type fifoService struct {
@@ -112,11 +111,6 @@ type PendingResolution struct {
 	Quantity  float64
 }
 
-type PendingResolveRequest struct {
-	ProductWarehouseID uint
-	Tx                 *gorm.DB
-}
-
 type StockReplenishResult struct {
 	AddedQuantity    float64
 	PendingResolved  []PendingResolution
@@ -233,23 +227,6 @@ func (s *fifoService) Replenish(ctx context.Context, req StockReplenishRequest)
 	return result, nil
 }
 
-func (s *fifoService) ResolvePending(ctx context.Context, req PendingResolveRequest) ([]PendingResolution, error) {
-	if req.ProductWarehouseID == 0 {
-		return nil, errors.New("product warehouse id is required")
-	}
-
-	var resolved []PendingResolution
-	err := s.withTransaction(ctx, req.Tx, func(tx *gorm.DB) error {
-		var err error
-		resolved, err = s.resolvePendingForWarehouse(ctx, tx, req.ProductWarehouseID)
-		return err
-	})
-	if err != nil {
-		return nil, err
-	}
-	return resolved, nil
-}
-
 func (s *fifoService) Consume(ctx context.Context, req StockConsumeRequest) (*StockConsumeResult, error) {
 	if req.UsableID == 0 || strings.TrimSpace(req.UsableKey.String()) == "" {
 		return nil, errors.New("usable key and id are required")
@@ -528,7 +505,6 @@ func (s *fifoService) allocateFromStock(
 			UsableType:         usableKey.String(),
 			UsableId:           usableID,
 			Qty:                portion,
-			AllocationPurpose:  entities.StockAllocationPurposeConsume,
 			Status:             entities.StockAllocationStatusActive,
 		})
 
@@ -873,8 +849,8 @@ func (s *fifoService) fetchPendingCandidates(ctx context.Context, tx *gorm.DB, p
 		if cfg.Columns.CreatedAt == cfg.Columns.ID {
 			var rows []struct {
 				ID        uint
-				Pending   float64 `gorm:"column:pending_qty"`
+				Pending   float64
-				CreatedAt int64   `gorm:"column:created_at"`
+				CreatedAt int64
 			}
 
 			query := tx.Table(cfg.Table).
@@ -894,6 +870,7 @@ func (s *fifoService) fetchPendingCandidates(ctx context.Context, tx *gorm.DB, p
 			if err := query.Find(&rows).Error; err != nil {
 				return nil, err
 			}
+
 			for _, row := range rows {
 				if row.Pending <= 0 {
 					continue
@@ -909,8 +886,8 @@ func (s *fifoService) fetchPendingCandidates(ctx context.Context, tx *gorm.DB, p
 		} else {
 			var rows []struct {
 				ID        uint
-				Pending   float64   `gorm:"column:pending_qty"`
+				Pending   float64
-				CreatedAt time.Time `gorm:"column:created_at"`
+				CreatedAt time.Time
 			}
 
 			query := tx.Table(cfg.Table).

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/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,749 +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 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 (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...)
-			}
-			minDesired := rollbackRes.ReleasedQty + usableRow.PendingQuantity
-			if desiredQty < minDesired {
-				desiredQty = minDesired
-			}
-
-			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
-	err := 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 <> ''").
-		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
-	}
-
-	var rules []routeRule
-	err = tx.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules").
-		Where("is_active = TRUE").
-		Where("lane = ?", string(LaneUsable)).
-		Where("legacy_type_key = ?", req.Usable.LegacyTypeKey).
-		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 {
-		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/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/database/migrations/20260216125014_add_depletions_recording_total_used.down.sql

@@ -1,12 +0,0 @@
-BEGIN;
-
-ALTER TABLE recording_depletions
-    DROP CONSTRAINT IF EXISTS chk_recording_depletions_pending_zero;
-
-ALTER TABLE recording_depletions
-    DROP COLUMN IF EXISTS total_used_qty;
-
-ALTER TABLE recording_depletions
-    DROP COLUMN IF EXISTS usage_qty;
-
-COMMIT;

internal/database/migrations/20260216125014_add_depletions_recording_total_used.up.sql

@@ -1,15 +0,0 @@
-BEGIN;
-
-ALTER TABLE recording_depletions
-    ADD COLUMN IF NOT EXISTS total_used_qty numeric(15, 3) NOT NULL DEFAULT 0,
-    ADD COLUMN IF NOT EXISTS usage_qty numeric(15, 3) NOT NULL DEFAULT 0;
-
-UPDATE recording_depletions
-SET pending_qty = 0
-WHERE pending_qty IS NULL OR pending_qty <> 0;
-
-ALTER TABLE recording_depletions
-    ADD CONSTRAINT chk_recording_depletions_pending_zero
-    CHECK (pending_qty = 0);
-
-COMMIT;

internal/database/migrations/20260218090000_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/20260218090000_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/20260218090010_seed_fifo_stock_v2_config.down.sql

@@ -1,36 +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'
-);
-
-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/20260218090010_seed_fifo_stock_v2_config.up.sql

@@ -1,248 +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')
-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 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/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,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/20260228143207_disable_chickin_fifo_consumption.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;

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/seed/seeder.go

@@ -74,7 +74,7 @@ func seedUsers(tx *gorm.DB) (map[string]uint, error) {
 }
 
 func seedUoms(tx *gorm.DB, createdBy uint) (map[string]uint, error) {
-	names := []string{"Kilogram", "Gram", "Liter", "Unit", "Ekor", "Butir"}
+	names := []string{"Kilogram", "Gram", "Liter", "Unit", "Ekor"}
 	result := make(map[string]uint, len(names))
 
 	for _, name := range names {
@@ -235,7 +235,7 @@ func seedProducts(tx *gorm.DB, createdBy uint, uoms map[string]uint, categories
 			Name:      "Telur Utuh",
 			Brand:     "-",
 			Sku:       "4",
-			Uom:       "Butir",
+			Uom:       "Gram",
 			Category:  "Telur",
 			Price:     1,
 			Flags:     []utils.FlagType{utils.FlagTelurUtuh},
@@ -245,7 +245,7 @@ func seedProducts(tx *gorm.DB, createdBy uint, uoms map[string]uint, categories
 			Name:      "Telur Pecah",
 			Brand:     "-",
 			Sku:       "5",
-			Uom:       "Butir",
+			Uom:       "Gram",
 			Category:  "Telur",
 			Price:     1,
 			Flags:     []utils.FlagType{utils.FlagTelurPecah},
@@ -255,7 +255,7 @@ func seedProducts(tx *gorm.DB, createdBy uint, uoms map[string]uint, categories
 			Name:      "Telur Putih",
 			Brand:     "-",
 			Sku:       "6",
-			Uom:       "Butir",
+			Uom:       "Gram",
 			Category:  "Telur",
 			Price:     1,
 			Flags:     []utils.FlagType{utils.FlagTelurPutih},
@@ -265,32 +265,12 @@ func seedProducts(tx *gorm.DB, createdBy uint, uoms map[string]uint, categories
 			Name:      "Telur Retak",
 			Brand:     "-",
 			Sku:       "7",
-			Uom:       "Butir",
+			Uom:       "Gram",
 			Category:  "Telur",
 			Price:     1,
 			Flags:     []utils.FlagType{utils.FlagTelurRetak},
 			IsVisible: false,
 		},
-		{
-			Name:      "Telur Papacal",
-			Brand:     "-",
-			Sku:       "8",
-			Uom:       "Butir",
-			Category:  "Telur",
-			Price:     1,
-			Flags:     []utils.FlagType{utils.FlagTelur},
-			IsVisible: false,
-		},
-		{
-			Name:      "Telur Jumbo",
-			Brand:     "-",
-			Sku:       "9",
-			Uom:       "Butir",
-			Category:  "Telur",
-			Price:     1,
-			Flags:     []utils.FlagType{utils.FlagTelur},
-			IsVisible: false,
-		},
 	}
 
 	for _, seed := range seeds {

internal/entities/adjustment_stock.go

@@ -5,14 +5,10 @@ import "time"
 type AdjustmentStock struct {
 	Id                 uint      `gorm:"primaryKey"`
 	ProductWarehouseId uint      `gorm:"column:product_warehouse_id;not null"`
-	TransactionType    string    `gorm:"column:transaction_type;type:varchar(100);not null;default:LEGACY"`
-	FunctionCode       string    `gorm:"column:function_code;type:varchar(64)"`
 	TotalQty           float64   `gorm:"column:total_qty;default:0"`
 	TotalUsed          float64   `gorm:"column:total_used;default:0"`
 	UsageQty           float64   `gorm:"column:usage_qty;default:0"`
 	PendingQty         float64   `gorm:"column:pending_qty;default:0"`
-	Price              float64   `gorm:"column:price;type:numeric(15,3);default:0"`
-	GrandTotal         float64   `gorm:"column:grand_total;type:numeric(15,3);default:0"`
 	CreatedAt          time.Time `gorm:"column:created_at;autoCreateTime"`
 	UpdatedAt          time.Time `gorm:"column:updated_at;autoUpdateTime"`
 	AdjNumber          string    `gorm:"column:adj_number;uniqueIndex;not null"`

internal/entities/purchase_item.go

@@ -21,7 +21,6 @@ type PurchaseItem struct {
 	Price                 float64 `gorm:"type:numeric(15,3);default:0"`
 	TotalPrice            float64 `gorm:"type:numeric(15,3);default:0"`
 	ExpenseNonstockId     *uint64
-	HasChickin            bool `gorm:"-" json:"-"`
 
 	// Relations
 	ExpenseNonstock  *ExpenseNonstock  `gorm:"foreignKey:ExpenseNonstockId;references:Id"`

internal/entities/recording_depletion.go

@@ -6,7 +6,6 @@ type RecordingDepletion struct {
 	ProductWarehouseId       uint    `gorm:"column:product_warehouse_id;not null"`
 	SourceProductWarehouseId *uint   `gorm:"column:source_product_warehouse_id"`
 	Qty                      float64 `gorm:"column:qty;not null"`
-	UsageQty                 float64 `gorm:"column:usage_qty"`
 	PendingQty               float64 `gorm:"column:pending_qty"`
 
 	Recording        Recording        `gorm:"foreignKey:RecordingId;references:Id"`

internal/entities/stock_allocation.go

@@ -10,9 +10,6 @@ const (
 	StockAllocationStatusPending  = "PENDING"
 	StockAllocationStatusActive   = "ACTIVE"
 	StockAllocationStatusReleased = "RELEASED"
-
-	StockAllocationPurposeConsume      = "CONSUME"
-	StockAllocationPurposeTraceChickin = "TRACE_CHICKIN"
 )
 
 // StockAllocation links a usable record (consumption) with an incoming stock record.
@@ -25,8 +22,7 @@ type StockAllocation struct {
 	UsableType         string         `gorm:"size:100;not null;index:stock_allocations_usage_lookup,priority:1"`
 	UsableId           uint           `gorm:"not null;index:stock_allocations_usage_lookup,priority:2"`
 	Qty                float64        `gorm:"type:numeric(15,3);not null"`
-	AllocationPurpose  string         `gorm:"size:32;not null;default:CONSUME;index:stock_allocations_purpose_status,priority:1"`
+	Status             string         `gorm:"size:20;not null;default:ACTIVE"`
-	Status             string         `gorm:"size:20;not null;default:ACTIVE;index:stock_allocations_purpose_status,priority:2"`
 	Note               *string        `gorm:"type:text"`
 	CreatedAt          time.Time      `gorm:"autoCreateTime"`
 	UpdatedAt          time.Time      `gorm:"autoUpdateTime"`

internal/modules/closings/controllers/closing.controller.go

@@ -347,12 +347,12 @@ func (u *ClosingController) GetSapronakByProject(c *fiber.Ctx) error {
 		return fiber.NewError(fiber.StatusBadRequest, "Invalid project_flock_id")
 	}
 
-	result, productFlags, err := u.SapronakService.GetSapronakByProject(c, uint(projectID), flag)
+	result, err := u.SapronakService.GetSapronakByProject(c, uint(projectID), flag)
 	if err != nil {
 		return err
 	}
 
-	payload := dto.ToSapronakProjectAggregatedFromReports(result, flag, productFlags)
+	payload := dto.ToSapronakProjectAggregatedFromReports(result, flag)
 
 	return c.Status(fiber.StatusOK).
 		JSON(response.Success{
@@ -377,12 +377,12 @@ func (u *ClosingController) GetSapronakByKandang(c *fiber.Ctx) error {
 		return fiber.NewError(fiber.StatusBadRequest, "Invalid project_flock_kandang_id")
 	}
 
-	result, productFlags, err := u.SapronakService.GetSapronakByKandang(c, uint(projectID), uint(pfkID), flag)
+	result, err := u.SapronakService.GetSapronakByKandang(c, uint(projectID), uint(pfkID), flag)
 	if err != nil {
 		return err
 	}
 
-	payload := dto.ToSapronakProjectAggregatedFromReport(result, flag, productFlags)
+	payload := dto.ToSapronakProjectAggregatedFromReport(result, flag)
 
 	return c.Status(fiber.StatusOK).
 		JSON(response.Success{

internal/modules/closings/dto/closingSapronak.dto.go

@@ -1,7 +1,6 @@
 package dto
 
 import (
-	"sort"
 	"strings"
 	"time"
 )
@@ -65,7 +64,7 @@ type SapronakCategoryRowDTO struct {
 	QtyOut          float64 `json:"qty_out"`
 	QtyUsed         float64 `json:"qty_used"`
 	Description     string  `json:"description"`
-	ProductCategory []string `json:"product_category"`
+	ProductCategory string  `json:"product_category"`
 	UnitPrice       float64 `json:"unit_price"`
 	TotalAmount     float64 `json:"total_amount"`
 	Notes           string  `json:"notes"`
@@ -128,7 +127,7 @@ type UomSummaryDTO struct {
 
 // === Mapper Functions for Aggregated Sapronak Response ===
 
-func ToSapronakProjectAggregatedFromReports(reports []SapronakReportDTO, flag string, productFlags map[uint][]string) SapronakProjectAggregatedDTO {
+func ToSapronakProjectAggregatedFromReports(reports []SapronakReportDTO, flag string) SapronakProjectAggregatedDTO {
 	result := SapronakProjectAggregatedDTO{}
 
 	if len(reports) == 0 {
@@ -136,10 +135,10 @@ func ToSapronakProjectAggregatedFromReports(reports []SapronakReportDTO, flag st
 	}
 
 	rep := reports[0]
-	return ToSapronakProjectAggregatedFromReport(&rep, flag, productFlags)
+	return ToSapronakProjectAggregatedFromReport(&rep, flag)
 }
 
-func ToSapronakProjectAggregatedFromReport(report *SapronakReportDTO, flag string, productFlags map[uint][]string) SapronakProjectAggregatedDTO {
+func ToSapronakProjectAggregatedFromReport(report *SapronakReportDTO, flag string) SapronakProjectAggregatedDTO {
 	result := SapronakProjectAggregatedDTO{}
 
 	if report == nil {
@@ -176,53 +175,6 @@ func ToSapronakProjectAggregatedFromReport(report *SapronakReportDTO, flag strin
 		return t.Format("02-Jan-2006")
 	}
 
-	flagOrder := map[string]int{
-		"DOC":    0,
-		"PAKAN":  0,
-		"OVK":    0,
-		"PULLET": 0,
-	}
-
-	buildFlagList := func(productID uint, fallback string) []string {
-		rawFlags := productFlags[productID]
-		if len(rawFlags) == 0 {
-			if fallback == "" {
-				return []string{}
-			}
-			return []string{fallback}
-		}
-		seen := make(map[string]struct{}, len(rawFlags))
-		ordered := make([]string, 0, len(rawFlags))
-		for _, f := range rawFlags {
-			flagName := strings.ToUpper(strings.TrimSpace(f))
-			if flagName == "" {
-				continue
-			}
-			if _, ok := seen[flagName]; ok {
-				continue
-			}
-			seen[flagName] = struct{}{}
-			ordered = append(ordered, flagName)
-		}
-		sort.SliceStable(ordered, func(i, j int) bool {
-			li := ordered[i]
-			lj := ordered[j]
-			ri, iok := flagOrder[li]
-			rj, jok := flagOrder[lj]
-			if iok != jok {
-				if iok {
-					return true
-				}
-				return false
-			}
-			if iok && jok && ri != rj {
-				return ri < rj
-			}
-			return li < lj
-		})
-		return ordered
-	}
-
 	for _, group := range report.Groups {
 		flagKey := normalizeFlag(group.Flag)
 		ptr := byFlag[flagKey]
@@ -254,7 +206,7 @@ func ToSapronakProjectAggregatedFromReport(report *SapronakReportDTO, flag strin
 				Date:            formatDate(item.Tanggal),
 				ReferenceNumber: item.NoReferensi,
 				Description:     item.ProductName,
-				ProductCategory: buildFlagList(item.ProductID, flagKey),
+				ProductCategory: item.ProductName,
 				UnitPrice:       item.Harga,
 				Notes:           "-",
 			}

internal/modules/closings/repositories/closing.repository.go

@@ -991,8 +991,8 @@ func (r *ClosingRepositoryImpl) FetchSapronakUsageAllocatedDetails(ctx context.C
 	query := r.withCtx(ctx).
 		Table("stock_allocations AS sa").
 		Select(`
-			p_resolve.id AS product_id,
+			pw.product_id AS product_id,
-			p_resolve.name AS product_name,
+			p.name AS product_name,
 			f.name AS flag,
 			COALESCE(
 				pi.received_date,
@@ -1013,9 +1013,10 @@ func (r *ClosingRepositoryImpl) FetchSapronakUsageAllocatedDetails(ctx context.C
 			) AS reference,
 			0 AS qty_in,
 			COALESCE(SUM(sa.qty), 0) AS qty_out,
-			COALESCE(pi.price, p_resolve.product_price, 0) AS price
+			COALESCE(pi.price, p.product_price, 0) AS price
 		`).
 		Joins("JOIN product_warehouses pw ON pw.id = sa.product_warehouse_id").
+		Joins("JOIN products p ON p.id = pw.product_id").
 		Joins("LEFT JOIN recording_stocks rs ON rs.id = sa.usable_id AND sa.usable_type = ?", fifo.UsableKeyRecordingStock.String()).
 		Joins("LEFT JOIN recordings r ON r.id = rs.recording_id").
 		Joins("LEFT JOIN project_chickins pc_used ON pc_used.id = sa.usable_id AND sa.usable_type = ?", fifo.UsableKeyProjectChickin.String()).
@@ -1025,13 +1026,10 @@ func (r *ClosingRepositoryImpl) FetchSapronakUsageAllocatedDetails(ctx context.C
 		Joins("LEFT JOIN stock_transfers st ON st.id = std.stock_transfer_id").
 		Joins("LEFT JOIN laying_transfer_targets ltt ON ltt.id = sa.stockable_id AND sa.stockable_type = ?", fifo.StockableKeyTransferToLayingIn.String()).
 		Joins("LEFT JOIN laying_transfers lt ON lt.id = ltt.laying_transfer_id").
-		Joins("LEFT JOIN product_warehouses pw_ltt ON pw_ltt.id = ltt.product_warehouse_id").
 		Joins("LEFT JOIN adjustment_stocks ast ON ast.id = sa.stockable_id AND sa.stockable_type = ?", fifo.StockableKeyAdjustmentIn.String()).
 		Joins("LEFT JOIN project_flock_populations pfp ON pfp.id = sa.stockable_id AND sa.stockable_type = ?", fifo.StockableKeyProjectFlockPopulation.String()).
 		Joins("LEFT JOIN project_chickins pc ON pc.id = pfp.project_chickin_id").
-		Joins("LEFT JOIN products p_resolve ON p_resolve.id = COALESCE(pi.product_id, pw_ltt.product_id, pw.product_id)").
 		Where("sa.status = ?", entity.StockAllocationStatusActive).
-		Where("sa.allocation_purpose = ?", entity.StockAllocationPurposeConsume).
 		Where("sa.stockable_type <> ?", fifo.StockableKeyProjectFlockPopulation.String()).
 		Where("f.name IN ?", sapronakFlagsAll).
 		Where(`
@@ -1042,12 +1040,12 @@ func (r *ClosingRepositoryImpl) FetchSapronakUsageAllocatedDetails(ctx context.C
 			fifo.UsableKeyRecordingStock.String(), projectFlockKandangID,
 			fifo.UsableKeyProjectChickin.String(), projectFlockKandangID,
 		)
-	query = r.joinSapronakProductFlag(query, "p_resolve").
+	query = r.joinSapronakProductFlag(query, "p").
 		Group(`
-			p_resolve.id, p_resolve.name, f.name,
+			pw.product_id, p.name, f.name,
 			pi.received_date, st.transfer_date, lt.transfer_date, ast.created_at, pc.chick_in_date, r.record_datetime,
 			po.po_number, st.movement_number, lt.transfer_number, ast.id, pc.id, r.id,
-			pi.price, p_resolve.product_price
+			pi.price, p.product_price
 		`)
 
 	return scanAndGroupDetails(query)
@@ -1237,7 +1235,6 @@ func (r *ClosingRepositoryImpl) FetchSapronakAdjustments(ctx context.Context, ka
 		Joins("JOIN warehouses w ON w.id = pw.warehouse_id").
 		Joins("JOIN products p ON p.id = pw.product_id").
 		Where("sa.status = ?", entity.StockAllocationStatusActive).
-		Where("sa.allocation_purpose = ?", entity.StockAllocationPurposeConsume).
 		Where("w.kandang_id = ?", kandangID).
 		Where("f.name IN ?", sapronakFlagsAll).
 		Where("f.name NOT IN ?", sapronakFlags(utils.FlagDOC, utils.FlagPullet)).
@@ -1329,7 +1326,6 @@ func (r *ClosingRepositoryImpl) FetchSapronakTransfers(ctx context.Context, kand
 		Joins("LEFT JOIN warehouses w_dest ON w_dest.id = pw_dest.warehouse_id").
 		Joins("JOIN products p ON p.id = std.product_id").
 		Where("sa.status = ?", entity.StockAllocationStatusActive).
-		Where("sa.allocation_purpose = ?", entity.StockAllocationPurposeConsume).
 		Where("w.kandang_id = ?", kandangID).
 		Where("(w_dest.kandang_id IS NULL OR w_dest.kandang_id <> w.kandang_id)").
 		Where("f.name IN ?", sapronakFlagsAll).
@@ -1361,7 +1357,6 @@ func (r *ClosingRepositoryImpl) FetchSapronakTransfers(ctx context.Context, kand
 		Joins("JOIN warehouses w ON w.id = pw.warehouse_id").
 		Joins("JOIN products p ON p.id = pw.product_id").
 		Where("sa.status = ?", entity.StockAllocationStatusActive).
-		Where("sa.allocation_purpose = ?", entity.StockAllocationPurposeConsume).
 		Where("w.kandang_id = ?", kandangID).
 		Where("(w_dest.kandang_id IS NULL OR w_dest.kandang_id <> w.kandang_id)").
 		Where("f.name IN ?", sapronakFlagsAll).
@@ -1397,7 +1392,6 @@ func (r *ClosingRepositoryImpl) FetchSapronakSales(ctx context.Context, projectF
 		Joins("JOIN product_warehouses pw ON pw.id = sa.product_warehouse_id").
 		Joins("JOIN products p ON p.id = pw.product_id").
 		Where("sa.status = ?", entity.StockAllocationStatusActive).
-		Where("sa.allocation_purpose = ?", entity.StockAllocationPurposeConsume).
 		Where("pw.project_flock_kandang_id = ?", projectFlockKandangID).
 		Where("f.name IN ?", sapronakFlagsAll).
 		Group("mdp.id, pw.product_id, p.name, f.name, mdp.delivery_date, mdp.created_at, m.so_number, mdp.unit_price, mp.unit_price")
@@ -1424,10 +1418,9 @@ func (r *ClosingRepositoryImpl) FetchSapronakSales(ctx context.Context, projectF
 		Joins("JOIN marketings m ON m.id = mp.marketing_id").
 		Joins("JOIN product_warehouses pw ON pw.id = mp.product_warehouse_id").
 		Joins("JOIN products p ON p.id = pw.product_id").
-		Joins("LEFT JOIN stock_allocations sa ON sa.usable_id = mdp.id AND sa.usable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?",
+		Joins("LEFT JOIN stock_allocations sa ON sa.usable_id = mdp.id AND sa.usable_type = ? AND sa.status = ?",
 			fifo.UsableKeyMarketingDelivery.String(),
 			entity.StockAllocationStatusActive,
-			entity.StockAllocationPurposeConsume,
 		).
 		Where("mdp.usage_qty > 0").
 		Where("sa.id IS NULL").
@@ -1487,7 +1480,6 @@ func (r *ClosingRepositoryImpl) FetchSapronakSalesAllocatedDetails(ctx context.C
 		Joins("LEFT JOIN laying_transfers lt ON lt.id = ltt.laying_transfer_id").
 		Joins("LEFT JOIN adjustment_stocks ast ON ast.id = sa.stockable_id AND sa.stockable_type = ?", fifo.StockableKeyAdjustmentIn.String()).
 		Where("sa.status = ?", entity.StockAllocationStatusActive).
-		Where("sa.allocation_purpose = ?", entity.StockAllocationPurposeConsume).
 		Where("sa.stockable_type <> ?", fifo.StockableKeyProjectFlockPopulation.String()).
 		Where("pw.project_flock_kandang_id = ?", projectFlockKandangID).
 		Where("f.name IN ?", sapronakFlagsAll).

internal/modules/closings/services/closingKeuangan.service.go

@@ -294,9 +294,6 @@ func (s closingKeuanganService) calculateProductionData(c *fiber.Ctx, projectFlo
 func (s closingKeuanganService) buildHPPSection(c *fiber.Ctx, projectFlock *entity.ProjectFlock, projectFlockKandangs []entity.ProjectFlockKandang, costs *CostData, production *ProductionData) dto.HPPSection {
 
 	actualPopulation := production.TotalPopulationIn - production.TotalDepletion
-	if lastPopulation, ok := s.getLastPopulationFromRecordings(c, projectFlockKandangs); ok {
-		actualPopulation = lastPopulation
-	}
 	totalWeightProduced := production.TotalWeightProduced
 	totalEggWeightKg := production.TotalEggWeightKg
 
@@ -532,35 +529,6 @@ func (s closingKeuanganService) buildProfitLossSection(projectFlock *entity.Proj
 	return dto.ToProfitLossSection(plItems, plSummary)
 }
 
-func (s closingKeuanganService) getLastPopulationFromRecordings(c *fiber.Ctx, projectFlockKandangs []entity.ProjectFlockKandang) (float64, bool) {
-	if s.RecordingRepo == nil || len(projectFlockKandangs) == 0 {
-		return 0, false
-	}
-
-	total := 0.0
-	recordedCount := 0
-	for _, kandang := range projectFlockKandangs {
-		latest, err := s.RecordingRepo.GetLatestByProjectFlockKandangID(c.Context(), kandang.Id)
-		if err != nil {
-			s.Log.Errorf("Failed to fetch latest recording for project_flock_kandang_id=%d: %+v", kandang.Id, err)
-			return 0, false
-		}
-		if latest == nil || latest.TotalChickQty == nil {
-			continue
-		}
-		recordedCount++
-		if *latest.TotalChickQty > 0 {
-			total += *latest.TotalChickQty
-		}
-	}
-
-	if recordedCount != len(projectFlockKandangs) {
-		return 0, false
-	}
-
-	return total, true
-}
-
 func containsFlag(flags []entity.Flag, name string) bool {
 	for _, flag := range flags {
 		if flag.Name == name {

internal/modules/closings/services/sapronak.service.go

@@ -18,8 +18,8 @@ import (
 )
 
 type SapronakService interface {
-	GetSapronakByProject(ctx *fiber.Ctx, projectFlockID uint, flag string) ([]dto.SapronakReportDTO, map[uint][]string, error)
+	GetSapronakByProject(ctx *fiber.Ctx, projectFlockID uint, flag string) ([]dto.SapronakReportDTO, error)
-	GetSapronakByKandang(ctx *fiber.Ctx, projectFlockID uint, pfkID uint, flag string) (*dto.SapronakReportDTO, map[uint][]string, error)
+	GetSapronakByKandang(ctx *fiber.Ctx, projectFlockID uint, pfkID uint, flag string) (*dto.SapronakReportDTO, error)
 }
 
 type sapronakService struct {
@@ -42,9 +42,9 @@ func NewSapronakService(
 	}
 }
 
-func (s sapronakService) GetSapronakByProject(c *fiber.Ctx, projectFlockID uint, flag string) ([]dto.SapronakReportDTO, map[uint][]string, error) {
+func (s sapronakService) GetSapronakByProject(c *fiber.Ctx, projectFlockID uint, flag string) ([]dto.SapronakReportDTO, error) {
 	if projectFlockID == 0 {
-		return nil, nil, fiber.NewError(fiber.StatusBadRequest, "project_flock_id is required")
+		return nil, fiber.NewError(fiber.StatusBadRequest, "project_flock_id is required")
 	}
 	reports, err := s.computeSapronakReports(c.Context(), &validation.CountSapronakQuery{
 		ProjectFlockID: projectFlockID,
@@ -52,27 +52,19 @@ func (s sapronakService) GetSapronakByProject(c *fiber.Ctx, projectFlockID uint,
 		Flag:           flag,
 	})
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 	if len(reports) <= 1 {
-		flags, err := s.collectProductFlags(c.Context(), reports)
+		return reports, nil
-		if err != nil {
-			return nil, nil, err
-		}
-		return reports, flags, nil
 	}
 
 	combined := s.combineSapronakReports(reports, projectFlockID)
-	flags, err := s.collectProductFlags(c.Context(), []dto.SapronakReportDTO{combined})
+	return []dto.SapronakReportDTO{combined}, nil
-	if err != nil {
-		return nil, nil, err
-	}
-	return []dto.SapronakReportDTO{combined}, flags, nil
 }
 
-func (s sapronakService) GetSapronakByKandang(c *fiber.Ctx, projectFlockID uint, pfkID uint, flag string) (*dto.SapronakReportDTO, map[uint][]string, error) {
+func (s sapronakService) GetSapronakByKandang(c *fiber.Ctx, projectFlockID uint, pfkID uint, flag string) (*dto.SapronakReportDTO, error) {
 	if projectFlockID == 0 || pfkID == 0 {
-		return nil, nil, fiber.NewError(fiber.StatusBadRequest, "project_flock_id and project_flock_kandang_id are required")
+		return nil, fiber.NewError(fiber.StatusBadRequest, "project_flock_id and project_flock_kandang_id are required")
 	}
 
 	results, err := s.computeSapronakReports(c.Context(), &validation.CountSapronakQuery{
@@ -82,20 +74,16 @@ func (s sapronakService) GetSapronakByKandang(c *fiber.Ctx, projectFlockID uint,
 		Flag:                  flag,
 	})
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	for _, res := range results {
 		if res.ProjectFlockID == projectFlockID && res.ProjectFlockKandangID == pfkID {
-			flags, err := s.collectProductFlags(c.Context(), []dto.SapronakReportDTO{res})
+			return &res, nil
-			if err != nil {
-				return nil, nil, err
-			}
-			return &res, flags, nil
 		}
 	}
 
-	return nil, nil, fiber.NewError(fiber.StatusNotFound, "Sapronak for kandang not found")
+	return nil, fiber.NewError(fiber.StatusNotFound, "Sapronak for kandang not found")
 }
 
 func (s sapronakService) computeSapronakReports(ctx context.Context, params *validation.CountSapronakQuery) ([]dto.SapronakReportDTO, error) {
@@ -148,52 +136,6 @@ func (s sapronakService) computeSapronakReports(ctx context.Context, params *val
 	return results, nil
 }
 
-func (s sapronakService) collectProductFlags(ctx context.Context, reports []dto.SapronakReportDTO) (map[uint][]string, error) {
-	productIDs := make(map[uint]struct{})
-	for _, report := range reports {
-		for _, group := range report.Groups {
-			for _, item := range group.Items {
-				if item.ProductID > 0 {
-					productIDs[item.ProductID] = struct{}{}
-				}
-			}
-		}
-	}
-	if len(productIDs) == 0 {
-		return map[uint][]string{}, nil
-	}
-
-	ids := make([]uint, 0, len(productIDs))
-	for id := range productIDs {
-		ids = append(ids, id)
-	}
-
-	products, err := s.Repository.GetProductsWithFlagsByIDs(ctx, ids)
-	if err != nil {
-		return nil, err
-	}
-
-	result := make(map[uint][]string, len(products))
-	for _, product := range products {
-		if len(product.Flags) == 0 {
-			continue
-		}
-		flags := make([]string, 0, len(product.Flags))
-		for _, flag := range product.Flags {
-			name := strings.TrimSpace(flag.Name)
-			if name == "" {
-				continue
-			}
-			flags = append(flags, strings.ToUpper(name))
-		}
-		if len(flags) > 0 {
-			result[product.Id] = flags
-		}
-	}
-
-	return result, nil
-}
-
 func (s sapronakService) loadProjectFlockKandangs(ctx context.Context, params *validation.CountSapronakQuery) ([]entity.ProjectFlockKandang, error) {
 	db := s.ProjectFlockKandangRepo.DB().WithContext(ctx).
 		Preload("ProjectFlock").

internal/modules/constants/repositories/constant.repository.go

@@ -12,7 +12,7 @@ import (
 )
 
 type ConstantRepository interface {
-	GetConstants() (map[string]interface{}, error)
+	GetConstants() map[string]interface{}
 }
 
 type ConstantRepositoryImpl struct {
@@ -25,7 +25,7 @@ func NewConstantRepository(db *gorm.DB) ConstantRepository {
 	}
 }
 
-func (r *ConstantRepositoryImpl) GetConstants() (map[string]interface{}, error) {
+func (r *ConstantRepositoryImpl) GetConstants() map[string]interface{} {
 	flagList := make([]string, 0)
 	for f := range utils.AllFlagTypes() {
 		flagList = append(flagList, string(f))
@@ -75,8 +75,6 @@ func (r *ConstantRepositoryImpl) GetConstants() (map[string]interface{}, error)
 		})
 	}
 
-	adjustmentSubtypesByType := utils.AdjustmentTransactionSubtypesByTypeForFrontend()
-
 	return map[string]interface{}{
 		"flags": flagList,
 		"warehouse_types": []string{
@@ -96,9 +94,6 @@ func (r *ConstantRepositoryImpl) GetConstants() (map[string]interface{}, error)
 			"BISNIS",
 			"INDIVIDUAL",
 		},
-		"adjustment": map[string]interface{}{
-			"transaction_subtypes": adjustmentSubtypesByType,
-		},
 		"approval_workflows": approvalWorkflows,
-	}, nil
+	}
 }

internal/modules/constants/services/constant.service.go

@@ -22,5 +22,5 @@ func NewConstantService(repo repository.ConstantRepository, validate *validator.
 }
 
 func (s constantService) GetAll(c *fiber.Ctx) (map[string]interface{}, error) {
-	return s.Repository.GetConstants()
+	return s.Repository.GetConstants(), nil
 }

internal/modules/inventory/adjustments/controllers/adjustment.controller.go

@@ -52,8 +52,6 @@ func (u *AdjustmentController) AdjustmentHistory(c *fiber.Ctx) error {
 		ProductID:       uint(c.QueryInt("product_id", 0)),
 		WarehouseID:     uint(c.QueryInt("warehouse_id", 0)),
 		TransactionType: c.Query("transaction_type", ""),
-		TransactionSubtype: c.Query("transaction_subtype", ""),
-		FunctionCode:       c.Query("function_code", ""),
 	}
 
 	result, totalResults, err := u.AdjustmentService.AdjustmentHistory(c, query)

internal/modules/inventory/adjustments/dto/adjustment.dto.go

@@ -17,21 +17,9 @@ type ProductRelationDTO struct {
 	ProductCategory *productCategoryDTO.ProductCategoryRelationDTO `json:"product_category,omitempty"`
 }
 
-type LocationRelationDTO struct {
-	Id   uint   `json:"id"`
-	Name string `json:"name"`
-}
-
-type ProjectFlockRelationDTO struct {
-	Id        uint   `json:"id"`
-	FlockName string `json:"flock_name"`
-	Period    int    `json:"period"`
-}
-
 type WarehouseRelationDTO struct {
 	Id   uint   `json:"id"`
 	Name string `json:"name"`
-	Location *LocationRelationDTO `json:"location,omitempty"`
 }
 
 type ProductWarehouseDTO struct {
@@ -41,23 +29,13 @@ type ProductWarehouseDTO struct {
 	Quantity    float64               `json:"quantity"`
 	Product     *ProductRelationDTO   `json:"product,omitempty"`
 	Warehouse   *WarehouseRelationDTO `json:"warehouse,omitempty"`
-	ProjectFlock *ProjectFlockRelationDTO `json:"project_flock,omitempty"`
 }
 
 type AdjustmentRelationDTO struct {
 	Id                 uint                 `json:"id"`
-	AdjNumber          string                   `json:"adj_number"`
-	TransactionType    string                   `json:"transaction_type"`
-	TransactionSubtype string                   `json:"transaction_subtype"`
-	FunctionCode       string                   `json:"function_code"`
-	Qty                float64                  `json:"qty"`
-	Price              float64                  `json:"price"`
-	GrandTotal         float64                  `json:"grand_total"`
 	Increase           float64              `json:"increase"`
 	Decrease           float64              `json:"decrease"`
-	Notes              string                   `json:"notes,omitempty"`
+	Note               string               `json:"note,omitempty"`
-	Location           *LocationRelationDTO     `json:"location,omitempty"`
-	ProjectFlock       *ProjectFlockRelationDTO `json:"project_flock,omitempty"`
 	ProductWarehouseId uint                 `json:"product_warehouse_id"`
 	ProductWarehouse   *ProductWarehouseDTO `json:"product_warehouse,omitempty"`
 }
@@ -105,28 +83,6 @@ func ToWarehouseRelationDTO(e *entity.Warehouse) *WarehouseRelationDTO {
 	return &WarehouseRelationDTO{
 		Id:   e.Id,
 		Name: e.Name,
-		Location: ToLocationRelationDTO(e.Location),
-	}
-}
-
-func ToLocationRelationDTO(e *entity.Location) *LocationRelationDTO {
-	if e == nil {
-		return nil
-	}
-	return &LocationRelationDTO{
-		Id:   e.Id,
-		Name: e.Name,
-	}
-}
-
-func ToProjectFlockRelationDTO(e *entity.ProjectFlockKandang) *ProjectFlockRelationDTO {
-	if e == nil || e.ProjectFlock.Id == 0 {
-		return nil
-	}
-	return &ProjectFlockRelationDTO{
-		Id:        e.ProjectFlock.Id,
-		FlockName: e.ProjectFlock.FlockName,
-		Period:    e.Period,
 	}
 }
 
@@ -141,42 +97,15 @@ func ToProductWarehouseDTO(e *entity.ProductWarehouse) *ProductWarehouseDTO {
 		Quantity:    e.Quantity,
 		Product:     ToProductRelationDTO(&e.Product),
 		Warehouse:   ToWarehouseRelationDTO(&e.Warehouse),
-		ProjectFlock: ToProjectFlockRelationDTO(e.ProjectFlockKandang),
 	}
 }
 
 func ToAdjustmentRelationDTO(e *entity.AdjustmentStock) AdjustmentRelationDTO {
-	note := ""
-	if e.StockLog != nil {
-		note = e.StockLog.Notes
-	}
-
-	qty := e.TotalQty
-	if qty <= 0 {
-		qty = e.UsageQty + e.PendingQty
-	}
-
-	var location *LocationRelationDTO
-	var projectFlock *ProjectFlockRelationDTO
-	if e.ProductWarehouse != nil {
-		location = ToLocationRelationDTO(e.ProductWarehouse.Warehouse.Location)
-		projectFlock = ToProjectFlockRelationDTO(e.ProductWarehouse.ProjectFlockKandang)
-	}
-
 	return AdjustmentRelationDTO{
 		Id:                 e.Id,
-		AdjNumber:          e.AdjNumber,
+		Note:               "",
-		TransactionType:    e.TransactionType,
-		TransactionSubtype: e.FunctionCode,
-		FunctionCode:       e.FunctionCode,
-		Qty:                qty,
-		Price:              e.Price,
-		GrandTotal:         e.GrandTotal,
 		Increase:           e.TotalQty,
 		Decrease:           e.UsageQty,
-		Notes:              note,
-		Location:           location,
-		ProjectFlock:       projectFlock,
 		ProductWarehouseId: e.ProductWarehouseId,
 		ProductWarehouse:   ToProductWarehouseDTO(e.ProductWarehouse),
 	}

internal/modules/inventory/adjustments/module.go

@@ -5,6 +5,7 @@ import (
 	"github.com/gofiber/fiber/v2"
 	"gorm.io/gorm"
 
+	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
 	rAdjustmentStock "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/adjustments/repositories"
 	sAdjustment "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/adjustments/services"
@@ -16,6 +17,7 @@ import (
 	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
 	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 )
 
 type AdjustmentModule struct{}
@@ -29,7 +31,41 @@ func (AdjustmentModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validat
 	userRepo := rUser.NewUserRepository(db)
 	productRepo := rproduct.NewProductRepository(db)
 	adjustmentStockRepo := rAdjustmentStock.NewAdjustmentStockRepository(db)
-	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
+	stockAllocRepo := commonRepo.NewStockAllocationRepository(db)
+
+	fifoService := commonSvc.NewFifoService(db, stockAllocRepo, productWarehouseRepo, utils.Log)
+
+	err := fifoService.RegisterStockable(fifo.StockableConfig{
+		Key:   fifo.StockableKeyAdjustmentIn,
+		Table: "adjustment_stocks",
+		Columns: fifo.StockableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			TotalQuantity:      "total_qty",
+			TotalUsedQuantity:  "total_used",
+			CreatedAt:          "created_at",
+		},
+		OrderBy: []string{"created_at ASC", "id ASC"},
+	})
+	if err != nil {
+		panic("Failed to register ADJUSTMENT_IN as Stockable: " + err.Error())
+	}
+
+	err = fifoService.RegisterUsable(fifo.UsableConfig{
+		Key:   fifo.UsableKeyAdjustmentOut,
+		Table: "adjustment_stocks",
+		Columns: fifo.UsableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			UsageQuantity:      "usage_qty",
+			PendingQuantity:    "pending_qty",
+			CreatedAt:          "created_at",
+		},
+		OrderBy: []string{"created_at ASC", "id ASC"},
+	})
+	if err != nil {
+		panic("Failed to register ADJUSTMENT_OUT as Usable: " + err.Error())
+	}
 
 	adjustmentService := sAdjustment.NewAdjustmentService(
 		productRepo,
@@ -37,7 +73,7 @@ func (AdjustmentModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validat
 		warehouseRepo,
 		productWarehouseRepo,
 		adjustmentStockRepo,
-		fifoStockV2Service,
+		fifoService,
 		validate,
 		projectFlockKandangRepo,
 	)

internal/modules/inventory/adjustments/repositories/adjustment_stock.repository.go

@@ -2,7 +2,6 @@ package repositories
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"strconv"
 	"strings"
@@ -15,35 +14,11 @@ import (
 type AdjustmentStockRepository interface {
 	CreateOne(ctx context.Context, data *entity.AdjustmentStock, modifier func(*gorm.DB) *gorm.DB) error
 	GetByID(ctx context.Context, id uint, modifier func(*gorm.DB) *gorm.DB) (*entity.AdjustmentStock, error)
-	FindKandangIDByProjectFlockKandangID(ctx context.Context, projectFlockKandangID uint) (uint, error)
-	FindRoutesByFunctionCode(ctx context.Context, productID uint, functionCode string) ([]AdjustmentRouteResolution, error)
-	FindOverconsumeRule(ctx context.Context, lane, flagGroupCode, functionCode string) (*bool, error)
-	FindHistory(ctx context.Context, filter AdjustmentHistoryFilter, modifier func(*gorm.DB) *gorm.DB) ([]*entity.AdjustmentStock, int64, error)
 	WithTx(tx *gorm.DB) AdjustmentStockRepository
 	DB() *gorm.DB
 	GenerateSequentialNumber(ctx context.Context, prefix string) (string, error)
 }
 
-type AdjustmentRouteResolution 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"`
-	AllowPendingDefault bool   `gorm:"column:allow_pending_default"`
-}
-
-type AdjustmentHistoryFilter struct {
-	ProductID       uint
-	WarehouseID     uint
-	TransactionType string
-	FunctionCode    string
-	ScopeRestrict   bool
-	ScopeIDs        []uint
-	Offset          int
-	Limit           int
-}
-
 type adjustmentStockRepositoryImpl struct {
 	db *gorm.DB
 }
@@ -73,151 +48,6 @@ func (r *adjustmentStockRepositoryImpl) GetByID(ctx context.Context, id uint, mo
 	return &record, nil
 }
 
-func (r *adjustmentStockRepositoryImpl) FindKandangIDByProjectFlockKandangID(ctx context.Context, projectFlockKandangID uint) (uint, error) {
-	type pfkRow struct {
-		KandangID uint `gorm:"column:kandang_id"`
-	}
-
-	var pfk pfkRow
-	err := r.db.WithContext(ctx).
-		Table("project_flock_kandangs pfk").
-		Select("pfk.kandang_id").
-		Where("pfk.id = ?", projectFlockKandangID).
-		Where("pfk.closed_at IS NULL").
-		Take(&pfk).Error
-	if err != nil {
-		return 0, err
-	}
-	return pfk.KandangID, nil
-}
-
-func (r *adjustmentStockRepositoryImpl) FindRoutesByFunctionCode(
-	ctx context.Context,
-	productID uint,
-	functionCode string,
-) ([]AdjustmentRouteResolution, error) {
-	var rows []AdjustmentRouteResolution
-	err := r.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, rr.allow_pending_default").
-		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
-	}
-	return rows, nil
-}
-
-func (r *adjustmentStockRepositoryImpl) FindOverconsumeRule(
-	ctx context.Context,
-	lane string,
-	flagGroupCode string,
-	functionCode string,
-) (*bool, error) {
-	type selectedRow struct {
-		AllowOverconsume bool `gorm:"column:allow_overconsume"`
-	}
-
-	var selected selectedRow
-	err := r.db.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(&selected).Error
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, nil
-		}
-		return nil, err
-	}
-
-	return &selected.AllowOverconsume, nil
-}
-
-func (r *adjustmentStockRepositoryImpl) FindHistory(
-	ctx context.Context,
-	filter AdjustmentHistoryFilter,
-	modifier func(*gorm.DB) *gorm.DB,
-) ([]*entity.AdjustmentStock, int64, error) {
-	q := r.db.WithContext(ctx).Model(&entity.AdjustmentStock{}).
-		Preload("ProductWarehouse").
-		Preload("ProductWarehouse.Product").
-		Preload("ProductWarehouse.Warehouse").
-		Preload("ProductWarehouse.Warehouse.Location").
-		Preload("ProductWarehouse.ProjectFlockKandang").
-		Preload("ProductWarehouse.ProjectFlockKandang.ProjectFlock").
-		Preload("StockLog.CreatedUser")
-
-	if modifier != nil {
-		q = modifier(q)
-	}
-
-	if filter.ScopeRestrict {
-		q = q.Joins("JOIN product_warehouses pw_scope ON pw_scope.id = adjustment_stocks.product_warehouse_id").
-			Joins("JOIN warehouses w_scope ON w_scope.id = pw_scope.warehouse_id")
-		if len(filter.ScopeIDs) == 0 {
-			q = q.Where("1 = 0")
-		} else {
-			q = q.Where("w_scope.location_id IN ?", filter.ScopeIDs)
-		}
-	}
-
-	if filter.ProductID > 0 || filter.WarehouseID > 0 {
-		q = q.Joins("JOIN product_warehouses pw_filter ON pw_filter.id = adjustment_stocks.product_warehouse_id")
-		if filter.ProductID > 0 {
-			q = q.Where("pw_filter.product_id = ?", filter.ProductID)
-		}
-		if filter.WarehouseID > 0 {
-			q = q.Where("pw_filter.warehouse_id = ?", filter.WarehouseID)
-		}
-	}
-
-	if strings.TrimSpace(filter.TransactionType) != "" {
-		q = q.Where("UPPER(adjustment_stocks.transaction_type) = ?", strings.ToUpper(strings.TrimSpace(filter.TransactionType)))
-	}
-
-	if strings.TrimSpace(filter.FunctionCode) != "" {
-		q = q.Where("adjustment_stocks.function_code = ?", strings.ToUpper(strings.TrimSpace(filter.FunctionCode)))
-	}
-
-	var total int64
-	if err := q.Count(&total).Error; err != nil {
-		return nil, 0, err
-	}
-
-	var rows []entity.AdjustmentStock
-	if err := q.Offset(filter.Offset).Limit(filter.Limit).Order("created_at DESC").Find(&rows).Error; err != nil {
-		return nil, 0, err
-	}
-
-	result := make([]*entity.AdjustmentStock, len(rows))
-	for i := range rows {
-		result[i] = &rows[i]
-	}
-	return result, total, nil
-}
-
 func (r *adjustmentStockRepositoryImpl) WithTx(tx *gorm.DB) AdjustmentStockRepository {
 	return &adjustmentStockRepositoryImpl{db: tx}
 }

internal/modules/inventory/adjustments/services/adjustment.service.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"math"
 	"strings"
 
 	"github.com/go-playground/validator/v10"
@@ -21,6 +20,7 @@ import (
 	projectFlockKandangRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
 	stockLogsRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 	"gorm.io/gorm"
 )
 
@@ -39,22 +39,16 @@ type adjustmentService struct {
 	ProductRepo               productRepo.ProductRepository
 	ProjectFlockKandangRepo   projectFlockKandangRepo.ProjectFlockKandangRepository
 	AdjustmentStockRepository adjustmentStockRepo.AdjustmentStockRepository
-	FifoStockV2Svc            common.FifoStockV2Service
+	FifoSvc                   common.FifoService
 }
 
-const (
-	adjustmentLaneStockable = "STOCKABLE"
-	adjustmentLaneUsable    = "USABLE"
-	flagGroupAyam           = "AYAM"
-)
-
 func NewAdjustmentService(
 	productRepo productRepo.ProductRepository,
 	stockLogsRepo stockLogsRepo.StockLogRepository,
 	warehouseRepo warehouseRepo.WarehouseRepository,
 	productWarehouseRepo ProductWarehouse.ProductWarehouseRepository,
 	adjustmentStockRepo adjustmentStockRepo.AdjustmentStockRepository,
-	fifoStockV2Svc common.FifoStockV2Service,
+	fifoSvc common.FifoService,
 	validate *validator.Validate,
 	projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository,
 ) AdjustmentService {
@@ -67,7 +61,7 @@ func NewAdjustmentService(
 		ProductRepo:               productRepo,
 		ProjectFlockKandangRepo:   projectFlockKandangRepo,
 		AdjustmentStockRepository: adjustmentStockRepo,
-		FifoStockV2Svc:            fifoStockV2Svc,
+		FifoSvc:                   fifoSvc,
 	}
 }
 
@@ -76,9 +70,6 @@ func (s *adjustmentService) withRelations(db *gorm.DB) *gorm.DB {
 		Preload("ProductWarehouse").
 		Preload("ProductWarehouse.Product").
 		Preload("ProductWarehouse.Warehouse").
-		Preload("ProductWarehouse.Warehouse.Location").
-		Preload("ProductWarehouse.ProjectFlockKandang").
-		Preload("ProductWarehouse.ProjectFlockKandang.ProjectFlock").
 		Preload("StockLog.CreatedUser")
 }
 
@@ -103,87 +94,47 @@ func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*e
 	if err := s.Validate.Struct(req); err != nil {
 		return nil, err
 	}
-
-	productID := req.ProductID
-	if productID == 0 {
-		return nil, fiber.NewError(fiber.StatusBadRequest, "Product is required")
-	}
-
-	qty := req.Qty
-	if qty <= 0 {
-		qty = req.Quantity
-	}
-	if qty <= 0 {
-		return nil, fiber.NewError(fiber.StatusBadRequest, "Quantity must be greater than zero")
-	}
-
-	functionCode := strings.ToUpper(strings.TrimSpace(req.TransactionSubtype))
-	if functionCode == "" {
-		functionCode = strings.ToUpper(strings.TrimSpace(req.TransactionSubType))
-	}
-	if functionCode == "" {
-		functionCode = strings.ToUpper(strings.TrimSpace(req.FunctionCode))
-	}
-	if functionCode == "" {
-		return nil, fiber.NewError(fiber.StatusBadRequest, "Transaction subtype is required")
-	}
-	if functionCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionOut) {
-		return nil, fiber.NewError(
-			fiber.StatusBadRequest,
-			"RECORDING_DEPLETION_OUT tidak boleh diinput manual. Gunakan RECORDING_DEPLETION_IN, sistem akan otomatis membuat depletion-out AYAM",
-		)
-	}
-
-	warehouseID, err := s.resolveWarehouseID(c.Context(), req)
-	if err != nil {
-		return nil, err
-	}
-
-	note := strings.TrimSpace(req.Notes)
-	if note == "" {
-		note = strings.TrimSpace(req.Note)
-	}
-	grandTotal := math.Round((qty*req.Price)*1000) / 1000
-
 	ctx := c.Context()
 	actorID, err := m.ActorIDFromContext(c)
 	if err != nil {
 		return nil, err
 	}
-	if err := m.EnsureWarehouseAccess(c, s.WarehouseRepo.DB(), warehouseID); err != nil {
+	if err := m.EnsureWarehouseAccess(c, s.WarehouseRepo.DB(), uint(req.WarehouseID)); err != nil {
 		return nil, err
 	}
-	if err := common.EnsureRelations(ctx,
+	if err := common.EnsureRelations(c.Context(),
-		common.RelationCheck{Name: "Product", ID: &productID, Exists: s.ProductRepo.IdExists},
+		common.RelationCheck{Name: "Product", ID: &req.ProductID, Exists: s.ProductRepo.IdExists},
-		common.RelationCheck{Name: "Warehouse", ID: &warehouseID, Exists: s.WarehouseRepo.IdExists},
+		common.RelationCheck{Name: "Warehouse", ID: &req.WarehouseID, Exists: s.WarehouseRepo.IdExists},
 	); err != nil {
 		return nil, err
 	}
 
-	routeMeta, err := s.resolveRouteByFunctionCode(ctx, productID, functionCode)
+	if req.Quantity <= 0 {
-	if err != nil {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Quantity must be greater than zero")
-		return nil, err
 	}
 
-	transactionType := utils.ResolveAdjustmentTransactionType(routeMeta.FunctionCode)
+	transactionType := strings.ToUpper(req.TransactionType)
+	if transactionType != string(utils.StockLogTransactionTypeIncrease) && transactionType != string(utils.StockLogTransactionTypeDecrease) {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Invalid transaction type")
+	}
 
 	var createdAdjustmentStockId uint
 
 	var projectFlockKandangID *uint
-	pfkID, err := s.getActiveProjectFlockKandangID(ctx, warehouseID)
+	pfkID, err := s.getActiveProjectFlockKandangID(ctx, uint(req.WarehouseID))
 	if err == nil && pfkID > 0 {
 		projectFlockKandangID = &pfkID
 	}
 
-	pw, err := s.ProductWarehouseRepo.FindByProductWarehouseAndPfk(ctx, productID, warehouseID, projectFlockKandangID)
+	pw, err := s.ProductWarehouseRepo.FindByProductWarehouseAndPfk(ctx, uint(req.ProductID), uint(req.WarehouseID), projectFlockKandangID)
 	if err != nil {
 		if !errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to get product warehouse")
 		}
 
 		newPW := &entity.ProductWarehouse{
-			ProductId:             productID,
+			ProductId:             uint(req.ProductID),
-			WarehouseId:           warehouseID,
+			WarehouseId:           uint(req.WarehouseID),
 			Quantity:              0,
 			ProjectFlockKandangId: projectFlockKandangID,
 		}
@@ -202,207 +153,96 @@ func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*e
 		return nil, err
 	}
 	err = s.StockLogsRepository.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		productWarehouseRepoTX := ProductWarehouse.NewProductWarehouseRepository(tx)
-		stockLogRepoTX := stockLogsRepo.NewStockLogRepository(tx)
-		adjustmentStockRepoTX := s.AdjustmentStockRepository.WithTx(tx)
 
-		productWarehouse, err := productWarehouseRepoTX.FindByProductWarehouseAndPfk(ctx, productID, warehouseID, projectFlockKandangID)
+		productWarehouse, err := s.ProductWarehouseRepo.FindByProductWarehouseAndPfk(ctx, uint(req.ProductID), uint(req.WarehouseID), projectFlockKandangID)
 		if err != nil {
 			s.Log.Errorf("Failed to get product warehouse: %+v", err)
 			return fiber.NewError(fiber.StatusInternalServerError, "Failed to get product warehouse")
 		}
 
-		if functionCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionIn) {
+		newLog := &entity.StockLog{
-			if routeMeta.Lane != adjustmentLaneStockable {
+			LoggableType:       string(utils.StockLogTypeAdjustment),
-				return fiber.NewError(fiber.StatusBadRequest, "Transaction subtype depletion in harus lane STOCKABLE")
+			LoggableId:         0,
-			}
+			Notes:              req.Note,
-			if projectFlockKandangID == nil || *projectFlockKandangID == 0 {
-				return fiber.NewError(fiber.StatusBadRequest, "project_flock_kandang_id aktif wajib tersedia untuk depletion conversion")
-			}
-			if s.FifoStockV2Svc == nil {
-				return fiber.NewError(fiber.StatusInternalServerError, "FIFO v2 service is not available")
-			}
-
-			sourcePW, err := s.resolveAyamSourceProductWarehouse(ctx, tx, warehouseID, *projectFlockKandangID)
-			if err != nil {
-				return err
-			}
-			if err := common.EnsureProjectFlockNotClosedForProductWarehouses(
-				ctx,
-				tx,
-				[]uint{productWarehouse.Id, sourcePW.Id},
-			); err != nil {
-				return err
-			}
-
-			sourceRoute, err := s.resolveRouteByFunctionCode(
-				ctx,
-				sourcePW.ProductId,
-				string(utils.AdjustmentTransactionSubtypeRecordingDepletionOut),
-			)
-			if err != nil {
-				return err
-			}
-			if sourceRoute.Lane != adjustmentLaneUsable {
-				return fiber.NewError(fiber.StatusBadRequest, "Route depletion out untuk produk AYAM tidak valid")
-			}
-
-			sourceCode, err := adjustmentStockRepoTX.GenerateSequentialNumber(ctx, utils.AdjustmentStockNumberPrefix)
-			if err != nil {
-				return err
-			}
-			sourceAdjustment := &entity.AdjustmentStock{
-				ProductWarehouseId: sourcePW.Id,
-				TransactionType:    transactionType,
-				FunctionCode:       sourceRoute.FunctionCode,
-				UsageQty:           qty,
-				Price:              req.Price,
-				GrandTotal:         grandTotal,
-				AdjNumber:          sourceCode,
-			}
-			if err := adjustmentStockRepoTX.CreateOne(ctx, sourceAdjustment, nil); err != nil {
-				return fiber.NewError(fiber.StatusInternalServerError, "Failed to create depletion source adjustment stock record")
-			}
-
-			destCode, err := adjustmentStockRepoTX.GenerateSequentialNumber(ctx, utils.AdjustmentStockNumberPrefix)
-			if err != nil {
-				return err
-			}
-			destinationAdjustment := &entity.AdjustmentStock{
 			ProductWarehouseId: productWarehouse.Id,
-				TransactionType:    transactionType,
+			CreatedBy:          actorID,
-				FunctionCode:       routeMeta.FunctionCode,
-				TotalQty:           qty,
-				Price:              req.Price,
-				GrandTotal:         grandTotal,
-				AdjNumber:          destCode,
-			}
-			if err := adjustmentStockRepoTX.CreateOne(ctx, destinationAdjustment, nil); err != nil {
-				return fiber.NewError(fiber.StatusInternalServerError, "Failed to create depletion destination adjustment stock record")
 		}
 
-			sourceAsOf := sourceAdjustment.CreatedAt
+		stockLogs, err := s.StockLogsRepository.GetByProductWarehouse(ctx, productWarehouse.Id, 1)
-			if _, err := s.FifoStockV2Svc.Reflow(ctx, common.FifoStockV2ReflowRequest{
-				FlagGroupCode:      sourceRoute.FlagGroupCode,
-				ProductWarehouseID: sourcePW.Id,
-				AsOf:               &sourceAsOf,
-				Tx:                 tx,
-			}); err != nil {
-				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to auto depletion-out AYAM via FIFO v2: %v", err))
-			}
-
-			destinationAsOf := destinationAdjustment.CreatedAt
-			if _, err := s.FifoStockV2Svc.Reflow(ctx, common.FifoStockV2ReflowRequest{
-				FlagGroupCode:      routeMeta.FlagGroupCode,
-				ProductWarehouseID: destinationAdjustment.ProductWarehouseId,
-				AsOf:               &destinationAsOf,
-				Tx:                 tx,
-			}); err != nil {
-				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to auto depletion-in destination via FIFO v2: %v", err))
-			}
-
-			refreshedSource, err := adjustmentStockRepoTX.GetByID(ctx, sourceAdjustment.Id, nil)
 		if err != nil {
-				return fiber.NewError(fiber.StatusInternalServerError, "Failed to refresh depletion source adjustment stock")
+			s.Log.Errorf("Failed to get stock logs: %+v", err)
-			}
+			return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
-			refreshedDestination, err := adjustmentStockRepoTX.GetByID(ctx, destinationAdjustment.Id, nil)
-			if err != nil {
-				return fiber.NewError(fiber.StatusInternalServerError, "Failed to refresh depletion destination adjustment stock")
 		}
 
-			if err := s.createAdjustmentStockLog(
+		if len(stockLogs) > 0 {
-				ctx,
+			latestStockLog := stockLogs[0]
-				stockLogRepoTX,
+			newLog.Stock = latestStockLog.Stock
-				refreshedSource.Id,
+		} else {
-				refreshedSource.ProductWarehouseId,
+			newLog.Stock = 0
-				note,
-				actorID,
-				0,
-				refreshedSource.UsageQty+refreshedSource.PendingQty,
-			); err != nil {
-				return err
-			}
-			if err := s.createAdjustmentStockLog(
-				ctx,
-				stockLogRepoTX,
-				refreshedDestination.Id,
-				refreshedDestination.ProductWarehouseId,
-				note,
-				actorID,
-				refreshedDestination.TotalQty,
-				0,
-			); err != nil {
-				return err
 		}
 
-			createdAdjustmentStockId = destinationAdjustment.Id
+		if transactionType == string(utils.StockLogTransactionTypeIncrease) {
-			return nil
+			newLog.Increase = req.Quantity
+			newLog.Stock += newLog.Increase
+		} else {
+			if productWarehouse.Quantity < req.Quantity {
+				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Stok tidak mencukupi untuk pengurangan. Stok saat ini: %.2f, Jumlah yang akan dikurangi: %.2f", productWarehouse.Quantity, req.Quantity))
+			}
+			newLog.Decrease = req.Quantity
+			newLog.Stock -= newLog.Decrease
+		}
+
+		if err := s.StockLogsRepository.WithTx(tx).CreateOne(ctx, newLog, nil); err != nil {
+
+			return err
 		}
 
 		adjustmentStock := &entity.AdjustmentStock{
 			ProductWarehouseId: productWarehouse.Id,
-			TransactionType:    transactionType,
-			FunctionCode:       routeMeta.FunctionCode,
-			Price:              req.Price,
-			GrandTotal:         grandTotal,
 		}
-		switch routeMeta.Lane {
+		code, err := s.AdjustmentStockRepository.GenerateSequentialNumber(ctx, utils.AdjustmentStockNumberPrefix)
-		case adjustmentLaneStockable:
-			adjustmentStock.TotalQty = qty
-		case adjustmentLaneUsable:
-			adjustmentStock.UsageQty = qty
-		}
-		code, err := adjustmentStockRepoTX.GenerateSequentialNumber(ctx, utils.AdjustmentStockNumberPrefix)
 		if err != nil {
 			return err
 		}
 		adjustmentStock.AdjNumber = code
-		if err := adjustmentStockRepoTX.CreateOne(ctx, adjustmentStock, nil); err != nil {
+		if err := s.AdjustmentStockRepository.WithTx(tx).CreateOne(ctx, adjustmentStock, nil); err != nil {
+
 			return fiber.NewError(fiber.StatusInternalServerError, "Failed to create adjustment stock record")
 		}
 
-		var increaseQty float64
+		newLog.LoggableType = string(utils.StockLogTypeAdjustment)
-		var decreaseQty float64
+		newLog.LoggableId = adjustmentStock.Id
-
+		if err := s.StockLogsRepository.WithTx(tx).UpdateOne(ctx, newLog.Id, newLog, nil); err != nil {
-		if routeMeta.Lane != adjustmentLaneStockable && routeMeta.Lane != adjustmentLaneUsable {
+			return fiber.NewError(fiber.StatusInternalServerError, "Failed to link stock log")
-			return fiber.NewError(fiber.StatusBadRequest, "Unsupported transaction subtype lane")
-		}
-		if s.FifoStockV2Svc == nil {
-			return fiber.NewError(fiber.StatusInternalServerError, "FIFO v2 service is not available")
 		}
 
-		asOf := adjustmentStock.CreatedAt
+		if transactionType == string(utils.StockLogTransactionTypeIncrease) {
-		if _, err := s.FifoStockV2Svc.Reflow(ctx, common.FifoStockV2ReflowRequest{
+
-			FlagGroupCode:      routeMeta.FlagGroupCode,
+			note := fmt.Sprintf("Stock Adjustment IN #%d", newLog.Id)
-			ProductWarehouseID: productWarehouse.Id,
+			_, err := s.FifoSvc.Replenish(ctx, common.StockReplenishRequest{
-			AsOf:               &asOf,
+				StockableKey:       fifo.StockableKeyAdjustmentIn,
+				StockableID:        adjustmentStock.Id,
+				ProductWarehouseID: uint(productWarehouse.Id),
+				Quantity:           req.Quantity,
+				Note:               &note,
 				Tx:                 tx,
-		}); err != nil {
+			})
-			return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to reflow stock via FIFO v2: %v", err))
-		}
-
-		refreshedAdjustment, err := adjustmentStockRepoTX.GetByID(ctx, adjustmentStock.Id, nil)
 			if err != nil {
-			return fiber.NewError(fiber.StatusInternalServerError, "Failed to refresh adjustment stock")
+				return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to replenish stock via FIFO: %v", err))
-		}
-		switch routeMeta.Lane {
-		case adjustmentLaneStockable:
-			increaseQty = refreshedAdjustment.TotalQty
-		case adjustmentLaneUsable:
-			decreaseQty = refreshedAdjustment.UsageQty
 			}
 
-		if err := s.createAdjustmentStockLog(
+		} else {
-			ctx,
+			_, err := s.FifoSvc.Consume(ctx, common.StockConsumeRequest{
-			stockLogRepoTX,
+				UsableKey:          fifo.UsableKeyAdjustmentOut,
-			adjustmentStock.Id,
+				UsableID:           adjustmentStock.Id,
-			productWarehouse.Id,
+				ProductWarehouseID: uint(productWarehouse.Id),
-			note,
+				Quantity:           req.Quantity,
-			actorID,
+				AllowPending:       false,
-			increaseQty,
+				Tx:                 tx,
-			decreaseQty,
+			})
-		); err != nil {
+			if err != nil {
-			return err
+				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to consume stock via FIFO: %v", err))
+			}
 		}
 
 		createdAdjustmentStockId = adjustmentStock.Id
@@ -421,91 +261,6 @@ func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*e
 	return s.GetOne(c, createdAdjustmentStockId)
 }
 
-func (s *adjustmentService) resolveWarehouseID(ctx context.Context, req *validation.Create) (uint, error) {
-	if req == nil {
-		return 0, fiber.NewError(fiber.StatusBadRequest, "Invalid request")
-	}
-
-	if req.WarehouseID > 0 {
-		return req.WarehouseID, nil
-	}
-
-	if req.ProjectFlockKandangID != nil && *req.ProjectFlockKandangID > 0 {
-		kandangID, err := s.AdjustmentStockRepository.FindKandangIDByProjectFlockKandangID(ctx, *req.ProjectFlockKandangID)
-		if err != nil {
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				return 0, fiber.NewError(fiber.StatusBadRequest, "project_flock_kandang_id tidak valid atau tidak aktif")
-			}
-			return 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to validate project_flock_kandang_id context")
-		}
-
-		warehouse, err := s.WarehouseRepo.GetLatestByKandangID(ctx, kandangID)
-		if err != nil {
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				return 0, fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Warehouse untuk project_flock_kandang_id %d tidak ditemukan", *req.ProjectFlockKandangID))
-			}
-			return 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to resolve warehouse by project_flock_kandang_id")
-		}
-		return warehouse.Id, nil
-	}
-
-	return 0, fiber.NewError(fiber.StatusBadRequest, "warehouse_id atau project_flock_kandang_id wajib diisi")
-}
-
-func (s *adjustmentService) resolveRouteByFunctionCode(
-	ctx context.Context,
-	productID uint,
-	functionCode string,
-) (*adjustmentStockRepo.AdjustmentRouteResolution, error) {
-	rows, err := s.AdjustmentStockRepository.FindRoutesByFunctionCode(ctx, productID, functionCode)
-	if err != nil {
-		return nil, err
-	}
-	if len(rows) == 0 {
-		return nil, fiber.NewError(fiber.StatusBadRequest, "Transaction subtype tidak kompatibel dengan konfigurasi FIFO v2 produk")
-	}
-
-	selected := rows[0]
-	for _, row := range rows {
-		if row.Lane != selected.Lane {
-			return nil, fiber.NewError(fiber.StatusBadRequest, "Transaction subtype ambigu: lane FIFO v2 lebih dari satu")
-		}
-	}
-
-	selected.FunctionCode = functionCode
-	switch selected.Lane {
-	case adjustmentLaneStockable, adjustmentLaneUsable:
-		return &selected, nil
-	default:
-		return nil, fiber.NewError(fiber.StatusBadRequest, "Transaction subtype memiliki lane FIFO v2 yang tidak didukung")
-	}
-}
-
-func (s *adjustmentService) resolveOverconsumePolicy(
-	ctx context.Context,
-	route *adjustmentStockRepo.AdjustmentRouteResolution,
-) (bool, error) {
-	if route == nil {
-		return false, fmt.Errorf("route is required")
-	}
-
-	defaultValue := route.AllowPendingDefault
-	selected, err := s.AdjustmentStockRepository.FindOverconsumeRule(
-		ctx,
-		route.Lane,
-		route.FlagGroupCode,
-		route.FunctionCode,
-	)
-	if err != nil {
-		return false, err
-	}
-	if selected == nil {
-		return defaultValue, nil
-	}
-
-	return *selected, nil
-}
-
 func (s *adjustmentService) getActiveProjectFlockKandangID(ctx context.Context, warehouseID uint) (uint, error) {
 	warehouse, err := s.WarehouseRepo.GetByID(ctx, warehouseID, nil)
 	if err != nil {
@@ -532,98 +287,10 @@ func (s *adjustmentService) getActiveProjectFlockKandangID(ctx context.Context,
 	return uint(projectFlockKandang.Id), nil
 }
 
-func (s *adjustmentService) resolveAyamSourceProductWarehouse(
-	ctx context.Context,
-	tx *gorm.DB,
-	warehouseID uint,
-	projectFlockKandangID uint,
-) (*entity.ProductWarehouse, error) {
-	if tx == nil {
-		return nil, fmt.Errorf("transaction is required")
-	}
-	if projectFlockKandangID == 0 {
-		return nil, fiber.NewError(fiber.StatusBadRequest, "project_flock_kandang_id tidak valid untuk depletion conversion")
-	}
-
-	var sourcePW entity.ProductWarehouse
-	err := tx.WithContext(ctx).
-		Model(&entity.ProductWarehouse{}).
-		Where("project_flock_kandang_id = ?", projectFlockKandangID).
-		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 = product_warehouses.product_id
-				  AND fm.flag_group_code = ?
-				)
-			`, entity.FlagableTypeProduct, flagGroupAyam).
-		Order(gorm.Expr("CASE WHEN warehouse_id = ? THEN 0 ELSE 1 END ASC", warehouseID)).
-		Order("id ASC").
-		Take(&sourcePW).Error
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, fiber.NewError(fiber.StatusBadRequest, "Produk sumber AYAM pada project flock kandang yang sama tidak ditemukan")
-		}
-		return nil, err
-	}
-
-	return &sourcePW, nil
-}
-
-func (s *adjustmentService) createAdjustmentStockLog(
-	ctx context.Context,
-	stockLogRepo stockLogsRepo.StockLogRepository,
-	adjustmentID uint,
-	productWarehouseID uint,
-	note string,
-	actorID uint,
-	increaseQty float64,
-	decreaseQty float64,
-) error {
-	if stockLogRepo == nil || adjustmentID == 0 || productWarehouseID == 0 {
-		return nil
-	}
-	if increaseQty == 0 && decreaseQty == 0 {
-		return nil
-	}
-
-	stockLogs, err := stockLogRepo.GetByProductWarehouse(ctx, productWarehouseID, 1)
-	if err != nil {
-		s.Log.Errorf("Failed to get stock logs: %+v", err)
-		return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
-	}
-
-	currentStock := 0.0
-	if len(stockLogs) > 0 {
-		currentStock = stockLogs[0].Stock
-	}
-
-	newLog := &entity.StockLog{
-		LoggableType:       string(utils.StockLogTypeAdjustment),
-		LoggableId:         adjustmentID,
-		Notes:              note,
-		ProductWarehouseId: productWarehouseID,
-		CreatedBy:          actorID,
-		Increase:           increaseQty,
-		Decrease:           decreaseQty,
-		Stock:              currentStock + increaseQty - decreaseQty,
-	}
-
-	return stockLogRepo.CreateOne(ctx, newLog, nil)
-}
-
 func (s *adjustmentService) AdjustmentHistory(c *fiber.Ctx, query *validation.Query) ([]*entity.AdjustmentStock, int64, error) {
 	if err := s.Validate.Struct(query); err != nil {
 		return nil, 0, err
 	}
-	if query.Page <= 0 {
-		query.Page = 1
-	}
-	if query.Limit <= 0 {
-		query.Limit = 10
-	}
 	offset := (query.Page - 1) * query.Limit
 
 	var isProductsExist bool
@@ -646,6 +313,15 @@ func (s *adjustmentService) AdjustmentHistory(c *fiber.Ctx, query *validation.Qu
 		return nil, 0, fiber.NewError(fiber.StatusNotFound, "Product not found")
 	}
 
+	var adjustmentStocks []entity.AdjustmentStock
+	var total int64
+
+	q := s.AdjustmentStockRepository.DB().WithContext(c.Context()).Model(&entity.AdjustmentStock{}).
+		Preload("ProductWarehouse").
+		Preload("ProductWarehouse.Product").
+		Preload("ProductWarehouse.Warehouse").
+		Preload("StockLog.CreatedUser")
+
 	scope, scopeErr := m.ResolveLocationScope(c, s.AdjustmentStockRepository.DB())
 	if scopeErr != nil {
 		return nil, 0, scopeErr
@@ -654,32 +330,42 @@ func (s *adjustmentService) AdjustmentHistory(c *fiber.Ctx, query *validation.Qu
 		if len(scope.IDs) == 0 {
 			return []*entity.AdjustmentStock{}, 0, nil
 		}
+		q = q.Joins("JOIN product_warehouses pw_scope ON pw_scope.id = adjustment_stocks.product_warehouse_id").
+			Joins("JOIN warehouses w_scope ON w_scope.id = pw_scope.warehouse_id")
+		q = m.ApplyScopeFilter(q, scope, "w_scope.location_id")
 	}
 
-	functionCode := strings.ToUpper(strings.TrimSpace(query.TransactionSubtype))
+	if query.ProductID > 0 {
-	if functionCode == "" {
+		q = q.Joins("JOIN product_warehouses ON product_warehouses.id = adjustment_stocks.product_warehouse_id").
-		functionCode = strings.ToUpper(strings.TrimSpace(query.FunctionCode))
+			Where("product_warehouses.product_id = ?", query.ProductID)
 	}
-	transactionType := strings.ToUpper(strings.TrimSpace(query.TransactionType))
 
-	adjustmentStocks, total, err := s.AdjustmentStockRepository.FindHistory(
+	if query.WarehouseID > 0 {
-		c.Context(),
+		q = q.Joins("JOIN product_warehouses ON product_warehouses.id = adjustment_stocks.product_warehouse_id").
-		adjustmentStockRepo.AdjustmentHistoryFilter{
+			Where("product_warehouses.warehouse_id = ?", query.WarehouseID)
-			ProductID:       query.ProductID,
+	}
-			WarehouseID:     query.WarehouseID,
+
-			TransactionType: transactionType,
+	if query.TransactionType != "" {
-			FunctionCode:    functionCode,
+		q = q.Joins("JOIN stock_logs ON stock_logs.loggable_type = ? AND stock_logs.loggable_id = adjustment_stocks.id", "ADJUSTMENT").
-			ScopeRestrict:   scope.Restrict,
+			Where("stock_logs.transaction_type = ?", strings.ToUpper(query.TransactionType))
-			ScopeIDs:        scope.IDs,
+	}
-			Offset:          offset,
+
-			Limit:           query.Limit,
+	if err = q.Count(&total).Error; err != nil {
-		},
+		s.Log.Errorf("Failed to get adjustments: %+v", err)
-		nil,
+		return nil, 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to get adjustment history")
-	)
+	}
+
+	err = q.Offset(offset).Limit(query.Limit).Order("created_at DESC").Find(&adjustmentStocks).Error
+
 	if err != nil {
 		s.Log.Errorf("Failed to get adjustments: %+v", err)
 		return nil, 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to get adjustment history")
 	}
 
-	return adjustmentStocks, total, nil
+	result := make([]*entity.AdjustmentStock, len(adjustmentStocks))
+	for i := range adjustmentStocks {
+		result[i] = &adjustmentStocks[i]
+	}
+
+	return result, total, nil
 }

internal/modules/inventory/adjustments/validations/adjustment.validation.go

@@ -1,16 +1,10 @@
 package validation
 
 type Create struct {
-	ProjectFlockKandangID *uint   `json:"project_flock_kandang_id" validate:"omitempty,min=1"`
+	ProductID       uint    `json:"product_id" validate:"required"`
-	WarehouseID           uint    `json:"warehouse_id" validate:"omitempty,min=1"`
+	WarehouseID     uint    `json:"warehouse_id" validate:"required"`
-	ProductID             uint    `json:"product_id" validate:"omitempty,min=1"`
+	TransactionType string  `json:"transaction_type" validate:"required,oneof=increase decrease"`
-	TransactionSubtype    string  `json:"transaction_subtype" validate:"required_without=TransactionSubType,max=64"`
+	Quantity        float64 `json:"quantity" validate:"required,gt=0"`
-	TransactionSubType    string  `json:"transaction_sub_type" validate:"required_without=TransactionSubtype,max=64"`
-	FunctionCode          string  `json:"function_code" validate:"omitempty,max=64"`
-	Qty                   float64 `json:"qty" validate:"omitempty,gt=0"`
-	Quantity              float64 `json:"quantity" validate:"omitempty,gt=0"`
-	Price                 float64 `json:"price" validate:"required,gte=0"`
-	Notes                 string  `json:"notes" validate:"omitempty,max=255"`
 	Note            string  `json:"note" validate:"omitempty,max=255"`
 }
 
@@ -19,7 +13,5 @@ type Query struct {
 	Limit           int    `query:"limit" validate:"omitempty,min=1,max=100"`
 	ProductID       uint   `query:"product_id" validate:"omitempty,min=0"`
 	WarehouseID     uint   `query:"warehouse_id" validate:"omitempty,min=0"`
-	TransactionType    string `query:"transaction_type" validate:"omitempty,max=100"`
+	TransactionType string `query:"transaction_type" validate:"omitempty,oneof=increase decrease"`
-	TransactionSubtype string `query:"transaction_subtype" validate:"omitempty,max=64"`
-	FunctionCode       string `query:"function_code" validate:"omitempty,max=64"`
 }

internal/modules/inventory/product-stocks/services/product-stock.service.go

@@ -175,47 +175,5 @@ func (s productStockService) GetOne(c *fiber.Ctx, id uint) (*entity.Product, err
 		s.Log.Errorf("Failed get product by id: %+v", err)
 		return nil, err
 	}
-
-	if len(product.ProductWarehouses) > 0 {
-		ids := make([]uint, 0, len(product.ProductWarehouses))
-		for _, pw := range product.ProductWarehouses {
-			if pw.Id != 0 {
-				ids = append(ids, pw.Id)
-			}
-		}
-
-		if len(ids) > 0 {
-			type pendingUsageRow struct {
-				ProductWarehouseId uint
-				PendingQty         float64
-			}
-
-			var rows []pendingUsageRow
-			if err := s.ProductRepository.DB().WithContext(c.Context()).
-				Table("recording_stocks").
-				Select("product_warehouse_id, COALESCE(SUM(pending_qty), 0) AS pending_qty").
-				Where("pending_qty > 0").
-				Where("product_warehouse_id IN ?", ids).
-				Group("product_warehouse_id").
-				Scan(&rows).Error; err != nil {
-				s.Log.Errorf("Failed to load pending usage for product warehouses: %+v", err)
-				return nil, err
-			}
-
-			if len(rows) > 0 {
-				pendingMap := make(map[uint]float64, len(rows))
-				for _, row := range rows {
-					pendingMap[row.ProductWarehouseId] = row.PendingQty
-				}
-
-				for i := range product.ProductWarehouses {
-					pw := &product.ProductWarehouses[i]
-					if pending, ok := pendingMap[pw.Id]; ok && pending != 0 {
-						pw.Quantity -= pending
-					}
-				}
-			}
-		}
-	}
 	return product, nil
 }

internal/modules/inventory/product-warehouses/services/product_warehouse.service.go

@@ -100,15 +100,11 @@ func (s productWarehouseService) GetAll(c *fiber.Ctx, params *validation.Query)
 
 	offset := (params.Page - 1) * params.Limit
 
-	var marketingTypes []string
 	if params.Type != "" {
-		marketingTypes = utils.ParseQueryArray(params.Type)
+		if !utils.IsValidMarketingType(params.Type) {
-		for _, t := range marketingTypes {
-			if !utils.IsValidMarketingType(t) {
 			return nil, 0, fiber.NewError(fiber.StatusBadRequest, "Invalid marketing type")
 		}
 	}
-	}
 
 	cleanFlags := utils.ParseFlags(params.Flags)
 
@@ -139,42 +135,16 @@ func (s productWarehouseService) GetAll(c *fiber.Ctx, params *validation.Query)
 			db = db.Where("warehouse_id = ?", params.WarehouseId)
 		}
 
-		if len(marketingTypes) > 0 {
+		if params.Type != "" {
-			flagSet := make(map[string]struct{})
+			switch params.Type {
-			for _, t := range marketingTypes {
-				switch t {
 			case string(utils.MarketingTypeAyamPullet):
-					flagSet[string(utils.FlagDOC)] = struct{}{}
+				db = s.Repository.ApplyFlagsFilter(db, []string{string(utils.FlagDOC), string(utils.FlagPullet), string(utils.FlagLayer)})
-					flagSet[string(utils.FlagPullet)] = struct{}{}
-					flagSet[string(utils.FlagLayer)] = struct{}{}
 			case string(utils.MarketingTypeAyam):
-					flagSet[string(utils.FlagAyamAfkir)] = struct{}{}
+				db = s.Repository.ApplyFlagsFilter(db, []string{string(utils.FlagAyamAfkir), string(utils.FlagAyamCulling), string(utils.FlagAyamMati)})
-					flagSet[string(utils.FlagAyamCulling)] = struct{}{}
-					flagSet[string(utils.FlagAyamMati)] = struct{}{}
 			case string(utils.MarketingTypeTelur):
-					flagSet[string(utils.FlagTelur)] = struct{}{}
+				db = s.Repository.ApplyFlagsFilter(db, []string{string(utils.FlagTelur), string(utils.FlagTelurUtuh), string(utils.FlagTelurPecah), string(utils.FlagTelurPutih), string(utils.FlagTelurRetak)})
-					flagSet[string(utils.FlagTelurUtuh)] = struct{}{}
-					flagSet[string(utils.FlagTelurPecah)] = struct{}{}
-					flagSet[string(utils.FlagTelurPutih)] = struct{}{}
-					flagSet[string(utils.FlagTelurRetak)] = struct{}{}
 			case string(utils.MarketingTypeTrading):
-					flagSet[string(utils.FlagPakan)] = struct{}{}
+				db = s.Repository.ApplyFlagsFilter(db, []string{string(utils.FlagPakan), string(utils.FlagPreStarter), string(utils.FlagStarter), string(utils.FlagFinisher), string(utils.FlagOVK), string(utils.FlagObat), string(utils.FlagVitamin), string(utils.FlagKimia), string(utils.FlagEkspedisi)})
-					flagSet[string(utils.FlagPreStarter)] = struct{}{}
-					flagSet[string(utils.FlagStarter)] = struct{}{}
-					flagSet[string(utils.FlagFinisher)] = struct{}{}
-					flagSet[string(utils.FlagOVK)] = struct{}{}
-					flagSet[string(utils.FlagObat)] = struct{}{}
-					flagSet[string(utils.FlagVitamin)] = struct{}{}
-					flagSet[string(utils.FlagKimia)] = struct{}{}
-					flagSet[string(utils.FlagEkspedisi)] = struct{}{}
-				}
-			}
-			if len(flagSet) > 0 {
-				flags := make([]string, 0, len(flagSet))
-				for f := range flagSet {
-					flags = append(flags, f)
-				}
-				db = s.Repository.ApplyFlagsFilter(db, flags)
 			}
 		}
 

internal/modules/inventory/product-warehouses/validations/product_warehouse.validation.go

@@ -20,5 +20,5 @@ type Query struct {
 	Flags           string `query:"flags" validate:"omitempty"`
 	KandangId       uint   `query:"kandang_id" validate:"omitempty,number,min=1"`
 	TransferContext string `query:"transfer_context" validate:"omitempty,oneof=inventory_transfer"`
-	Type            string `query:"type" validate:"omitempty"`
+	Type            string `query:"type" validate:"omitempty,oneof=AYAM TELUR TRADING AYAM_PULLET"`
 }

internal/modules/inventory/transfers/module.go

@@ -24,6 +24,7 @@ import (
 	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
 	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 )
 
 type TransferModule struct{}
@@ -42,6 +43,7 @@ func (TransferModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	kandangRepo := rKandang.NewKandangRepository(db)
 	nonstockRepo := rNonstock.NewNonstockRepository(db)
 	documentRepo := commonRepo.NewDocumentRepository(db)
+	stockAllocRepo := commonRepo.NewStockAllocationRepository(db)
 	expenseRepository := expenseRepo.NewExpenseRepository(db)
 	expenseRealizationRepo := expenseRepo.NewExpenseRealizationRepository(db)
 
@@ -50,6 +52,7 @@ func (TransferModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		panic(err)
 	}
 
+
 	approvalRepo := commonRepo.NewApprovalRepository(db)
 	approvalSvc := commonSvc.NewApprovalService(approvalRepo)
 	if err := approvalSvc.RegisterWorkflowSteps(utils.ApprovalWorkflowExpense, utils.ExpenseApprovalSteps); err != nil {
@@ -67,7 +70,7 @@ func (TransferModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		validate,
 	)
 
-	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
+	fifoService := commonSvc.NewFifoService(db, stockAllocRepo, productWarehouseRepo, utils.Log)
 	expenseBridge := sTransfer.NewTransferExpenseBridge(
 		db,
 		stockTransferRepo,
@@ -76,7 +79,39 @@ func (TransferModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		expenseServiceInstance,
 	)
 
-	transferService := sTransfer.NewTransferService(validate, stockTransferRepo, stockTransferDetailRepo, stockTransferDeliveryRepo, StockTransferDeliveryItemRepo, stockLogsRepo, productWarehouseRepo, supplierRepo, warehouseRepo, projectFlockKandangRepo, documentSvc, fifoStockV2Service, expenseBridge)
+	err = fifoService.RegisterStockable(fifo.StockableConfig{
+		Key:   fifo.StockableKeyStockTransferIn,
+		Table: "stock_transfer_details",
+		Columns: fifo.StockableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "dest_product_warehouse_id",
+			TotalQuantity:      "total_qty",
+			TotalUsedQuantity:  "total_used",
+			CreatedAt:          "created_at",
+		},
+		OrderBy: []string{"created_at ASC", "id ASC"},
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	err = fifoService.RegisterUsable(fifo.UsableConfig{
+		Key:   fifo.UsableKeyStockTransferOut,
+		Table: "stock_transfer_details",
+		Columns: fifo.UsableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "source_product_warehouse_id",
+			UsageQuantity:      "usage_qty",
+			PendingQuantity:    "pending_qty",
+			CreatedAt:          "created_at",
+		},
+		OrderBy: []string{"created_at ASC", "id ASC"},
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	transferService := sTransfer.NewTransferService(validate, stockTransferRepo, stockTransferDetailRepo, stockTransferDeliveryRepo, StockTransferDeliveryItemRepo, stockLogsRepo, productWarehouseRepo, supplierRepo, warehouseRepo, projectFlockKandangRepo, documentSvc, fifoService, expenseBridge)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	TransferRoutes(router, userService, transferService)

internal/modules/inventory/transfers/services/transfer.service.go

@@ -21,6 +21,7 @@ import (
 	projectFlockKandangRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
 	rStockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 
 	"gorm.io/gorm"
 )
@@ -44,11 +45,11 @@ type transferService struct {
 	WarehouseRepo                 warehouseRepo.WarehouseRepository
 	ProjectFlockKandangRepo       projectFlockKandangRepo.ProjectFlockKandangRepository
 	DocumentSvc                   commonSvc.DocumentService
-	FifoStockV2Svc                commonSvc.FifoStockV2Service
+	FifoSvc                       commonSvc.FifoService
 	ExpenseBridge                 TransferExpenseBridge
 }
 
-func NewTransferService(validate *validator.Validate, stockTransferRepo rStockTransfer.StockTransferRepository, stockTransferDetailRepo rStockTransfer.StockTransferDetailRepository, stockTransferDeliveryRepo rStockTransfer.StockTransferDeliveryRepository, stockTransferDeliveryItemRepo rStockTransfer.StockTransferDeliveryItemRepository, stockLogsRepo rStockLogs.StockLogRepository, productWarehouseRepo rProductWarehouse.ProductWarehouseRepository, supplierRepo rSupplier.SupplierRepository, warehouseRepo warehouseRepo.WarehouseRepository, projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository, documentSvc commonSvc.DocumentService, fifoStockV2Svc commonSvc.FifoStockV2Service, expenseBridge TransferExpenseBridge) TransferService {
+func NewTransferService(validate *validator.Validate, stockTransferRepo rStockTransfer.StockTransferRepository, stockTransferDetailRepo rStockTransfer.StockTransferDetailRepository, stockTransferDeliveryRepo rStockTransfer.StockTransferDeliveryRepository, stockTransferDeliveryItemRepo rStockTransfer.StockTransferDeliveryItemRepository, stockLogsRepo rStockLogs.StockLogRepository, productWarehouseRepo rProductWarehouse.ProductWarehouseRepository, supplierRepo rSupplier.SupplierRepository, warehouseRepo warehouseRepo.WarehouseRepository, projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository, documentSvc commonSvc.DocumentService, fifoSvc commonSvc.FifoService, expenseBridge TransferExpenseBridge) TransferService {
 	return &transferService{
 		Log:                           utils.Log,
 		Validate:                      validate,
@@ -62,7 +63,7 @@ func NewTransferService(validate *validator.Validate, stockTransferRepo rStockTr
 		WarehouseRepo:                 warehouseRepo,
 		ProjectFlockKandangRepo:       projectFlockKandangRepo,
 		DocumentSvc:                   documentSvc,
-		FifoStockV2Svc:                fifoStockV2Svc,
+		FifoSvc:                       fifoSvc,
 		ExpenseBridge:                 expenseBridge,
 	}
 }
@@ -441,79 +442,36 @@ func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferReques
 			}
 		}
 
-		if s.FifoStockV2Svc == nil {
-			return fiber.NewError(fiber.StatusInternalServerError, "FIFO v2 service is not available")
-		}
-		flagGroupByProduct := make(map[uint]string, len(req.Products))
-
 		for _, product := range req.Products {
 			detail := detailMap[uint64(product.ProductID)]
-			if detail == nil || detail.SourceProductWarehouseID == nil || detail.DestProductWarehouseID == nil {
-				return fiber.NewError(fiber.StatusInternalServerError, "Data transfer detail tidak valid")
-			}
 
-			flagGroupCode, ok := flagGroupByProduct[uint(product.ProductID)]
+			consumeResult, err := s.FifoSvc.Consume(c.Context(), commonSvc.StockConsumeRequest{
-			if !ok {
+				UsableKey:          fifo.UsableKeyStockTransferOut,
-				flagGroupCode, err = s.resolveTransferFlagGroup(c.Context(), tx, uint(product.ProductID))
+				UsableID:           uint(detail.Id),
+				ProductWarehouseID: uint(*detail.SourceProductWarehouseID),
+				Quantity:           product.ProductQty,
+				AllowPending:       false,
+				Tx:                 tx,
+			})
 			if err != nil {
-					return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("FIFO v2 route tidak ditemukan untuk produk %d: %v", product.ProductID, err))
+				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Stok tidak mencukupi untuk produk %d di gudang asal. Error: %v", product.ProductID, err))
-				}
-				flagGroupByProduct[uint(product.ProductID)] = flagGroupCode
 			}
 
 			if err := tx.Model(&entity.StockTransferDetail{}).
 				Where("id = ?", detail.Id).
 				Updates(map[string]interface{}{
-					"usage_qty":   product.ProductQty,
+					"usage_qty":   consumeResult.UsageQuantity,
-					"pending_qty": 0,
+					"pending_qty": consumeResult.PendingQuantity,
-					"total_qty":   product.ProductQty,
 				}).Error; err != nil {
-				s.Log.Errorf("Failed to update transfer detail seed fields for detail_id=%d, product_id=%d: %+v", detail.Id, product.ProductID, err)
+				s.Log.Errorf("Failed to update tracking usage for detail_id=%d, product_id=%d: %+v", detail.Id, product.ProductID, err)
 				return fiber.NewError(fiber.StatusInternalServerError, "Gagal memperbarui data tracking")
 			}
 
-			asOf := transferDate
-			if _, err := s.FifoStockV2Svc.Reflow(c.Context(), commonSvc.FifoStockV2ReflowRequest{
-				FlagGroupCode:      flagGroupCode,
-				ProductWarehouseID: uint(*detail.SourceProductWarehouseID),
-				AsOf:               &asOf,
-				Tx:                 tx,
-			}); err != nil {
-				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Stok tidak mencukupi untuk produk %d di gudang asal. Error: %v", product.ProductID, err))
-			}
-			if _, err := s.FifoStockV2Svc.Reflow(c.Context(), commonSvc.FifoStockV2ReflowRequest{
-				FlagGroupCode:      flagGroupCode,
-				ProductWarehouseID: uint(*detail.DestProductWarehouseID),
-				AsOf:               &asOf,
-				Tx:                 tx,
-			}); err != nil {
-				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Gagal reflow stok tujuan untuk produk %d. Error: %v", product.ProductID, err))
-			}
-
-			type usageSnapshot struct {
-				UsageQty   float64 `gorm:"column:usage_qty"`
-				PendingQty float64 `gorm:"column:pending_qty"`
-			}
-			var usage usageSnapshot
-			if err := tx.WithContext(c.Context()).
-				Table("stock_transfer_details").
-				Select("usage_qty, pending_qty").
-				Where("id = ?", detail.Id).
-				Take(&usage).Error; err != nil {
-				s.Log.Errorf("Failed to read transfer usage snapshot detail_id=%d, product_id=%d: %+v", detail.Id, product.ProductID, err)
-				return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data tracking")
-			}
-			outUsageQty := usage.UsageQty
-			outPendingQty := usage.PendingQty
-			if outPendingQty > 1e-6 {
-				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Stok tidak mencukupi untuk produk %d di gudang asal", product.ProductID))
-			}
-
 			stockLogDecrease := &entity.StockLog{
 				ProductWarehouseId: uint(*detail.SourceProductWarehouseID),
 				CreatedBy:          uint(actorID),
 				Increase:           0,
-				Decrease:           outUsageQty,
+				Decrease:           product.ProductQty,
 				LoggableType:       string(utils.StockLogTypeTransfer),
 				LoggableId:         uint(detail.Id),
 				Notes:              "",
@@ -525,7 +483,7 @@ func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferReques
 			}
 			if len(stockLogs) > 0 {
 				latestStockLog := stockLogs[0]
-				stockLogDecrease.Stock = latestStockLog.Stock - stockLogDecrease.Decrease
+				stockLogDecrease.Stock -= latestStockLog.Stock - stockLogDecrease.Decrease
 			} else {
 				stockLogDecrease.Stock -= stockLogDecrease.Decrease
 			}
@@ -534,12 +492,33 @@ func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferReques
 				return fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok keluar")
 			}
 
-			inAddedQty := outUsageQty
+			note := fmt.Sprintf("Transfer #%s", entityTransfer.MovementNumber)
+			replenishResult, err := s.FifoSvc.Replenish(c.Context(), commonSvc.StockReplenishRequest{
+				StockableKey:       fifo.StockableKeyStockTransferIn,
+				StockableID:        uint(detail.Id),
+				ProductWarehouseID: uint(*detail.DestProductWarehouseID),
+				Quantity:           product.ProductQty,
+				Note:               &note,
+				Tx:                 tx,
+			})
+			if err != nil {
+				s.Log.Errorf("Failed to replenish stock for product_id=%d, pw_id=%d, qty=%.2f: %+v", product.ProductID, *detail.DestProductWarehouseID, product.ProductQty, err)
+				return fiber.NewError(fiber.StatusInternalServerError, "Gagal menambah stok gudang tujuan")
+			}
+
+			if err := tx.Model(&entity.StockTransferDetail{}).
+				Where("id = ?", detail.Id).
+				Updates(map[string]interface{}{
+					"total_qty": replenishResult.AddedQuantity,
+				}).Error; err != nil {
+				s.Log.Errorf("Failed to update tracking total for detail_id=%d, product_id=%d: %+v", detail.Id, product.ProductID, err)
+				return fiber.NewError(fiber.StatusInternalServerError, "Gagal memperbarui data tracking")
+			}
 
 			stockLogIncrease := &entity.StockLog{
 				ProductWarehouseId: uint(*detail.DestProductWarehouseID),
 				CreatedBy:          uint(actorID),
-				Increase:           inAddedQty,
+				Increase:           product.ProductQty,
 				Decrease:           0,
 				LoggableType:       string(utils.StockLogTypeTransfer),
 				LoggableId:         uint(detail.Id),
@@ -617,47 +596,6 @@ func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferReques
 	return result, nil
 }
 
-func (s *transferService) resolveTransferFlagGroup(
-	ctx context.Context,
-	tx *gorm.DB,
-	productID uint,
-) (string, error) {
-	if productID == 0 {
-		return "", fmt.Errorf("product id is required")
-	}
-
-	type row struct {
-		FlagGroupCode string `gorm:"column:flag_group_code"`
-	}
-	var selected row
-	err := tx.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules rr").
-		Select("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 = ?", "USABLE").
-		Where("rr.function_code = ?", "STOCK_TRANSFER_OUT").
-		Where("rr.source_table = ?", "stock_transfer_details").
-		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("rr.id ASC").
-		Limit(1).
-		Take(&selected).Error
-	if err != nil {
-		return "", err
-	}
-
-	return strings.TrimSpace(selected.FlagGroupCode), nil
-}
-
 func (s *transferService) notifyExpenseItemsDelivered(c *fiber.Ctx, transferID uint64, payloads []TransferExpenseReceivingPayload) error {
 	if s.ExpenseBridge == nil || transferID == 0 || len(payloads) == 0 {
 		return nil

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

@@ -3,7 +3,6 @@ package controller
 import (
 	"math"
 	"strconv"
-	"strings"
 
 	"gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/dto"
 	service "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/services"
@@ -24,38 +23,9 @@ func NewDeliveryOrdersController(deliveryOrdersService service.DeliveryOrdersSer
 }
 
 func (u *DeliveryOrdersController) GetAll(c *fiber.Ctx) error {
-	parseUintListParam := func(param string) ([]uint, error) {
-		if param == "" {
-			return nil, nil
-		}
-		parts := strings.Split(param, ",")
-		ids := make([]uint, 0, len(parts))
-		for _, part := range parts {
-			trimmed := strings.TrimSpace(part)
-			if trimmed == "" {
-				return nil, strconv.ErrSyntax
-			}
-			parsed, err := strconv.ParseUint(trimmed, 10, 64)
-			if err != nil {
-				return nil, err
-			}
-			ids = append(ids, uint(parsed))
-		}
-		return ids, nil
-	}
-
-	productIDs, err := parseUintListParam(c.Query("product_ids", ""))
-	if err != nil {
-		return fiber.NewError(fiber.StatusBadRequest, "Invalid product_ids")
-	}
-
 	query := &validation.DeliveryOrderQuery{
 		Page:        c.QueryInt("page", 1),
 		Limit:       c.QueryInt("limit", 10),
-		Search:      strings.TrimSpace(c.Query("search", "")),
-		ProductIDs:  productIDs,
-		Status:      strings.ReplaceAll(strings.TrimSpace(c.Query("status", "")), "_", " "),
-		CustomerId:  uint(c.QueryInt("customer_id", 0)),
 		MarketingId: uint(c.QueryInt("marketing_id", 0)),
 	}
 

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

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"math"
 	"sort"
-	"strings"
 	"time"
 
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
@@ -18,7 +17,6 @@ import (
 type MarketingRelationDTO struct {
 	Id       uint      `json:"id"`
 	SoNumber string    `json:"so_number"`
-	DoNumber *string   `json:"do_number"`
 	SoDate   time.Time `json:"so_date"`
 	Notes    string    `json:"notes,omitempty"`
 }
@@ -97,16 +95,9 @@ type DeliveryMarketingProductDTO struct {
 }
 
 func ToMarketingRelationDTO(marketing *entity.Marketing) MarketingRelationDTO {
-	var doNumber *string
-	if doNumbers := collectDoNumbers(marketing); len(doNumbers) > 0 {
-		value := doNumbers[0]
-		doNumber = &value
-	}
-
 	return MarketingRelationDTO{
 		Id:       marketing.Id,
 		SoNumber: marketing.SoNumber,
-		DoNumber: doNumber,
 		SoDate:   marketing.SoDate,
 		Notes:    marketing.Notes,
 	}
@@ -191,6 +182,7 @@ func ToMarketingListDTO(marketing *entity.Marketing, deliveryProducts []entity.M
 			salesOrderProducts[i] = ToDeliveryMarketingProductDTO(product, marketing.MarketingType)
 		}
 	}
+
 	return MarketingListDTO{
 		MarketingRelationDTO: ToMarketingRelationDTO(marketing),
 		Customer:             customer,
@@ -247,6 +239,7 @@ func ToMarketingDetailDTO(marketing *entity.Marketing, deliveryProducts []entity
 		mapped := approvalDTO.ToApprovalDTO(*marketing.LatestApproval)
 		latestApproval = mapped
 	}
+
 	return MarketingDetailDTO{
 		MarketingRelationDTO: ToMarketingRelationDTO(marketing),
 		SoDocs:               marketing.SoDocs,
@@ -353,46 +346,11 @@ func groupDeliveryProducts(products []MarketingDeliveryProductDTO, soNumber stri
 }
 
 func GenerateDeliveryOrderNumber(soNumber string, deliveryDate *time.Time, warehouseId uint) string {
-	numberPrefix := soNumber
+	dateStr := ""
-	if strings.HasPrefix(strings.ToUpper(strings.TrimSpace(soNumber)), "SO-") {
+	if deliveryDate != nil {
-		numberPrefix = "DO-" + soNumber[3:]
+		dateStr = deliveryDate.Format("20060102")
 	}
-	return numberPrefix
+	return fmt.Sprintf("%s-%s-%d", soNumber, dateStr, warehouseId)
-}
-
-func collectDoNumbers(marketing *entity.Marketing) []string {
-	if marketing == nil || len(marketing.Products) == 0 {
-		return nil
-	}
-
-	seen := make(map[string]struct{})
-	for _, product := range marketing.Products {
-		if product.DeliveryProduct == nil || product.DeliveryProduct.DeliveryDate == nil {
-			continue
-		}
-		warehouseID := product.ProductWarehouse.WarehouseId
-		if warehouseID == 0 && product.ProductWarehouse.Warehouse.Id != 0 {
-			warehouseID = product.ProductWarehouse.Warehouse.Id
-		}
-		if warehouseID == 0 {
-			continue
-		}
-
-		doNumber := GenerateDeliveryOrderNumber(marketing.SoNumber, product.DeliveryProduct.DeliveryDate, warehouseID)
-		if doNumber != "" {
-			seen[doNumber] = struct{}{}
-		}
-	}
-
-	if len(seen) == 0 {
-		return nil
-	}
-	result := make([]string, 0, len(seen))
-	for value := range seen {
-		result = append(result, value)
-	}
-	sort.Strings(result)
-	return result
 }
 
 func getVehicleNumber(e entity.MarketingProduct) string {

internal/modules/marketing/module.go

@@ -2,6 +2,7 @@ package marketing
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
@@ -19,6 +20,7 @@ import (
 	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
 	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 )
 
 type MarketingModule struct{}
@@ -33,7 +35,24 @@ func (MarketingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	productWarehouseRepo := rProductWarehouse.NewProductWarehouseRepository(db)
 	stockLogRepo := rShared.NewStockLogRepository(db)
 
-	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
+	stockAllocationRepo := commonRepo.NewStockAllocationRepository(db)
+	fifoService := commonSvc.NewFifoService(db, stockAllocationRepo, productWarehouseRepo, utils.Log)
+
+	if err := fifoService.RegisterUsable(fifo.UsableConfig{
+		Key:   fifo.UsableKeyMarketingDelivery,
+		Table: "marketing_delivery_products",
+		Columns: fifo.UsableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			UsageQuantity:      "usage_qty",
+			PendingQuantity:    "pending_qty",
+			CreatedAt:          "created_at",
+		},
+	}); err != nil {
+		if !strings.Contains(strings.ToLower(err.Error()), "already registered") {
+			panic(fmt.Sprintf("failed to register marketing delivery usable workflow: %v", err))
+		}
+	}
 
 	approvalRepo := commonRepo.NewApprovalRepository(db)
 	approvalSvc := commonSvc.NewApprovalService(approvalRepo)
@@ -45,8 +64,8 @@ func (MarketingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	warehouseRepo := rWarehouse.NewWarehouseRepository(db)
 	projectFlockKandangRepo := rProjectFlockKandang.NewProjectFlockKandangRepository(db)
 
-	salesOrdersService := service.NewSalesOrdersService(marketingRepo, customerRepo, productWarehouseRepo, userRepo, approvalSvc, fifoStockV2Service, warehouseRepo, projectFlockKandangRepo, validate)
+	salesOrdersService := service.NewSalesOrdersService(marketingRepo, customerRepo, productWarehouseRepo, userRepo, approvalSvc, fifoService, warehouseRepo, projectFlockKandangRepo, validate)
-	deliveryOrdersService := service.NewDeliveryOrdersService(marketingRepo, marketingProductRepo, marketingDeliveryProductRepo, stockLogRepo, approvalSvc, fifoStockV2Service, validate)
+	deliveryOrdersService := service.NewDeliveryOrdersService(marketingRepo, marketingProductRepo, marketingDeliveryProductRepo, stockLogRepo, approvalSvc, fifoService, validate)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	RegisterRoutes(router, userService, salesOrdersService, deliveryOrdersService)

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

@@ -15,6 +15,7 @@ import (
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/validations"
 	rShared "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
@@ -35,7 +36,7 @@ type deliveryOrdersService struct {
 	MarketingDeliveryProductRepo marketingRepo.MarketingDeliveryProductRepository
 	StockLogRepo                 rShared.StockLogRepository
 	ApprovalSvc                  commonSvc.ApprovalService
-	FifoStockV2Svc               commonSvc.FifoStockV2Service
+	FifoSvc                      commonSvc.FifoService
 }
 
 func NewDeliveryOrdersService(
@@ -44,7 +45,7 @@ func NewDeliveryOrdersService(
 	marketingDeliveryProductRepo marketingRepo.MarketingDeliveryProductRepository,
 	stockLogRepo rShared.StockLogRepository,
 	approvalSvc commonSvc.ApprovalService,
-	fifoStockV2Svc commonSvc.FifoStockV2Service,
+	fifoSvc commonSvc.FifoService,
 	validate *validator.Validate,
 ) DeliveryOrdersService {
 	return &deliveryOrdersService{
@@ -54,7 +55,7 @@ func NewDeliveryOrdersService(
 		MarketingDeliveryProductRepo: marketingDeliveryProductRepo,
 		StockLogRepo:                 stockLogRepo,
 		ApprovalSvc:                  approvalSvc,
-		FifoStockV2Svc:               fifoStockV2Svc,
+		FifoSvc:                      fifoSvc,
 	}
 }
 
@@ -115,71 +116,6 @@ func (s deliveryOrdersService) GetAll(c *fiber.Ctx, params *validation.DeliveryO
 			Preload("Products.ProductWarehouse.Warehouse").
 			Preload("Products.DeliveryProduct")
 
-		if params.Status != "" {
-			latestApprovalSubQuery := s.MarketingRepo.DB().
-				WithContext(c.Context()).
-				Table("approvals").
-				Select("DISTINCT ON (approvable_id) approvable_id, step_name").
-				Where("approvable_type = ?", utils.ApprovalWorkflowMarketing.String()).
-				Order("approvable_id, id DESC")
-			db = db.Where(`EXISTS (
-				SELECT 1
-				FROM (?) AS latest_approval
-				WHERE latest_approval.approvable_id = marketings.id
-					AND LOWER(latest_approval.step_name) = LOWER(?)
-			)`, latestApprovalSubQuery, params.Status)
-		}
-
-		if params.Search != "" {
-			searchPattern := "%" + params.Search + "%"
-			db = db.Where(`(
-				marketings.so_number ILIKE ? OR
-				EXISTS (
-					SELECT 1
-					FROM customers c
-					WHERE c.id = marketings.customer_id
-						AND c.name ILIKE ?
-				) OR
-				EXISTS (
-					SELECT 1
-					FROM users su
-					WHERE su.id = marketings.sales_person_id
-						AND su.name ILIKE ?
-				) OR
-				EXISTS (
-					SELECT 1
-					FROM marketing_products mp
-					JOIN product_warehouses pw ON pw.id = mp.product_warehouse_id
-					JOIN products p ON p.id = pw.product_id
-					WHERE mp.marketing_id = marketings.id
-						AND p.name ILIKE ?
-				) OR
-				EXISTS (
-					SELECT 1
-					FROM marketing_products mp
-					JOIN product_warehouses pw ON pw.id = mp.product_warehouse_id
-					JOIN warehouses w ON w.id = pw.warehouse_id
-					WHERE mp.marketing_id = marketings.id
-						AND w.name ILIKE ?
-				)
-			)`, searchPattern, searchPattern, searchPattern, searchPattern, searchPattern)
-		}
-
-		if len(params.ProductIDs) > 0 {
-			db = db.Where(`EXISTS (
-				SELECT 1
-				FROM marketing_products mp
-				JOIN product_warehouses pw ON pw.id = mp.product_warehouse_id
-				JOIN products p ON p.id = pw.product_id
-				WHERE mp.marketing_id = marketings.id
-					AND p.id IN ?
-			)`, params.ProductIDs)
-		}
-
-		if params.CustomerId != 0 {
-			db = db.Where("marketings.customer_id = ?", params.CustomerId)
-		}
-
 		if scope.Restrict {
 			if len(scope.IDs) == 0 {
 				return db.Where("1 = 0")
@@ -548,42 +484,33 @@ func (s deliveryOrdersService) consumeDeliveryStock(ctx context.Context, tx *gor
 		return fiber.NewError(fiber.StatusInternalServerError, "Delivery product not found")
 	}
 
-	deliveryProductRepo := marketingRepo.NewMarketingDeliveryProductRepository(tx)
+	result, err := s.FifoSvc.Consume(ctx, commonSvc.StockConsumeRequest{
-	previousUsage := deliveryProduct.UsageQty
+		UsableKey:          fifo.UsableKeyMarketingDelivery,
-	deliveryProduct.UsageQty = requestedQty
+		UsableID:           deliveryProduct.Id,
-	deliveryProduct.PendingQty = 0
+		ProductWarehouseID: marketingProduct.ProductWarehouseId,
+		Quantity:           requestedQty,
+		AllowPending:       false,
+		Tx:                 tx,
+	})
 
-	if err := deliveryProductRepo.UpdateOne(ctx, deliveryProduct.Id, deliveryProduct, nil); err != nil {
+	if err != nil {
-		return fiber.NewError(fiber.StatusInternalServerError, "Failed to update delivery product")
-	}
-
-	if err := reflowMarketingScope(
-		ctx,
-		s.FifoStockV2Svc,
-		tx,
-		marketingProduct.ProductWarehouseId,
-		resolveMarketingAsOf(deliveryProduct.DeliveryDate, deliveryProduct.CreatedAt),
-	); err != nil {
 		return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Insufficient stock for product warehouse %d: %v", marketingProduct.ProductWarehouseId, err))
 	}
 
-	refreshed, err := deliveryProductRepo.GetByID(ctx, deliveryProduct.Id, nil)
+	deliveryProductRepo := marketingRepo.NewMarketingDeliveryProductRepository(tx)
-	if err != nil {
-		return fiber.NewError(fiber.StatusInternalServerError, "Failed to refresh delivery product")
-	}
-	deliveryProduct.UsageQty = refreshed.UsageQty
-	deliveryProduct.PendingQty = refreshed.PendingQty
-	deliveryProduct.CreatedAt = refreshed.CreatedAt
 
-	allocatedDelta := deliveryProduct.UsageQty - previousUsage
+	if err := deliveryProductRepo.UpdateFifoFields(ctx, deliveryProduct.Id, result.UsageQuantity, 0); err != nil {
-	if actorID > 0 && allocatedDelta > 0 {
+		return fiber.NewError(fiber.StatusInternalServerError, "Failed to update delivery product")
+	}
+
+	if actorID > 0 && result.UsageQuantity > 0 {
 		decreaseLog := &entity.StockLog{
-			Decrease:           allocatedDelta,
+			Decrease:           result.UsageQuantity,
 			LoggableType:       string(utils.StockLogTypeMarketing),
 			LoggableId:         deliveryProduct.Id,
 			ProductWarehouseId: marketingProduct.ProductWarehouseId,
 			CreatedBy:          actorID,
-			Notes:              fmt.Sprintf("FIFO v2 reflow consume (%.2f)", allocatedDelta),
+			Notes:              fmt.Sprintf("FIFO consume (%.2f)", result.UsageQuantity),
 		}
 
 		stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, marketingProduct.ProductWarehouseId, 1)
@@ -612,45 +539,35 @@ func (s deliveryOrdersService) releaseDeliveryStock(ctx context.Context, tx *gor
 	}
 
 	deliveryProductRepo := marketingRepo.NewMarketingDeliveryProductRepository(tx)
-	currentUsage := deliveryProduct.UsageQty
+	currentUsage, err := deliveryProductRepo.GetUsageQty(ctx, deliveryProduct.Id)
-	currentPending := deliveryProduct.PendingQty
+	if err != nil {
-	if currentUsage <= 0 && currentPending <= 0 {
+		currentUsage = 0
+	}
+
+	if currentUsage == 0 {
 		return nil
 	}
 
-	deliveryProduct.UsageQty = 0
+	if err := s.FifoSvc.ReleaseUsage(ctx, commonSvc.StockReleaseRequest{
-	deliveryProduct.PendingQty = 0
+		UsableKey: fifo.UsableKeyMarketingDelivery,
-	if err := deliveryProductRepo.UpdateOne(ctx, deliveryProduct.Id, deliveryProduct, nil); err != nil {
+		UsableID:  deliveryProduct.Id,
-		return fiber.NewError(fiber.StatusInternalServerError, "Failed to reset delivery product")
+		Tx:        tx,
+	}); err != nil {
+		return err
 	}
 
-	if err := reflowMarketingScope(
+	if err := deliveryProductRepo.ResetFifoFields(ctx, deliveryProduct.Id); err != nil {
-		ctx,
+		return err
-		s.FifoStockV2Svc,
-		tx,
-		marketingProduct.ProductWarehouseId,
-		resolveMarketingAsOf(deliveryProduct.DeliveryDate, deliveryProduct.CreatedAt),
-	); err != nil {
-		return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to reflow stock for product warehouse %d: %v", marketingProduct.ProductWarehouseId, err))
 	}
 
-	refreshed, err := deliveryProductRepo.GetByID(ctx, deliveryProduct.Id, nil)
+	if actorID > 0 && currentUsage > 0 {
-	if err != nil {
-		return fiber.NewError(fiber.StatusInternalServerError, "Failed to refresh delivery product")
-	}
-	deliveryProduct.UsageQty = refreshed.UsageQty
-	deliveryProduct.PendingQty = refreshed.PendingQty
-	deliveryProduct.CreatedAt = refreshed.CreatedAt
-
-	releasedUsage := currentUsage - deliveryProduct.UsageQty
-	if actorID > 0 && releasedUsage > 0 {
 		increaseLog := &entity.StockLog{
-			Increase:           releasedUsage,
+			Increase:           currentUsage,
 			LoggableType:       string(utils.StockLogTypeMarketing),
 			LoggableId:         deliveryProduct.Id,
 			ProductWarehouseId: marketingProduct.ProductWarehouseId,
 			CreatedBy:          actorID,
-			Notes:              fmt.Sprintf("FIFO v2 reflow release (%.2f)", releasedUsage),
+			Notes:              fmt.Sprintf("Release delivery stock (%.2f)", currentUsage),
 		}
 		stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, marketingProduct.ProductWarehouseId, 1)
 		if err != nil {

internal/modules/marketing/services/fifo_stock_v2_helper.go

@@ -1,97 +0,0 @@
-package service
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gorm.io/gorm"
-)
-
-const (
-	marketingOutFunctionCode = "MARKETING_OUT"
-	marketingUsableLane      = "USABLE"
-	marketingSourceTable     = "marketing_delivery_products"
-)
-
-func reflowMarketingScope(
-	ctx context.Context,
-	fifoStockV2Svc commonSvc.FifoStockV2Service,
-	tx *gorm.DB,
-	productWarehouseID uint,
-	asOf *time.Time,
-) error {
-	if fifoStockV2Svc == nil {
-		return fmt.Errorf("FIFO v2 service is not available")
-	}
-	if productWarehouseID == 0 {
-		return fmt.Errorf("product warehouse id is required")
-	}
-
-	flagGroupCode, err := resolveMarketingFlagGroupByProductWarehouse(ctx, tx, productWarehouseID)
-	if err != nil {
-		return err
-	}
-	if strings.TrimSpace(flagGroupCode) == "" {
-		return fmt.Errorf("flag group code is not found for product warehouse %d", productWarehouseID)
-	}
-
-	_, err = fifoStockV2Svc.Reflow(ctx, commonSvc.FifoStockV2ReflowRequest{
-		FlagGroupCode:      flagGroupCode,
-		ProductWarehouseID: productWarehouseID,
-		AsOf:               asOf,
-		Tx:                 tx,
-	})
-	return err
-}
-
-func resolveMarketingFlagGroupByProductWarehouse(ctx context.Context, tx *gorm.DB, productWarehouseID uint) (string, error) {
-	type row struct {
-		FlagGroupCode string `gorm:"column:flag_group_code"`
-	}
-
-	var selected row
-	err := tx.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules rr").
-		Select("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 = ?", marketingUsableLane).
-		Where("rr.function_code = ?", marketingOutFunctionCode).
-		Where("rr.source_table = ?", marketingSourceTable).
-		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.id ASC").
-		Limit(1).
-		Take(&selected).Error
-	if err != nil {
-		return "", err
-	}
-
-	return strings.TrimSpace(selected.FlagGroupCode), nil
-}
-
-func resolveMarketingAsOf(deliveryDate, createdAt *time.Time) *time.Time {
-	if deliveryDate != nil {
-		asOf := *deliveryDate
-		return &asOf
-	}
-	if createdAt != nil {
-		asOf := *createdAt
-		return &asOf
-	}
-	asOf := time.Now()
-	return &asOf
-}

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

@@ -20,6 +20,7 @@ import (
 	userRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
@@ -42,12 +43,12 @@ type salesOrdersService struct {
 	ProductWarehouseRepo    productWarehouseRepo.ProductWarehouseRepository
 	UserRepo                userRepo.UserRepository
 	ApprovalSvc             commonSvc.ApprovalService
-	FifoStockV2Svc          commonSvc.FifoStockV2Service
+	FifoSvc                 commonSvc.FifoService
 	WarehouseRepo           warehouseRepo.WarehouseRepository
 	ProjectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository
 }
 
-func NewSalesOrdersService(marketingRepo repository.MarketingRepository, customerRepo customerRepo.CustomerRepository, productWarehouseRepo productWarehouseRepo.ProductWarehouseRepository, userRepo userRepo.UserRepository, approvalSvc commonSvc.ApprovalService, fifoStockV2Svc commonSvc.FifoStockV2Service, warehouseRepo warehouseRepo.WarehouseRepository,
+func NewSalesOrdersService(marketingRepo repository.MarketingRepository, customerRepo customerRepo.CustomerRepository, productWarehouseRepo productWarehouseRepo.ProductWarehouseRepository, userRepo userRepo.UserRepository, approvalSvc commonSvc.ApprovalService, fifoSvc commonSvc.FifoService, warehouseRepo warehouseRepo.WarehouseRepository,
 	projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository, validate *validator.Validate) SalesOrdersService {
 	return &salesOrdersService{
 		Log:                     utils.Log,
@@ -57,7 +58,7 @@ func NewSalesOrdersService(marketingRepo repository.MarketingRepository, custome
 		ProductWarehouseRepo:    productWarehouseRepo,
 		UserRepo:                userRepo,
 		ApprovalSvc:             approvalSvc,
-		FifoStockV2Svc:          fifoStockV2Svc,
+		FifoSvc:                 fifoSvc,
 		WarehouseRepo:           warehouseRepo,
 		ProjectFlockKandangRepo: projectFlockKandangRepo,
 	}
@@ -375,18 +376,15 @@ func (s salesOrdersService) UpdateOne(c *fiber.Ctx, req *validation.Update, id u
 						if qtyDiff < 0 {
 							return fiber.NewError(fiber.StatusBadRequest, "Cannot decrease quantity after stock has been allocated. Please delete and create new product.")
 						} else if qtyDiff > 0 {
-							nextRequestedQty := deliveryProduct.UsageQty + deliveryProduct.PendingQty + qtyDiff
+							_, err := s.FifoSvc.Consume(c.Context(), commonSvc.StockConsumeRequest{
-							if err := invDeliveryRepoTx.UpdateFifoFields(c.Context(), deliveryProduct.Id, nextRequestedQty, 0); err != nil {
+								UsableKey:          fifo.UsableKeyMarketingDelivery,
-								return fiber.NewError(fiber.StatusInternalServerError, "Failed to update marketing delivery fifo fields")
+								UsableID:           deliveryProduct.Id,
-							}
+								ProductWarehouseID: rp.ProductWarehouseId,
-							if err := reflowMarketingScope(
+								Quantity:           qtyDiff,
-								c.Context(),
+								Tx:                 dbTransaction,
-								s.FifoStockV2Svc,
+							})
-								dbTransaction,
+							if err != nil {
-								rp.ProductWarehouseId,
+								return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Insufficient stock for additional quantity: %v", err))
-								resolveMarketingAsOf(deliveryProduct.DeliveryDate, deliveryProduct.CreatedAt),
-							); err != nil {
-								return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to reflow stock via FIFO v2: %v", err))
 							}
 						}
 					}
@@ -441,17 +439,12 @@ func (s salesOrdersService) UpdateOne(c *fiber.Ctx, req *validation.Update, id u
 							return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Cannot delete marketing product %d because it has been delivered", old.Id))
 						}
 
-						if err := invDeliveryRepoTx.UpdateFifoFields(c.Context(), deliveryProduct.Id, 0, 0); err != nil {
+						if err := s.FifoSvc.ReleaseUsage(c.Context(), commonSvc.StockReleaseRequest{
-							return fiber.NewError(fiber.StatusInternalServerError, "Failed to reset marketing delivery fifo fields")
+							UsableKey: fifo.UsableKeyMarketingDelivery,
-						}
+							UsableID:  deliveryProduct.Id,
-						if err := reflowMarketingScope(
+							Tx:        dbTransaction,
-							c.Context(),
+						}); err != nil {
-							s.FifoStockV2Svc,
+							return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to release stock: %v", err))
-							dbTransaction,
-							deliveryProduct.ProductWarehouseId,
-							resolveMarketingAsOf(deliveryProduct.DeliveryDate, deliveryProduct.CreatedAt),
-						); err != nil {
-							return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to reflow stock via FIFO v2: %v", err))
 						}
 
 						if err := invDeliveryRepoTx.DeleteOne(c.Context(), deliveryProduct.Id); err != nil {
@@ -530,17 +523,12 @@ func (s salesOrdersService) DeleteOne(c *fiber.Ctx, id uint) error {
 			deliveryProducts, err := marketingDeliveryProductRepoTx.GetByMarketingId(c.Context(), marketing.Id)
 			if err == nil && len(deliveryProducts) > 0 {
 				for _, dp := range deliveryProducts {
-					if err := marketingDeliveryProductRepoTx.UpdateFifoFields(c.Context(), dp.Id, 0, 0); err != nil {
+					if err := s.FifoSvc.ReleaseUsage(c.Context(), commonSvc.StockReleaseRequest{
-						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to reset fifo fields for delivery product %d", dp.Id))
+						UsableKey: fifo.UsableKeyMarketingDelivery,
-					}
+						UsableID:  dp.Id,
-					if err := reflowMarketingScope(
+						Tx:        dbTransaction,
-						c.Context(),
+					}); err != nil {
-						s.FifoStockV2Svc,
+						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to release stock for delivery product %d: %v", dp.Id, err))
-						dbTransaction,
-						dp.ProductWarehouseId,
-						resolveMarketingAsOf(dp.DeliveryDate, dp.CreatedAt),
-					); err != nil {
-						return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to reflow stock via FIFO v2 for delivery product %d: %v", dp.Id, err))
 					}
 				}
 			}

internal/modules/marketing/validations/deliveryorder.validation.go

@@ -21,10 +21,6 @@ type DeliveryOrderUpdate struct {
 type DeliveryOrderQuery struct {
 	Page        int  `query:"page" validate:"omitempty,number,min=1,gt=0"`
 	Limit       int  `query:"limit" validate:"omitempty,number,min=1,max=100,gt=0"`
-	Search      string `query:"search" validate:"omitempty,max=100"`
-	ProductIDs  []uint `query:"product_ids" validate:"omitempty,dive,gt=0"`
-	Status      string `query:"status" validate:"omitempty,max=50"`
-	CustomerId  uint   `query:"customer_id" validate:"omitempty,gt=0"`
 	MarketingId uint `query:"marketing_id" validate:"omitempty,gt=0"`
 }
 

internal/modules/master/product-categories/services/product-category.service.go

@@ -52,22 +52,7 @@ func (s productCategoryService) GetAll(c *fiber.Ctx, params *validation.Query) (
 	productCategories, total, err := s.Repository.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
 		db = s.withRelations(db)
 		if params.Search != "" {
-			terms := splitSearchTerms(params.Search)
+			return db.Where("name ILIKE ?", "%"+params.Search+"%")
-			if len(terms) == 0 {
-				return db
-			}
-			if len(terms) == 1 {
-				return db.Where("name ILIKE ?", "%"+terms[0]+"%")
-			}
-			for i, term := range terms {
-				like := "%" + term + "%"
-				if i == 0 {
-					db = db.Where("name ILIKE ?", like)
-				} else {
-					db = db.Or("name ILIKE ?", like)
-				}
-			}
-			return db
 		}
 		return db.Order("created_at DESC").Order("updated_at DESC")
 	})
@@ -79,20 +64,6 @@ func (s productCategoryService) GetAll(c *fiber.Ctx, params *validation.Query) (
 	return productCategories, total, nil
 }
 
-func splitSearchTerms(raw string) []string {
-	parts := strings.FieldsFunc(raw, func(r rune) bool {
-		return r == ',' || r == ';' || r == '|'
-	})
-	terms := make([]string, 0, len(parts))
-	for _, part := range parts {
-		trimmed := strings.TrimSpace(part)
-		if trimmed != "" {
-			terms = append(terms, trimmed)
-		}
-	}
-	return terms
-}
-
 func (s productCategoryService) GetOne(c *fiber.Ctx, id uint) (*entity.ProductCategory, error) {
 	productCategory, err := s.Repository.GetByID(c.Context(), id, s.withRelations)
 	if errors.Is(err, gorm.ErrRecordNotFound) {

internal/modules/production/chickins/module.go

@@ -2,6 +2,7 @@ package chickins
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
@@ -9,6 +10,7 @@ import (
 
 	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 
 	rProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
 	rKandang "gitlab.com/mbugroup/lti-api.git/internal/modules/master/kandangs/repositories"
@@ -38,9 +40,45 @@ func (ChickinModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 	projectFlockRepo := rProjectFlock.NewProjectflockRepository(db)
 	productWarehouseRepo := rProductWarehouse.NewProductWarehouseRepository(db)
 	productRepo := rProduct.NewProductRepository(db)
-	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
+	stockAllocationRepo := commonRepo.NewStockAllocationRepository(db)
+	fifoService := commonSvc.NewFifoService(db, stockAllocationRepo, productWarehouseRepo, utils.Log)
 	userRepo := rUser.NewUserRepository(db)
 
+	if err := fifoService.RegisterUsable(fifo.UsableConfig{
+		Key:   fifo.UsableKeyProjectChickin,
+		Table: "project_chickins",
+		Columns: fifo.UsableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			UsageQuantity:      "usage_qty",
+			PendingQuantity:    "pending_usage_qty",
+			CreatedAt:          "created_at",
+		},
+
+		ExcludedStockables: []fifo.StockableKey{fifo.StockableKeyProjectFlockPopulation},
+	}); err != nil {
+		if !strings.Contains(strings.ToLower(err.Error()), "already registered") {
+			panic(fmt.Sprintf("failed to register chickin usable workflow: %v", err))
+		}
+	}
+
+	if err := fifoService.RegisterStockable(fifo.StockableConfig{
+		Key:   fifo.StockableKeyProjectFlockPopulation,
+		Table: "project_flock_populations",
+		Columns: fifo.StockableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			TotalQuantity:      "total_qty",
+			TotalUsedQuantity:  "total_used_qty",
+			CreatedAt:          "created_at",
+		},
+		OrderBy: []string{"created_at ASC", "id ASC"},
+	}); err != nil {
+		if !strings.Contains(strings.ToLower(err.Error()), "already registered") {
+			panic(fmt.Sprintf("failed to register project flock population stockable workflow: %v", err))
+		}
+	}
+
 	approvalRepo := commonRepo.NewApprovalRepository(db)
 	approvalService := commonSvc.NewApprovalService(approvalRepo)
 	if err := approvalService.RegisterWorkflowSteps(utils.ApprovalWorkflowChickin, utils.ChickinApprovalSteps); err != nil {
@@ -58,7 +96,7 @@ func (ChickinModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 		projectflockpopulationrepo,
 		chickinDetailRepo,
 		validate,
-		fifoStockV2Service)
+		fifoService)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	ChickinRoutes(router, userService, chickinService)

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

@@ -4,9 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"math"
 	"strings"
-	"time"
 
 	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
@@ -29,6 +27,8 @@ import (
 	"gorm.io/gorm"
 )
 
+var chickinUsableKey = fifo.UsableKeyProjectChickin
+
 type ChickinService interface {
 	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.ProjectChickin, int64, error)
 	GetOne(ctx *fiber.Ctx, id uint) (*entity.ProjectChickin, error)
@@ -36,7 +36,6 @@ type ChickinService interface {
 	UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.ProjectChickin, error)
 	DeleteOne(ctx *fiber.Ctx, id uint) error
 	Approval(ctx *fiber.Ctx, req *validation.Approve) ([]entity.ProjectChickin, error)
-	EnsureChickInExists(ctx context.Context, projectFlockKandangID uint) error
 }
 
 type chickinService struct {
@@ -51,11 +50,11 @@ type chickinService struct {
 	ProjectflockKandangRepo    rProjectFlock.ProjectFlockKandangRepository
 	ProjectflockPopulationRepo rProjectFlock.ProjectFlockPopulationRepository
 	ProjectChickinDetailRepo   repository.ProjectChickinDetailRepository
-	FifoStockV2Svc             commonSvc.FifoStockV2Service
+	FifoSvc                    commonSvc.FifoService
 	StockLogRepo               rStockLogs.StockLogRepository
 }
 
-func NewChickinService(repo repository.ProjectChickinRepository, kandangRepo KandangRepo.KandangRepository, warehouseRepo rWarehouse.WarehouseRepository, productWarehouseRepo rProductWarehouse.ProductWarehouseRepository, productRepo rProduct.ProductRepository, projectFlockRepo rProjectFlock.ProjectflockRepository, projectflockkandangRepo rProjectFlock.ProjectFlockKandangRepository, projectflockpopulationRepo rProjectFlock.ProjectFlockPopulationRepository, projectChickinDetailRepo repository.ProjectChickinDetailRepository, validate *validator.Validate, fifoStockV2Svc commonSvc.FifoStockV2Service) ChickinService {
+func NewChickinService(repo repository.ProjectChickinRepository, kandangRepo KandangRepo.KandangRepository, warehouseRepo rWarehouse.WarehouseRepository, productWarehouseRepo rProductWarehouse.ProductWarehouseRepository, productRepo rProduct.ProductRepository, projectFlockRepo rProjectFlock.ProjectflockRepository, projectflockkandangRepo rProjectFlock.ProjectFlockKandangRepository, projectflockpopulationRepo rProjectFlock.ProjectFlockPopulationRepository, projectChickinDetailRepo repository.ProjectChickinDetailRepository, validate *validator.Validate, fifoSvc commonSvc.FifoService) ChickinService {
 	return &chickinService{
 		Log:                        utils.Log,
 		Validate:                   validate,
@@ -68,7 +67,7 @@ func NewChickinService(repo repository.ProjectChickinRepository, kandangRepo Kan
 		ProjectflockKandangRepo:    projectflockkandangRepo,
 		ProjectflockPopulationRepo: projectflockpopulationRepo,
 		ProjectChickinDetailRepo:   projectChickinDetailRepo,
-		FifoStockV2Svc:             fifoStockV2Svc,
+		FifoSvc:                    fifoSvc,
 		StockLogRepo:               rStockLogs.NewStockLogRepository(repo.DB()),
 	}
 }
@@ -260,7 +259,7 @@ func (s *chickinService) CreateOne(c *fiber.Ctx, req *validation.Create) ([]enti
 
 		for idx, chickin := range newChikins {
 			desiredQty := chickinQtyMap[uint(idx)]
-			if err := s.StageChickinStocks(c.Context(), dbTransaction, chickin, desiredQty, actorID); err != nil {
+			if err := s.ConsumeChickinStocks(c.Context(), dbTransaction, chickin, desiredQty, actorID); err != nil {
 				return err
 			}
 		}
@@ -353,18 +352,7 @@ func (s chickinService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
 		return nil, err
 	}
 
-	updated, err := s.GetOne(c, id)
+	return s.GetOne(c, id)
-	if err != nil {
-		return nil, err
-	}
-
-	if updated.UsageQty > 0 {
-		if err := s.syncChickinTraceForProductWarehouse(c.Context(), nil, updated.ProductWarehouseId); err != nil {
-			return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to sync chickin stock trace")
-		}
-	}
-
-	return updated, nil
 }
 
 func (s chickinService) DeleteOne(c *fiber.Ctx, id uint) error {
@@ -382,35 +370,28 @@ func (s chickinService) DeleteOne(c *fiber.Ctx, id uint) error {
 		return err
 	}
 
-	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
+	if chickin.UsageQty > 0 {
-		chickinRepoTx := repository.NewChickinRepository(tx)
 
-		if chickin.UsageQty > 0 || chickin.PendingUsageQty > 0 {
+		currentUsageQty := chickin.UsageQty
-			if err := s.ReleaseChickinStocks(c.Context(), tx, chickin, actorID); err != nil {
+
+		if err := s.ReleaseChickinStocks(c.Context(), s.Repository.DB(), chickin, actorID); err != nil {
+			return err
+		}
+
+		warehouseDeltas := make(map[uint]float64)
+		warehouseDeltas[chickin.ProductWarehouseId] += currentUsageQty
+		if err := s.adjustProductWarehouseQuantities(c.Context(), s.Repository.DB(), warehouseDeltas); err != nil {
 			return err
 		}
 	}
 
-		if err := chickinRepoTx.DeleteOne(c.Context(), id); err != nil {
+	if err := s.Repository.DeleteOne(c.Context(), id); err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return fiber.NewError(fiber.StatusNotFound, "Chickin not found")
 		}
 		return err
 	}
 
-		if err := s.syncChickinTraceForProductWarehouse(c.Context(), tx, chickin.ProductWarehouseId); err != nil {
-			return err
-		}
-
-		return nil
-	})
-	if err != nil {
-		if fiberErr, ok := err.(*fiber.Error); ok {
-			return fiberErr
-		}
-		return err
-	}
-
 	return nil
 }
 
@@ -469,7 +450,6 @@ func (s chickinService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entit
 		approvalSvc := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
 		chickinRepoTx := repository.NewChickinRepository(dbTransaction)
 		ProjectFlockPopulationRepotx := s.ProjectflockPopulationRepo.WithTx(dbTransaction)
-		touchedProductWarehouseIDs := make(map[uint]struct{})
 
 		for _, approvableID := range approvableIDs {
 			if _, err := approvalSvc.CreateApproval(
@@ -510,21 +490,6 @@ func (s chickinService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entit
 				}
 
 				for _, chickin := range chickins {
-					approvedQty := chickin.UsageQty
-					if approvedQty <= 0 {
-						approvedQty = chickin.PendingUsageQty
-					}
-					if approvedQty < 0 {
-						approvedQty = 0
-					}
-
-					if err := s.ConsumeChickinStocks(c.Context(), dbTransaction, &chickin, approvedQty, actorID); err != nil {
-						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to finalize usage qty for chickin %d", chickin.Id))
-					}
-					chickin.UsageQty = approvedQty
-					chickin.PendingUsageQty = 0
-					touchedProductWarehouseIDs[chickin.ProductWarehouseId] = struct{}{}
-
 					populationExists, err := ProjectFlockPopulationRepotx.ExistsByProjectChickinID(c.Context(), chickin.Id)
 					if err != nil {
 						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to check population for chickin %d", chickin.Id))
@@ -556,13 +521,19 @@ func (s chickinService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entit
 						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to create population for chickin %d", chickin.Id))
 					}
 
+					if err := chickinRepoTx.PatchOne(c.Context(), chickin.Id, map[string]any{
+						"pending_usage_qty": 0,
+					}, nil); err != nil {
+						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to reset pending usage qty for chickin %d", chickin.Id))
+					}
+
 					if err := s.ReplenishChickinStocks(c.Context(), dbTransaction, &chickin, sourcePW, population, actorID); err != nil {
 						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to replenish stock for chickin %d", chickin.Id))
 					}
 				}
 			}
 			if action == entity.ApprovalActionRejected {
-				chickins, err := chickinRepoTx.GetByProjectFlockKandangID(c.Context(), approvableID)
+				chickins, err := chickinRepoTx.GetPendingByProjectFlockKandangID(c.Context(), approvableID)
 				if err != nil {
 					return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to get pending chickins for rejection %d", approvableID))
 				}
@@ -572,22 +543,16 @@ func (s chickinService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entit
 				}
 
 				for _, chickin := range chickins {
-					populationExists, err := ProjectFlockPopulationRepotx.ExistsByProjectChickinID(c.Context(), chickin.Id)
-					if err != nil {
-						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to check population for chickin %d", chickin.Id))
-					}
-					if populationExists {
-						continue
-					}
-
-					if chickin.UsageQty <= 0 && chickin.PendingUsageQty <= 0 {
-						continue
-					}
 
 					if err := s.ReleaseChickinStocks(c.Context(), dbTransaction, &chickin, actorID); err != nil {
 						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to release stock for rejected chickin %d: %v", chickin.Id, err))
 					}
-					touchedProductWarehouseIDs[chickin.ProductWarehouseId] = struct{}{}
+
+					warehouseDeltas := make(map[uint]float64)
+					warehouseDeltas[chickin.ProductWarehouseId] += chickin.UsageQty
+					if err := s.adjustProductWarehouseQuantities(c.Context(), dbTransaction, warehouseDeltas); err != nil {
+						return err
+					}
 
 					if err := chickinRepoTx.DeleteOne(c.Context(), chickin.Id); err != nil {
 						if !errors.Is(err, gorm.ErrRecordNotFound) {
@@ -597,13 +562,6 @@ func (s chickinService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entit
 				}
 			}
 		}
-
-		for productWarehouseID := range touchedProductWarehouseIDs {
-			if err := s.syncChickinTraceForProductWarehouse(c.Context(), dbTransaction, productWarehouseID); err != nil {
-				return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to sync chickin trace for product warehouse %d", productWarehouseID))
-			}
-		}
-
 		return nil
 	})
 
@@ -658,45 +616,66 @@ func (s *chickinService) autoAddFlagToProduct(ctx context.Context, tx *gorm.DB,
 }
 
 func (s *chickinService) ConsumeChickinStocks(ctx context.Context, tx *gorm.DB, chickin *entity.ProjectChickin, desiredQty float64, actorID uint) error {
-	if chickin == nil {
+	if chickin == nil || s.FifoSvc == nil {
 		return nil
 	}
-	if tx == nil {
+
-		return errors.New("transaction is required")
+	result, err := s.FifoSvc.Consume(ctx, commonSvc.StockConsumeRequest{
-	}
+		UsableKey:          chickinUsableKey,
-	if desiredQty < 0 {
+		UsableID:           chickin.Id,
-		return errors.New("desired quantity must be zero or greater")
+		ProductWarehouseID: chickin.ProductWarehouseId,
+		Quantity:           desiredQty,
+		AllowPending:       true,
+		Tx:                 tx,
+	})
+	if err != nil {
+		return err
 	}
 
-	return s.Repository.UpdateUsageFields(ctx, tx, chickin.Id, desiredQty, 0)
+	if err := s.Repository.UpdateUsageFields(ctx, tx, chickin.Id, result.UsageQuantity, result.PendingQuantity); err != nil {
-}
+		return err
+	}
+
+	if result.UsageQuantity > 0 {
+		decreaseLog := &entity.StockLog{
+			Decrease:           result.UsageQuantity,
+			LoggableType:       string(utils.StockLogTypeChikin),
+			LoggableId:         chickin.Id,
+			ProductWarehouseId: chickin.ProductWarehouseId,
+			CreatedBy:          actorID,
+			Notes:              fmt.Sprintf("Chickin #%d", chickin.Id),
+		}
+		stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, chickin.ProductWarehouseId, 1)
+		if err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
+		}
+		if len(stockLogs) > 0 {
+			latestStockLog := stockLogs[0]
+			decreaseLog.Stock = latestStockLog.Stock
+			decreaseLog.Stock -= decreaseLog.Decrease
+		} else {
+			decreaseLog.Stock -= decreaseLog.Decrease
+		}
+
+		s.StockLogRepo.CreateOne(ctx, decreaseLog, nil)
+	}
 
-func (s *chickinService) StageChickinStocks(ctx context.Context, tx *gorm.DB, chickin *entity.ProjectChickin, desiredQty float64, actorID uint) error {
-	if chickin == nil {
 	return nil
-	}
-	if tx == nil {
-		return errors.New("transaction is required")
-	}
-	if desiredQty < 0 {
-		return errors.New("desired quantity must be zero or greater")
-	}
-
-	return s.Repository.UpdateUsageFields(ctx, tx, chickin.Id, 0, desiredQty)
 }
 
 func (s *chickinService) ReplenishChickinStocks(ctx context.Context, tx *gorm.DB, chickin *entity.ProjectChickin, targetPW *entity.ProductWarehouse, population *entity.ProjectFlockPopulation, actorID uint) error {
-	if chickin == nil || targetPW == nil || population == nil {
+	if chickin == nil || targetPW == nil || population == nil || s.FifoSvc == nil {
 		return nil
 	}
-	if tx == nil {
-		return errors.New("transaction is required")
-	}
 
-	if err := tx.WithContext(ctx).
+	_, err := s.FifoSvc.Replenish(ctx, commonSvc.StockReplenishRequest{
-		Model(&entity.ProjectFlockPopulation{}).
+		StockableKey:       fifo.StockableKeyProjectFlockPopulation,
-		Where("id = ?", population.Id).
+		StockableID:        population.Id,
-		Update("total_qty", chickin.UsageQty).Error; err != nil {
+		ProductWarehouseID: targetPW.Id,
+		Quantity:           chickin.UsageQty,
+		Tx:                 tx,
+	})
+	if err != nil {
 		return err
 	}
 
@@ -704,214 +683,57 @@ func (s *chickinService) ReplenishChickinStocks(ctx context.Context, tx *gorm.DB
 }
 
 func (s *chickinService) ReleaseChickinStocks(ctx context.Context, tx *gorm.DB, chickin *entity.ProjectChickin, actorID uint) error {
-	if chickin == nil {
+	if chickin == nil || s.FifoSvc == nil {
 		return nil
 	}
-	if tx == nil {
+
-		return errors.New("transaction is required")
+	var currentUsage float64
+	if err := tx.Model(&entity.ProjectChickin{}).Where("id = ?", chickin.Id).Select("usage_qty").Scan(&currentUsage).Error; err != nil {
+
+	}
+
+	if err := s.FifoSvc.ReleaseUsage(ctx, commonSvc.StockReleaseRequest{
+		UsableKey: chickinUsableKey,
+		UsableID:  chickin.Id,
+		Tx:        tx,
+	}); err != nil {
+		return err
 	}
 
 	if err := s.Repository.UpdateUsageFields(ctx, tx, chickin.Id, 0, 0); err != nil {
 		return err
 	}
 
-	return nil
+	if currentUsage > 0 {
-}
+		increaseLog := &entity.StockLog{
-
+			Increase:           currentUsage,
-func (s *chickinService) syncChickinTraceForProductWarehouse(ctx context.Context, tx *gorm.DB, productWarehouseID uint) error {
+			LoggableType:       string(utils.StockLogTypeChikin),
-	if productWarehouseID == 0 {
+			LoggableId:         chickin.Id,
-		return nil
+			ProductWarehouseId: chickin.ProductWarehouseId,
+			CreatedBy:          actorID,
+			Notes:              fmt.Sprintf("Chickin #%d - Stock released", chickin.Id),
 		}
-	if s.FifoStockV2Svc == nil {
+		stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, chickin.ProductWarehouseId, 1)
-		return nil
-	}
-
-	if tx == nil {
-		return s.Repository.DB().WithContext(ctx).Transaction(func(innerTx *gorm.DB) error {
-			return s.syncChickinTraceForProductWarehouse(ctx, innerTx, productWarehouseID)
-		})
-	}
-
-	flagGroupCode, err := s.resolveFlagGroupByProductWarehouse(ctx, tx, productWarehouseID)
 		if err != nil {
-		return err
+			return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
 		}
-	if strings.TrimSpace(flagGroupCode) == "" {
+		if len(stockLogs) > 0 {
-		return nil
+			latestStockLog := stockLogs[0]
+			increaseLog.Stock = latestStockLog.Stock
+			increaseLog.Stock += increaseLog.Increase
+		} else {
+			increaseLog.Stock += increaseLog.Increase
 		}
 
-	now := time.Now()
+		s.StockLogRepo.CreateOne(ctx, increaseLog, nil)
-	if err := 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": now,
-			"updated_at":  now,
-			"note":        "chickin_trace_reflow_reset",
-		}).Error; err != nil {
-		return err
-	}
-
-	type chickinTraceRow struct {
-		ID       uint      `gorm:"column:id"`
-		UsageQty float64   `gorm:"column:usage_qty"`
-		ChickIn  time.Time `gorm:"column:chick_in_date"`
-	}
-	chickins := make([]chickinTraceRow, 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 := s.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
-	}
-
-	lotIndex := 0
-	traceNow := time.Now()
-	for _, chickin := range chickins {
-		remaining := chickin.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":            chickin.ID,
-				"qty":                  portion,
-				"status":               entity.StockAllocationStatusActive,
-				"allocation_purpose":   entity.StockAllocationPurposeTraceChickin,
-				"engine_version":       "v2",
-				"flag_group_code":      flagGroupCode,
-				"function_code":        "CHICKIN_TRACE",
-				"created_at":           traceNow,
-				"updated_at":           traceNow,
-			}
-			if err := tx.WithContext(ctx).Table("stock_allocations").Create(insert).Error; err != nil {
-				return err
-			}
-
-			remaining -= portion
-			remainingByLot[key] = available - portion
-		}
-
-		if remaining > 1e-6 {
-			s.Log.Warnf(
-				"chickin trace partial allocation for product_warehouse_id=%d chickin_id=%d: remaining=%.3f",
-				productWarehouseID,
-				chickin.ID,
-				remaining,
-			)
-		}
 	}
 
 	return nil
 }
 
-func (s *chickinService) resolveFlagGroupByProductWarehouse(ctx context.Context, tx *gorm.DB, productWarehouseID uint) (string, error) {
+func (s *chickinService) adjustProductWarehouseQuantities(ctx context.Context, tx *gorm.DB, deltas map[uint]float64) error {
-	type row struct {
+	if len(deltas) == 0 {
-		FlagGroupCode string `gorm:"column:flag_group_code"`
-	}
-
-	selected := row{}
-	err := tx.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules rr").
-		Select("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 = 'STOCKABLE'").
-		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("fg.priority ASC, rr.id ASC").
-		Limit(1).
-		Take(&selected).Error
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return "", nil
-		}
-		return "", err
-	}
-	return selected.FlagGroupCode, nil
-}
-
-func (s chickinService) EnsureChickInExists(ctx context.Context, projectFlockKandangID uint) error {
-	if projectFlockKandangID == 0 {
-		return fiber.NewError(fiber.StatusBadRequest, "Project flock kandang tidak valid")
-	}
-
-	populations, err := s.ProjectflockPopulationRepo.GetByProjectFlockKandangID(ctx, projectFlockKandangID)
-	if err != nil {
-		s.Log.Errorf("Failed to check project flock population for project_flock_kandang_id=%d: %+v", projectFlockKandangID, err)
-		return fiber.NewError(fiber.StatusInternalServerError, "Gagal memeriksa data chick in")
-	}
-
-	if len(populations) == 0 {
-		return fiber.NewError(fiber.StatusBadRequest, "Project flock belum memiliki chick in yang disetujui sehingga belum dapat membuat recording")
-	}
-
-	for _, population := range populations {
-		if population.TotalQty > 0 {
 		return nil
 	}
-	}
+	return s.ProductWarehouseRepo.AdjustQuantities(ctx, deltas, func(*gorm.DB) *gorm.DB { return tx })
-
-	return fiber.NewError(fiber.StatusBadRequest, "Chick in project flock belum disetujui sehingga belum dapat membuat recording")
 }

internal/modules/production/project_flocks/repositories/projectflock_kandang.repository.go

@@ -13,7 +13,6 @@ import (
 
 type ProjectFlockKandangRepository interface {
 	GetByID(ctx context.Context, id uint) (*entity.ProjectFlockKandang, error)
-	GetByIDLight(ctx context.Context, id uint) (*entity.ProjectFlockKandang, error)
 	GetByProjectFlockAndKandang(ctx context.Context, projectFlockID uint, kandangID uint) (*entity.ProjectFlockKandang, error)
 	GetActiveByKandangID(ctx context.Context, kandangID uint) (*entity.ProjectFlockKandang, error)
 	UpdateClosedAt(ctx context.Context, id uint, t *time.Time) error
@@ -343,17 +342,6 @@ func (r *projectFlockKandangRepositoryImpl) GetByID(ctx context.Context, id uint
 	return record, nil
 }
 
-// GetByIDLight loads only the minimal relations needed for recording flows.
-func (r *projectFlockKandangRepositoryImpl) GetByIDLight(ctx context.Context, id uint) (*entity.ProjectFlockKandang, error) {
-	record := new(entity.ProjectFlockKandang)
-	if err := r.db.WithContext(ctx).
-		Preload("ProjectFlock").
-		First(record, id).Error; err != nil {
-		return nil, err
-	}
-	return record, nil
-}
-
 func (r *projectFlockKandangRepositoryImpl) GetByProjectFlockAndKandang(ctx context.Context, projectFlockID uint, kandangID uint) (*entity.ProjectFlockKandang, error) {
 	record := new(entity.ProjectFlockKandang)
 	if err := r.db.WithContext(ctx).

internal/modules/production/project_flocks/services/projectflock.service.go

@@ -48,7 +48,6 @@ type ProjectflockService interface {
 	GetProjectPeriods(ctx *fiber.Ctx, projectIDs []uint) (map[uint]int, error)
 	Approval(ctx *fiber.Ctx, req *validation.Approve) ([]entity.ProjectFlock, error)
 	Resubmit(ctx *fiber.Ctx, req *validation.Resubmit, id uint) (*entity.ProjectFlock, error)
-	EnsureProjectFlockApproved(ctx context.Context, projectFlockID uint) error
 }
 
 type projectflockService struct {
@@ -113,32 +112,6 @@ func (s projectflockService) approvalQueryModifier() func(*gorm.DB) *gorm.DB {
 	}
 }
 
-func (s projectflockService) EnsureProjectFlockApproved(ctx context.Context, projectFlockID uint) error {
-	if projectFlockID == 0 {
-		return fiber.NewError(fiber.StatusBadRequest, "Project flock kandang tidak valid")
-	}
-
-	approvalSvc := s.ApprovalSvc
-	if approvalSvc == nil {
-		approvalSvc = commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(s.Repository.DB()))
-	}
-
-	latest, err := approvalSvc.LatestByTarget(ctx, s.approvalWorkflow, projectFlockID, nil)
-	if err != nil {
-		s.Log.Errorf("Failed to check project flock %d approval status: %+v", projectFlockID, err)
-		return fiber.NewError(fiber.StatusInternalServerError, "Gagal memeriksa status project flock")
-	}
-
-	if latest == nil {
-		return fiber.NewError(fiber.StatusBadRequest, "Project flock masih dalam status pengajuan sehingga belum dapat membuat recording")
-	}
-	if latest.StepNumber != uint16(utils.ProjectFlockStepAktif) || latest.Action == nil || *latest.Action != entity.ApprovalActionApproved {
-		return fiber.NewError(fiber.StatusBadRequest, "Project flock masih dalam status pengajuan sehingga belum dapat membuat recording")
-	}
-
-	return nil
-}
-
 func (s projectflockService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.ProjectFlock, int64, map[uint]*flockDTO.FlockRelationDTO, error) {
 	if err := s.Validate.Struct(params); err != nil {
 		return nil, 0, nil, err
@@ -486,15 +459,6 @@ func (s projectflockService) GetProjectFlockKandangPopulation(ctx *fiber.Ctx, pr
 		return 0, fiber.NewError(fiber.StatusBadRequest, "project_flock_kandang_id is required")
 	}
 
-	total, err := s.PopulationRepo.GetAvailableQtyByProjectFlockKandangID(ctx.Context(), projectFlockKandangID)
-	if err != nil {
-		s.Log.Errorf("Failed to fetch project flock kandang population %d: %+v", projectFlockKandangID, err)
-		return 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch project flock kandang population")
-	}
-	if total > 0 {
-		return total, nil
-	}
-
 	if s.RecordingRepo != nil {
 		latest, err := s.RecordingRepo.GetLatestByProjectFlockKandangID(ctx.Context(), projectFlockKandangID)
 		if err != nil {
@@ -506,6 +470,12 @@ func (s projectflockService) GetProjectFlockKandangPopulation(ctx *fiber.Ctx, pr
 		}
 	}
 
+	total, err := s.PopulationRepo.GetAvailableQtyByProjectFlockKandangID(ctx.Context(), projectFlockKandangID)
+	if err != nil {
+		s.Log.Errorf("Failed to fetch project flock kandang population %d: %+v", projectFlockKandangID, err)
+		return 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch project flock kandang population")
+	}
+
 	return total, nil
 }
 
@@ -580,22 +550,21 @@ func (s projectflockService) GetProjectFlockKandangByParams(ctx *fiber.Ctx, idSt
 }
 
 func (s projectflockService) GetAvailableDocQuantity(ctx *fiber.Ctx, kandangID uint) (float64, error) {
-	if s.PopulationRepo == nil {
-		return 0, fiber.NewError(fiber.StatusInternalServerError, "Project flock population repository is not configured")
-	}
 
-	pfk, err := s.PivotRepo.GetActiveByKandangID(ctx.Context(), kandangID)
+	wh, err := s.WarehouseRepo.GetByKandangID(ctx.Context(), kandangID)
 	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return 0, fiber.NewError(fiber.StatusNotFound, "ProjectFlockKandang not found")
-		}
 		return 0, err
 	}
 
-	total, err := s.PopulationRepo.GetAvailableQtyByProjectFlockKandangID(ctx.Context(), pfk.Id)
+	productWarehouses, err := s.ProductWarehouseRepo.GetByCategoryCodeAndWarehouseID(ctx.Context(), "DOC", wh.Id)
 	if err != nil {
 		return 0, err
 	}
+
+	total := 0.0
+	for _, pw := range productWarehouses {
+		total += pw.Quantity
+	}
 	return total, nil
 }
 

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

@@ -27,14 +27,9 @@ func NewRecordingController(recordingService service.RecordingService) *Recordin
 func (u *RecordingController) GetAll(c *fiber.Ctx) error {
 	projectFlockID := c.QueryInt("project_flock_kandang_id", 0)
 
-	page := c.QueryInt("page", 1)
-	limit := c.QueryInt("limit", 10)
-	offset := (page - 1) * limit
-
 	query := &validation.Query{
-		Page:   page,
+		Page:   c.QueryInt("page", 1),
-		Limit:  limit,
+		Limit:  c.QueryInt("limit", 10),
-		Offset: offset,
 		Search: c.Query("search"),
 	}
 	if projectFlockID > 0 {
@@ -84,27 +79,25 @@ func (u *RecordingController) GetOne(c *fiber.Ctx) error {
 }
 
 func (u *RecordingController) GetNextDay(c *fiber.Ctx) error {
-	req := new(validation.GetRecordingNextDay)
+	projectFlockID := c.QueryInt("project_flock_kandang_id", 0)
-
+	if projectFlockID <= 0 {
-	if err := c.QueryParser(req); err != nil {
-		return fiber.NewError(fiber.StatusBadRequest, "Invalid query params")
-	}
-	if req.ProjectFlockKandangId == 0 {
 		return fiber.NewError(fiber.StatusBadRequest, "project_flock_kandang_id is required")
 	}
-	if req.RecordTime == nil || strings.TrimSpace(*req.RecordTime) == "" {
+
-		return fiber.NewError(fiber.StatusBadRequest, "record_date is required")
+	recordTime := time.Now().UTC()
-	}
+	if recordDate := strings.TrimSpace(c.Query("record_date")); recordDate != "" {
-	recordTime, err := time.Parse("2006-01-02", strings.TrimSpace(*req.RecordTime))
+		parsed, err := time.Parse("2006-01-02", recordDate)
 		if err != nil {
-		return fiber.NewError(fiber.StatusBadRequest, "record_time must be in YYYY-MM-DD format")
+			return fiber.NewError(fiber.StatusBadRequest, "record_date must be in YYYY-MM-DD format")
 		}
-	req.RecordTimeValue = &recordTime
+		recordTime = parsed.UTC()
-	nextDay, err := u.RecordingService.GetNextDay(c, req)
+	}
+
+	nextDay, err := u.RecordingService.GetNextDay(c, uint(projectFlockID), recordTime)
 	if err != nil {
 		return err
 	}
-	projectFlockID := req.ProjectFlockKandangId
+
 	return c.Status(fiber.StatusOK).
 		JSON(response.Success{
 			Code:    fiber.StatusOK,

internal/modules/production/recordings/module.go

@@ -2,6 +2,7 @@ package recordings
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
@@ -10,21 +11,14 @@ import (
 	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
 	rProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
-	rFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/master/flocks/repositories"
-	rKandang "gitlab.com/mbugroup/lti-api.git/internal/modules/master/kandangs/repositories"
-	rNonstock "gitlab.com/mbugroup/lti-api.git/internal/modules/master/nonstocks/repositories"
 	rProductionStandard "gitlab.com/mbugroup/lti-api.git/internal/modules/master/production-standards/repositories"
 	sProductionStandard "gitlab.com/mbugroup/lti-api.git/internal/modules/master/production-standards/services"
-	rProduct "gitlab.com/mbugroup/lti-api.git/internal/modules/master/products/repositories"
-	rWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/master/warehouses/repositories"
-	rChickin "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins/repositories"
-	sChickin "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins/services"
 	rProjectFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
-	sProjectFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/services"
 	rRecording "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/repositories"
 	sRecording "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/services"
 	rStockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 
 	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
 	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
@@ -34,18 +28,10 @@ type RecordingModule struct{}
 
 func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
 	recordingRepo := rRecording.NewRecordingRepository(db)
-	projectFlockRepo := rProjectFlock.NewProjectflockRepository(db)
 	projectFlockKandangRepo := rProjectFlock.NewProjectFlockKandangRepository(db)
 	projectFlockPopulationRepo := rProjectFlock.NewProjectFlockPopulationRepository(db)
-	projectBudgetRepo := rProjectFlock.NewProjectBudgetRepository(db)
 	productWarehouseRepo := rProductWarehouse.NewProductWarehouseRepository(db)
-	flockRepo := rFlock.NewFlockRepository(db)
+	stockAllocationRepo := commonRepo.NewStockAllocationRepository(db)
-	kandangRepo := rKandang.NewKandangRepository(db)
-	warehouseRepo := rWarehouse.NewWarehouseRepository(db)
-	nonstockRepo := rNonstock.NewNonstockRepository(db)
-	productRepo := rProduct.NewProductRepository(db)
-	chickinRepo := rChickin.NewChickinRepository(db)
-	chickinDetailRepo := rChickin.NewChickinDetailRepository(db)
 	stockLogRepo := rStockLogs.NewStockLogRepository(db)
 	productionStandardRepo := rProductionStandard.NewProductionStandardRepository(db)
 	productionStandardDetailRepo := rProductionStandard.NewProductionStandardDetailRepository(db)
@@ -58,48 +44,69 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		validate,
 	)
 
-	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
+	fifoService := commonSvc.NewFifoService(db, stockAllocationRepo, productWarehouseRepo, utils.Log)
+	if err := fifoService.RegisterStockable(fifo.StockableConfig{
+		Key:   fifo.StockableKeyRecordingEgg,
+		Table: "recording_eggs",
+		Columns: fifo.StockableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			TotalQuantity:      "total_qty",
+			TotalUsedQuantity:  "total_used",
+			CreatedAt:          "created_at",
+		},
+		OrderBy: []string{"created_at ASC", "id ASC"},
+	}); err != nil {
+		if !strings.Contains(strings.ToLower(err.Error()), "already registered") {
+			panic(fmt.Sprintf("failed to register recording egg stockable workflow: %v", err))
+		}
+	}
+	if err := fifoService.RegisterUsable(fifo.UsableConfig{
+		Key:   fifo.UsableKeyRecordingStock,
+		Table: "recording_stocks",
+		Columns: fifo.UsableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			UsageQuantity:      "usage_qty",
+			PendingQuantity:    "pending_qty",
+			CreatedAt:          "id",
+		},
+	}); err != nil {
+		if !strings.Contains(strings.ToLower(err.Error()), "already registered") {
+			panic(fmt.Sprintf("failed to register recording usable workflow: %v", err))
+		}
+	}
+	if err := fifoService.RegisterUsable(fifo.UsableConfig{
+		Key:   fifo.UsableKeyRecordingDepletion,
+		Table: "recording_depletions",
+		Columns: fifo.UsableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "source_product_warehouse_id",
+			UsageQuantity:      "qty",
+			PendingQuantity:    "pending_qty",
+			CreatedAt:          "id",
+		},
+		ExcludedStockables: []fifo.StockableKey{
+			fifo.StockableKeyTransferToLayingIn,
+			fifo.StockableKeyStockTransferIn,
+			fifo.StockableKeyAdjustmentIn,
+			fifo.StockableKeyPurchaseItems,
+			fifo.StockableKeyRecordingEgg,
+		},
+	}); err != nil {
+		if !strings.Contains(strings.ToLower(err.Error()), "already registered") {
+			panic(fmt.Sprintf("failed to register recording depletion usable workflow: %v", err))
+		}
+	}
 
 	approvalRepo := commonRepo.NewApprovalRepository(db)
 	approvalService := commonSvc.NewApprovalService(approvalRepo)
 	if err := approvalService.RegisterWorkflowSteps(utils.ApprovalWorkflowRecording, utils.RecordingApprovalSteps); err != nil {
 		panic(fmt.Sprintf("failed to register recording approval workflow: %v", err))
 	}
-	if err := approvalService.RegisterWorkflowSteps(utils.ApprovalWorkflowProjectFlock, utils.ProjectFlockApprovalSteps); err != nil {
-		panic(fmt.Sprintf("failed to register project flock approval workflow: %v", err))
-	}
 
 	userRepo := rUser.NewUserRepository(db)
 
-	projectFlockService := sProjectFlock.NewProjectflockService(
-		projectFlockRepo,
-		flockRepo,
-		kandangRepo,
-		projectFlockKandangRepo,
-		warehouseRepo,
-		productWarehouseRepo,
-		projectBudgetRepo,
-		nonstockRepo,
-		projectFlockPopulationRepo,
-		recordingRepo,
-		approvalService,
-		validate,
-	)
-
-	chickinService := sChickin.NewChickinService(
-		chickinRepo,
-		kandangRepo,
-		warehouseRepo,
-		productWarehouseRepo,
-		productRepo,
-		projectFlockRepo,
-		projectFlockKandangRepo,
-		projectFlockPopulationRepo,
-		chickinDetailRepo,
-		validate,
-		fifoStockV2Service,
-	)
-
 	recordingService := sRecording.NewRecordingService(
 		recordingRepo,
 		projectFlockKandangRepo,
@@ -107,11 +114,9 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		projectFlockPopulationRepo,
 		approvalRepo,
 		approvalService,
-		fifoStockV2Service,
+		fifoService,
 		stockLogRepo,
 		productionStandardService,
-		projectFlockService,
-		chickinService,
 		validate,
 	)
 	userService := sUser.NewUserService(userRepo, validate)

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

@@ -17,48 +17,31 @@ type RecordingRepository interface {
 	repository.BaseRepository[entity.Recording]
 
 	WithRelations(db *gorm.DB) *gorm.DB
-	WithRelationsList(db *gorm.DB) *gorm.DB
-	ApplyListFilters(db *gorm.DB, search string, projectFlockKandangId uint) *gorm.DB
-	ApplyListCountFilters(db *gorm.DB, search string, projectFlockKandangId uint) *gorm.DB
 	ApplySearchFilters(db *gorm.DB, rawSearch string) *gorm.DB
-	GetAllWithFilters(ctx context.Context, offset, limit int, search string, projectFlockKandangId uint, modifier func(*gorm.DB) *gorm.DB) ([]entity.Recording, int64, error)
 	GetLatestByProjectFlockKandangID(ctx context.Context, projectFlockKandangId uint) (*entity.Recording, error)
-	ListByProjectFlockKandangID(ctx context.Context, tx *gorm.DB, projectFlockKandangId uint, from *time.Time) ([]entity.Recording, error)
 	GenerateNextDay(tx *gorm.DB, projectFlockKandangId uint) (int, error)
-	CreateRecording(tx *gorm.DB, recording *entity.Recording) error
 
 	CreateStocks(tx *gorm.DB, stocks []entity.RecordingStock) error
-	CreateStock(tx *gorm.DB, stock *entity.RecordingStock) error
 	DeleteStocks(tx *gorm.DB, recordingID uint) error
-	DeleteStocksByIDs(tx *gorm.DB, ids []uint) error
 	ListStocks(tx *gorm.DB, recordingID uint) ([]entity.RecordingStock, error)
-	GetStockByID(tx *gorm.DB, stockID uint) (*entity.RecordingStock, error)
 	UpdateStockUsage(tx *gorm.DB, stockID uint, usageQty, pendingQty float64) error
 	UpdateDepletionPending(tx *gorm.DB, depletionID uint, pendingQty float64) error
-	UpdateDepletionQuantities(tx *gorm.DB, depletionID uint, qty, usageQty, pendingQty float64) error
 
 	CreateDepletions(tx *gorm.DB, depletions []entity.RecordingDepletion) error
 	DeleteDepletions(tx *gorm.DB, recordingID uint) error
 	ListDepletions(tx *gorm.DB, recordingID uint) ([]entity.RecordingDepletion, error)
-	GetDepletionByID(tx *gorm.DB, depletionID uint) (*entity.RecordingDepletion, error)
 
 	CreateEggs(tx *gorm.DB, eggs []entity.RecordingEgg) error
 	DeleteEggs(tx *gorm.DB, recordingID uint) error
 	ListEggs(tx *gorm.DB, recordingID uint) ([]entity.RecordingEgg, error)
-	UpdateEggTotalQty(tx *gorm.DB, eggID uint, totalQty float64) error
 	GetRecordingEggByID(ctx context.Context, id uint, modifier func(*gorm.DB) *gorm.DB) (*entity.RecordingEgg, error)
 
 	ExistsOnDate(ctx context.Context, projectFlockKandangId uint, recordTime time.Time) (bool, error)
 
 	SumRecordingDepletions(tx *gorm.DB, recordingID uint) (float64, error)
 	GetCumulativeDepletionByProjectFlockKandangUntil(tx *gorm.DB, projectFlockKandangId uint, recordTime time.Time) (float64, error)
-	GetCumulativeDepletionByRecordingIDs(tx *gorm.DB, recordingIDs []uint) (map[uint]float64, error)
-	GetUniformityMeanBwByWeek(tx *gorm.DB, projectFlockKandangId uint, week int) (float64, bool, error)
 	FindPreviousRecording(tx *gorm.DB, projectFlockKandangId uint, currentDay int) (*entity.Recording, error)
-	GetPreviousTotalChickByRecordingIDs(tx *gorm.DB, recordingIDs []uint) (map[uint]*float64, error)
 	GetTotalChick(tx *gorm.DB, projectFlockKandangId uint) (int64, error)
-	GetRemainingPopulationByProjectFlockKandang(tx *gorm.DB, projectFlockKandangId uint) (float64, error)
-	GetTotalChickByProjectFlockKandangIDs(tx *gorm.DB, projectFlockKandangIds []uint) (map[uint]int64, error)
 	GetTotalChickinByProjectFlockKandang(tx *gorm.DB, projectFlockKandangId uint) (float64, error)
 	GetFeedUsageInGrams(tx *gorm.DB, recordingID uint) (float64, error)
 	GetEggSummaryByRecording(tx *gorm.DB, recordingID uint) (totalQty float64, totalWeightGrams float64, err error)
@@ -71,8 +54,6 @@ type RecordingRepository interface {
 	GetLatestAvgWeightByProjectFlockID(ctx context.Context, projectFlockID uint) (avgWeight float64, err error)
 	GetTotalEggProductionWeightByProjectFlockID(ctx context.Context, projectFlockID uint) (totalWeightKg float64, err error)
 	GetAverageTargetMetricsByProjectFlockKandangID(ctx context.Context, projectFlockKandangID uint, includeTargets bool) (RecordingTargetAverages, error)
-	ResyncProjectFlockPopulationUsage(ctx context.Context, tx *gorm.DB, projectFlockKandangID uint) error
-	ValidateProductWarehousesByFlags(ctx context.Context, ids []uint, flags []string) (uint, error)
 }
 
 type RecordingRepositoryImpl struct {
@@ -131,64 +112,6 @@ func (r *RecordingRepositoryImpl) WithRelations(db *gorm.DB) *gorm.DB {
 		Preload("Eggs.ProductWarehouse.Warehouse.Location")
 }
 
-func (r *RecordingRepositoryImpl) WithRelationsList(db *gorm.DB) *gorm.DB {
-	return db.
-		Preload("CreatedUser").
-		Preload("ProjectFlockKandang").
-		Preload("ProjectFlockKandang.Kandang").
-		Preload("ProjectFlockKandang.Kandang.Location").
-		Preload("ProjectFlockKandang.ProjectFlock").
-		Preload("ProjectFlockKandang.ProjectFlock.ProductionStandard")
-}
-
-func (r *RecordingRepositoryImpl) ApplyListFilters(db *gorm.DB, search string, projectFlockKandangId uint) *gorm.DB {
-	db = r.WithRelationsList(db)
-	db = db.
-		Joins("JOIN project_flock_kandangs pfk ON pfk.id = recordings.project_flock_kandangs_id").
-		Joins("JOIN project_flocks pf ON pf.id = pfk.project_flock_id")
-	if projectFlockKandangId != 0 {
-		db = db.Where("recordings.project_flock_kandangs_id = ?", projectFlockKandangId)
-	}
-	db = r.ApplySearchFilters(db, search)
-	return db.Order("recordings.record_datetime DESC").Order("recordings.created_at DESC")
-}
-
-func (r *RecordingRepositoryImpl) ApplyListCountFilters(db *gorm.DB, search string, projectFlockKandangId uint) *gorm.DB {
-	db = db.
-		Joins("JOIN project_flock_kandangs pfk ON pfk.id = recordings.project_flock_kandangs_id").
-		Joins("JOIN project_flocks pf ON pf.id = pfk.project_flock_id")
-	if projectFlockKandangId != 0 {
-		db = db.Where("recordings.project_flock_kandangs_id = ?", projectFlockKandangId)
-	}
-	db = r.ApplySearchFilters(db, search)
-	return db
-}
-
-func (r *RecordingRepositoryImpl) GetAllWithFilters(ctx context.Context, offset, limit int, search string, projectFlockKandangId uint, modifier func(*gorm.DB) *gorm.DB) ([]entity.Recording, int64, error) {
-	var (
-		records []entity.Recording
-		total   int64
-	)
-
-	countQ := r.ApplyListCountFilters(r.DB().WithContext(ctx).Model(&entity.Recording{}), search, projectFlockKandangId)
-	if modifier != nil {
-		countQ = modifier(countQ)
-	}
-	if err := countQ.Count(&total).Error; err != nil {
-		return nil, 0, err
-	}
-
-	listQ := r.ApplyListFilters(r.DB().WithContext(ctx).Model(&entity.Recording{}), search, projectFlockKandangId)
-	if modifier != nil {
-		listQ = modifier(listQ)
-	}
-	if err := listQ.Offset(offset).Limit(limit).Find(&records).Error; err != nil {
-		return nil, 0, err
-	}
-
-	return records, total, nil
-}
-
 func (r *RecordingRepositoryImpl) ApplySearchFilters(db *gorm.DB, rawSearch string) *gorm.DB {
 	normalized := strings.ToLower(strings.TrimSpace(rawSearch))
 	if normalized == "" {
@@ -246,27 +169,6 @@ func (r *RecordingRepositoryImpl) GetLatestByProjectFlockKandangID(ctx context.C
 	return &record, nil
 }
 
-func (r *RecordingRepositoryImpl) ListByProjectFlockKandangID(ctx context.Context, tx *gorm.DB, projectFlockKandangId uint, from *time.Time) ([]entity.Recording, error) {
-	if projectFlockKandangId == 0 {
-		return nil, errors.New("project_flock_kandang_id is required")
-	}
-
-	db := tx.WithContext(ctx).
-		Model(&entity.Recording{}).
-		Where("project_flock_kandangs_id = ?", projectFlockKandangId).
-		Where("deleted_at IS NULL")
-
-	if from != nil {
-		db = db.Where("record_datetime >= ?", *from)
-	}
-
-	var records []entity.Recording
-	if err := db.Order("record_datetime ASC").Order("created_at ASC").Find(&records).Error; err != nil {
-		return nil, err
-	}
-	return records, nil
-}
-
 func (r *RecordingRepositoryImpl) GenerateNextDay(tx *gorm.DB, projectFlockKandangId uint) (int, error) {
 	var days []int
 	if err := tx.Model(&entity.Recording{}).
@@ -279,18 +181,6 @@ func (r *RecordingRepositoryImpl) GenerateNextDay(tx *gorm.DB, projectFlockKanda
 	return nextRecordingDay(days), nil
 }
 
-func (r *RecordingRepositoryImpl) CreateRecording(tx *gorm.DB, recording *entity.Recording) error {
-	if recording == nil {
-		return nil
-	}
-	return tx.Select(
-		"ProjectFlockKandangId",
-		"RecordDatetime",
-		"Day",
-		"CreatedBy",
-	).Create(recording).Error
-}
-
 func (r *RecordingRepositoryImpl) CreateStocks(tx *gorm.DB, stocks []entity.RecordingStock) error {
 	if len(stocks) == 0 {
 		return nil
@@ -298,24 +188,10 @@ func (r *RecordingRepositoryImpl) CreateStocks(tx *gorm.DB, stocks []entity.Reco
 	return tx.Create(&stocks).Error
 }
 
-func (r *RecordingRepositoryImpl) CreateStock(tx *gorm.DB, stock *entity.RecordingStock) error {
-	if stock == nil {
-		return nil
-	}
-	return tx.Create(stock).Error
-}
-
 func (r *RecordingRepositoryImpl) DeleteStocks(tx *gorm.DB, recordingID uint) error {
 	return tx.Where("recording_id = ?", recordingID).Delete(&entity.RecordingStock{}).Error
 }
 
-func (r *RecordingRepositoryImpl) DeleteStocksByIDs(tx *gorm.DB, ids []uint) error {
-	if len(ids) == 0 {
-		return nil
-	}
-	return tx.Where("id IN ?", ids).Delete(&entity.RecordingStock{}).Error
-}
-
 func (r *RecordingRepositoryImpl) ListStocks(tx *gorm.DB, recordingID uint) ([]entity.RecordingStock, error) {
 	var items []entity.RecordingStock
 	if err := tx.Where("recording_id = ?", recordingID).Find(&items).Error; err != nil {
@@ -324,18 +200,6 @@ func (r *RecordingRepositoryImpl) ListStocks(tx *gorm.DB, recordingID uint) ([]e
 	return items, nil
 }
 
-func (r *RecordingRepositoryImpl) GetStockByID(tx *gorm.DB, stockID uint) (*entity.RecordingStock, error) {
-	if stockID == 0 {
-		return nil, gorm.ErrRecordNotFound
-	}
-
-	var stock entity.RecordingStock
-	if err := tx.Where("id = ?", stockID).Take(&stock).Error; err != nil {
-		return nil, err
-	}
-	return &stock, nil
-}
-
 func (r *RecordingRepositoryImpl) UpdateStockUsage(tx *gorm.DB, stockID uint, usageQty, pendingQty float64) error {
 	return tx.Model(&entity.RecordingStock{}).
 		Where("id = ?", stockID).
@@ -351,16 +215,6 @@ func (r *RecordingRepositoryImpl) UpdateDepletionPending(tx *gorm.DB, depletionI
 		Update("pending_qty", pendingQty).Error
 }
 
-func (r *RecordingRepositoryImpl) UpdateDepletionQuantities(tx *gorm.DB, depletionID uint, qty, usageQty, pendingQty float64) error {
-	return tx.Model(&entity.RecordingDepletion{}).
-		Where("id = ?", depletionID).
-		Updates(map[string]any{
-			"qty":         qty,
-			"usage_qty":   usageQty,
-			"pending_qty": pendingQty,
-		}).Error
-}
-
 func (r *RecordingRepositoryImpl) CreateDepletions(tx *gorm.DB, depletions []entity.RecordingDepletion) error {
 	if len(depletions) == 0 {
 		return nil
@@ -380,18 +234,6 @@ func (r *RecordingRepositoryImpl) ListDepletions(tx *gorm.DB, recordingID uint)
 	return items, nil
 }
 
-func (r *RecordingRepositoryImpl) GetDepletionByID(tx *gorm.DB, depletionID uint) (*entity.RecordingDepletion, error) {
-	if depletionID == 0 {
-		return nil, gorm.ErrRecordNotFound
-	}
-
-	var depletion entity.RecordingDepletion
-	if err := tx.Where("id = ?", depletionID).Take(&depletion).Error; err != nil {
-		return nil, err
-	}
-	return &depletion, nil
-}
-
 func (r *RecordingRepositoryImpl) CreateEggs(tx *gorm.DB, eggs []entity.RecordingEgg) error {
 	if len(eggs) == 0 {
 		return nil
@@ -411,12 +253,6 @@ func (r *RecordingRepositoryImpl) ListEggs(tx *gorm.DB, recordingID uint) ([]ent
 	return items, nil
 }
 
-func (r *RecordingRepositoryImpl) UpdateEggTotalQty(tx *gorm.DB, eggID uint, totalQty float64) error {
-	return tx.Model(&entity.RecordingEgg{}).
-		Where("id = ?", eggID).
-		Update("total_qty", totalQty).Error
-}
-
 func (r *RecordingRepositoryImpl) GetRecordingEggByID(
 	ctx context.Context,
 	id uint,
@@ -495,68 +331,6 @@ func (r *RecordingRepositoryImpl) GetCumulativeDepletionByProjectFlockKandangUnt
 	return total, err
 }
 
-func (r *RecordingRepositoryImpl) GetCumulativeDepletionByRecordingIDs(tx *gorm.DB, recordingIDs []uint) (map[uint]float64, error) {
-	result := make(map[uint]float64)
-	if len(recordingIDs) == 0 {
-		return result, nil
-	}
-
-	type row struct {
-		RecordingID uint    `gorm:"column:recording_id"`
-		Total       float64 `gorm:"column:total_qty"`
-	}
-	var rows []row
-
-	err := tx.
-		Table("recordings r").
-		Select("r.id AS recording_id, COALESCE(SUM(rd.qty), 0) AS total_qty").
-		Joins(`
-			LEFT JOIN recordings r2
-				ON r2.project_flock_kandangs_id = r.project_flock_kandangs_id
-				AND r2.record_datetime <= r.record_datetime
-				AND r2.deleted_at IS NULL`).
-		Joins("LEFT JOIN recording_depletions rd ON rd.recording_id = r2.id").
-		Where("r.id IN ?", recordingIDs).
-		Where("r.deleted_at IS NULL").
-		Group("r.id").
-		Scan(&rows).Error
-	if err != nil {
-		return nil, err
-	}
-
-	for _, row := range rows {
-		result[row.RecordingID] = row.Total
-	}
-	return result, nil
-}
-
-func (r *RecordingRepositoryImpl) GetUniformityMeanBwByWeek(tx *gorm.DB, projectFlockKandangId uint, week int) (float64, bool, error) {
-	if projectFlockKandangId == 0 || week <= 0 {
-		return 0, false, nil
-	}
-
-	var row struct {
-		ID     uint
-		MeanUp float64
-	}
-	if err := tx.
-		Table("project_flock_kandang_uniformity").
-		Select("id, mean_up").
-		Where("project_flock_kandang_id = ?", projectFlockKandangId).
-		Where("week = ?", week).
-		Order("id DESC").
-		Limit(1).
-		Scan(&row).Error; err != nil {
-		return 0, false, err
-	}
-	if row.ID == 0 {
-		return 0, false, nil
-	}
-
-	meanBw := row.MeanUp / 1.10
-	return meanBw, true, nil
-}
-
 func (r *RecordingRepositoryImpl) FindPreviousRecording(tx *gorm.DB, projectFlockKandangId uint, currentDay int) (*entity.Recording, error) {
 	if currentDay <= 1 {
 		return nil, nil
@@ -579,46 +353,6 @@ func (r *RecordingRepositoryImpl) FindPreviousRecording(tx *gorm.DB, projectFloc
 	return &prev, nil
 }
 
-func (r *RecordingRepositoryImpl) GetPreviousTotalChickByRecordingIDs(tx *gorm.DB, recordingIDs []uint) (map[uint]*float64, error) {
-	result := make(map[uint]*float64)
-	if len(recordingIDs) == 0 {
-		return result, nil
-	}
-
-	type row struct {
-		RecordingID       uint     `gorm:"column:recording_id"`
-		PrevTotalChickQty *float64 `gorm:"column:prev_total_chick_qty"`
-	}
-	var rows []row
-
-	err := tx.
-		Table("recordings r").
-		Select(`
-			r.id AS recording_id,
-			(
-				SELECT r2.total_chick_qty
-				FROM recordings r2
-				WHERE r2.project_flock_kandangs_id = r.project_flock_kandangs_id
-				  AND r2.day IS NOT NULL
-				  AND r.day IS NOT NULL
-				  AND r2.day < r.day
-				  AND r2.deleted_at IS NULL
-				ORDER BY r2.day DESC
-				LIMIT 1
-			) AS prev_total_chick_qty`).
-		Where("r.id IN ?", recordingIDs).
-		Where("r.deleted_at IS NULL").
-		Scan(&rows).Error
-	if err != nil {
-		return nil, err
-	}
-
-	for _, row := range rows {
-		result[row.RecordingID] = row.PrevTotalChickQty
-	}
-	return result, nil
-}
-
 func (r *RecordingRepositoryImpl) GetTotalChick(tx *gorm.DB, projectFlockKandangId uint) (int64, error) {
 	var total float64
 	err := tx.
@@ -638,57 +372,6 @@ func (r *RecordingRepositoryImpl) GetTotalChick(tx *gorm.DB, projectFlockKandang
 	return int64(math.Round(total)), nil
 }
 
-func (r *RecordingRepositoryImpl) GetRemainingPopulationByProjectFlockKandang(tx *gorm.DB, projectFlockKandangId uint) (float64, error) {
-	var total float64
-	err := tx.
-		Table("project_flock_populations").
-		Select("COALESCE(SUM(project_flock_populations.total_qty - project_flock_populations.total_used_qty), 0) AS total_qty").
-		Joins("JOIN project_chickins ON project_chickins.id = project_flock_populations.project_chickin_id").
-		Where("project_chickins.project_flock_kandang_id = ?", projectFlockKandangId).
-		Scan(&total).Error
-	if err != nil {
-		return 0, err
-	}
-	if total < 0 {
-		total = 0
-	}
-	return total, nil
-}
-
-func (r *RecordingRepositoryImpl) GetTotalChickByProjectFlockKandangIDs(tx *gorm.DB, projectFlockKandangIds []uint) (map[uint]int64, error) {
-	result := make(map[uint]int64)
-	if len(projectFlockKandangIds) == 0 {
-		return result, nil
-	}
-
-	type row struct {
-		ProjectFlockKandangId uint    `gorm:"column:project_flock_kandang_id"`
-		Total                 float64 `gorm:"column:total_qty"`
-	}
-	var rows []row
-
-	err := tx.
-		Table("project_flock_populations pfp").
-		Select("project_chickins.project_flock_kandang_id, COALESCE(SUM(pfp.total_qty - pfp.total_used_qty), 0) AS total_qty").
-		Joins("JOIN project_chickins ON project_chickins.id = pfp.project_chickin_id").
-		Where("project_chickins.project_flock_kandang_id IN ?", projectFlockKandangIds).
-		Group("project_chickins.project_flock_kandang_id").
-		Scan(&rows).Error
-	if err != nil {
-		return nil, err
-	}
-
-	for _, row := range rows {
-		total := math.Round(row.Total)
-		if total < 0 {
-			total = 0
-		}
-		result[row.ProjectFlockKandangId] = int64(total)
-	}
-
-	return result, nil
-}
-
 func (r *RecordingRepositoryImpl) GetTotalChickinByProjectFlockKandang(tx *gorm.DB, projectFlockKandangId uint) (float64, error) {
 	if projectFlockKandangId == 0 {
 		return 0, nil
@@ -874,84 +557,6 @@ func (r *RecordingRepositoryImpl) GetAverageTargetMetricsByProjectFlockKandangID
 	return result, nil
 }
 
-func (r *RecordingRepositoryImpl) ResyncProjectFlockPopulationUsage(ctx context.Context, tx *gorm.DB, projectFlockKandangID uint) error {
-	if projectFlockKandangID == 0 {
-		return nil
-	}
-
-	idsSubquery := `
-		SELECT pfp.id
-		FROM project_flock_populations pfp
-		JOIN project_chickins pc ON pc.id = pfp.project_chickin_id
-		WHERE pc.project_flock_kandang_id = ?
-	`
-
-	updateWithAlloc := `
-		UPDATE project_flock_populations p
-		SET total_used_qty = COALESCE(a.used, 0)
-		FROM (
-			SELECT stockable_id, SUM(qty) AS used
-			FROM stock_allocations
-			WHERE stockable_type = 'PROJECT_FLOCK_POPULATION'
-			  AND status = 'ACTIVE'
-			  AND allocation_purpose = 'CONSUME'
-			GROUP BY stockable_id
-		) a
-		WHERE p.id = a.stockable_id
-		  AND p.id IN (` + idsSubquery + `)
-	`
-
-	resetMissing := `
-		UPDATE project_flock_populations p
-		SET total_used_qty = 0
-		WHERE p.id IN (` + idsSubquery + `)
-			AND NOT EXISTS (
-				SELECT 1
-				FROM stock_allocations sa
-				WHERE sa.stockable_type = 'PROJECT_FLOCK_POPULATION'
-				  AND sa.status = 'ACTIVE'
-				  AND sa.allocation_purpose = 'CONSUME'
-				  AND sa.stockable_id = p.id
-			  )
-		`
-
-	db := r.DB().WithContext(ctx)
-	if tx != nil {
-		db = tx.WithContext(ctx)
-	}
-
-	if err := db.Exec(updateWithAlloc, projectFlockKandangID).Error; err != nil {
-		return err
-	}
-	if err := db.Exec(resetMissing, projectFlockKandangID).Error; err != nil {
-		return err
-	}
-	return nil
-}
-
-func (r *RecordingRepositoryImpl) ValidateProductWarehousesByFlags(ctx context.Context, ids []uint, flags []string) (uint, error) {
-	if len(ids) == 0 {
-		return 0, nil
-	}
-	var invalidIDs []uint
-	if err := r.DB().WithContext(ctx).
-		Table("product_warehouses pw").
-		Where("pw.id IN ?", ids).
-		Where(`NOT EXISTS (
-			SELECT 1 FROM flags f
-			WHERE f.flagable_type = 'products'
-			  AND f.flagable_id = pw.product_id
-			  AND UPPER(f.name) IN ?
-		)`, flags).
-		Pluck("pw.id", &invalidIDs).Error; err != nil {
-		return 0, err
-	}
-	if len(invalidIDs) > 0 {
-		return invalidIDs[0], nil
-	}
-	return 0, nil
-}
-
 func nextRecordingDay(days []int) int {
 	if len(days) == 0 {
 		return 1

internal/modules/production/recordings/services/fifo_stock_v2_helper.go

@@ -1,137 +0,0 @@
-package service
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gorm.io/gorm"
-)
-
-const (
-	recordingLaneUsable    = "USABLE"
-	recordingLaneStockable = "STOCKABLE"
-
-	recordingFunctionStockOut     = "RECORDING_STOCK_OUT"
-	recordingFunctionDepletionOut = "RECORDING_DEPLETION_OUT"
-	recordingFunctionDepletionIn  = "RECORDING_DEPLETION_IN"
-	recordingFunctionEggIn        = "RECORDING_EGG_IN"
-
-	recordingSourceStocks     = "recording_stocks"
-	recordingSourceDepletions = "recording_depletions"
-	recordingSourceEggs       = "recording_eggs"
-)
-
-func (s *recordingService) reflowRecordingScope(
-	ctx context.Context,
-	tx *gorm.DB,
-	productWarehouseID uint,
-	recordingID uint,
-	lane string,
-	functionCode string,
-	sourceTable string,
-) error {
-	if s == nil || s.FifoStockV2Svc == nil {
-		return fmt.Errorf("FIFO v2 service is not available")
-	}
-	if tx == nil {
-		return fmt.Errorf("transaction is required")
-	}
-	if productWarehouseID == 0 {
-		return fmt.Errorf("product warehouse id is required")
-	}
-
-	flagGroupCode, err := resolveRecordingFlagGroupByProductWarehouse(ctx, tx, productWarehouseID, lane, functionCode, sourceTable)
-	if err != nil {
-		return err
-	}
-	if strings.TrimSpace(flagGroupCode) == "" {
-		return fmt.Errorf("flag group code is not found for product warehouse %d", productWarehouseID)
-	}
-
-	asOf, err := resolveRecordingAsOf(ctx, tx, recordingID)
-	if err != nil {
-		return err
-	}
-
-	_, err = s.FifoStockV2Svc.Reflow(ctx, commonSvc.FifoStockV2ReflowRequest{
-		FlagGroupCode:      flagGroupCode,
-		ProductWarehouseID: productWarehouseID,
-		AsOf:               asOf,
-		Tx:                 tx,
-	})
-	return err
-}
-
-func resolveRecordingFlagGroupByProductWarehouse(
-	ctx context.Context,
-	tx *gorm.DB,
-	productWarehouseID uint,
-	lane string,
-	functionCode string,
-	sourceTable string,
-) (string, error) {
-	type row struct {
-		FlagGroupCode string `gorm:"column:flag_group_code"`
-	}
-
-	var selected row
-	q := tx.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules rr").
-		Select("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 = ?", lane).
-		Where("rr.source_table = ?", sourceTable)
-
-	if strings.TrimSpace(functionCode) != "" {
-		q = q.Where("rr.function_code = ?", functionCode)
-	}
-
-	err := q.
-		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.id ASC").
-		Limit(1).
-		Take(&selected).Error
-	if err != nil {
-		return "", err
-	}
-
-	return strings.TrimSpace(selected.FlagGroupCode), nil
-}
-
-func resolveRecordingAsOf(ctx context.Context, tx *gorm.DB, recordingID uint) (*time.Time, error) {
-	if recordingID == 0 {
-		asOf := time.Now().UTC()
-		return &asOf, nil
-	}
-
-	type row struct {
-		RecordDatetime time.Time `gorm:"column:record_datetime"`
-	}
-	var selected row
-	if err := tx.WithContext(ctx).
-		Table("recordings").
-		Select("record_datetime").
-		Where("id = ?", recordingID).
-		Limit(1).
-		Take(&selected).Error; err != nil {
-		return nil, err
-	}
-
-	asOf := selected.RecordDatetime.UTC()
-	return &asOf, nil
-}

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

@@ -0,0 +1,703 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"strings"
+
+	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	rProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
+	repository "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/repositories"
+	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/validations"
+	rStockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
+	recordingutil "gitlab.com/mbugroup/lti-api.git/internal/utils/recording"
+
+	"github.com/gofiber/fiber/v2"
+	"gorm.io/gorm"
+)
+
+type RecordingFIFOIntegrationService interface {
+	ConsumeRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock, note string, actorID uint) error
+	ReleaseRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock, note string, actorID uint) error
+}
+
+var recordingStockUsableKey = fifo.UsableKeyRecordingStock
+var recordingDepletionUsableKey = fifo.UsableKeyRecordingDepletion
+
+func NewRecordingFIFOIntegrationService(
+	repo repository.RecordingRepository,
+	productWarehouseRepo rProductWarehouse.ProductWarehouseRepository,
+	fifoSvc commonSvc.FifoService,
+	stockLogRepo rStockLogs.StockLogRepository,
+) RecordingFIFOIntegrationService {
+	return &recordingService{
+		Log:                  utils.Log,
+		Repository:           repo,
+		ProductWarehouseRepo: productWarehouseRepo,
+		FifoSvc:              fifoSvc,
+		StockLogRepo:         stockLogRepo,
+	}
+}
+
+func (s *recordingService) consumeRecordingStocks(
+	ctx context.Context,
+	tx *gorm.DB,
+	stocks []entity.RecordingStock,
+	note string,
+	actorID uint,
+) error {
+	if len(stocks) == 0 || s.FifoSvc == nil {
+		return nil
+	}
+	if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
+		return errors.New("stock log repository is not available")
+	}
+
+	for _, stock := range stocks {
+		if stock.Id == 0 {
+			continue
+		}
+
+		var desired float64
+		if stock.UsageQty != nil {
+			desired = *stock.UsageQty
+		}
+		var pending float64
+		if stock.PendingQty != nil {
+			pending = *stock.PendingQty
+		}
+		desiredTotal := desired + pending
+
+		result, err := s.FifoSvc.Consume(ctx, commonSvc.StockConsumeRequest{
+			UsableKey:          recordingStockUsableKey,
+			UsableID:           stock.Id,
+			ProductWarehouseID: stock.ProductWarehouseId,
+			Quantity:           desiredTotal,
+			AllowPending:       true,
+			Tx:                 tx,
+		})
+		if err != nil {
+			s.Log.Errorf("Failed to consume FIFO stock for recording stock %d: %+v", stock.Id, err)
+			return err
+		}
+
+		if err := s.Repository.UpdateStockUsage(tx, stock.Id, result.UsageQuantity, result.PendingQuantity); err != nil {
+			return err
+		}
+
+		logDecrease := result.UsageQuantity
+		if result.PendingQuantity > 0 {
+			logDecrease += result.PendingQuantity
+		}
+		if logDecrease > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
+			log := &entity.StockLog{
+				ProductWarehouseId: stock.ProductWarehouseId,
+				CreatedBy:          actorID,
+				Decrease:           logDecrease,
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         stock.RecordingId,
+				Notes:              note,
+			}
+			stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, stock.ProductWarehouseId, 1)
+			if err != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
+			}
+			if len(stockLogs) > 0 {
+				latestStockLog := stockLogs[0]
+				log.Stock = latestStockLog.Stock
+				log.Stock -= log.Decrease
+			} else {
+				log.Stock -= log.Decrease
+			}
+
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (s *recordingService) consumeRecordingDepletions(
+	ctx context.Context,
+	tx *gorm.DB,
+	depletions []entity.RecordingDepletion,
+	note string,
+	actorID uint,
+) error {
+	if len(depletions) == 0 || s.FifoSvc == nil {
+		return nil
+	}
+	if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
+		return errors.New("stock log repository is not available")
+	}
+
+	for _, depletion := range depletions {
+		if depletion.Id == 0 {
+			continue
+		}
+
+		sourceWarehouseID := uint(0)
+		if depletion.SourceProductWarehouseId != nil {
+			sourceWarehouseID = *depletion.SourceProductWarehouseId
+		}
+		if sourceWarehouseID == 0 {
+			return fiber.NewError(fiber.StatusBadRequest, "Source product warehouse tidak ditemukan untuk depletion")
+		}
+
+		desired := depletion.Qty + depletion.PendingQty
+		result, err := s.FifoSvc.Consume(ctx, commonSvc.StockConsumeRequest{
+			UsableKey:          recordingDepletionUsableKey,
+			UsableID:           depletion.Id,
+			ProductWarehouseID: sourceWarehouseID,
+			Quantity:           desired,
+			AllowPending:       false,
+			Tx:                 tx,
+		})
+		if err != nil {
+			s.Log.Errorf("Failed to consume FIFO stock for recording depletion %d: %+v", depletion.Id, err)
+			return err
+		}
+
+		if err := s.Repository.UpdateDepletionPending(tx, depletion.Id, result.PendingQuantity); err != nil {
+			return err
+		}
+
+		logDecrease := result.UsageQuantity
+		if result.PendingQuantity > 0 {
+			logDecrease += result.PendingQuantity
+		}
+		if logDecrease > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
+			log := &entity.StockLog{
+				ProductWarehouseId: sourceWarehouseID,
+				CreatedBy:          actorID,
+				Decrease:           logDecrease,
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         depletion.RecordingId,
+				Notes:              note,
+			}
+			stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, sourceWarehouseID, 1)
+			if err != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
+			}
+			if len(stockLogs) > 0 {
+				latestStockLog := stockLogs[0]
+				log.Stock = latestStockLog.Stock
+				log.Stock -= log.Decrease
+			} else {
+				log.Stock -= log.Decrease
+			}
+
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
+
+		destDelta := depletion.Qty + depletion.PendingQty
+		if depletion.ProductWarehouseId != 0 && destDelta > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
+			if depletion.ProductWarehouseId == sourceWarehouseID {
+				continue
+			}
+			log := &entity.StockLog{
+				ProductWarehouseId: depletion.ProductWarehouseId,
+				CreatedBy:          actorID,
+				Increase:           destDelta,
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         depletion.RecordingId,
+				Notes:              note,
+			}
+			stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, depletion.ProductWarehouseId, 1)
+			if err != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
+			}
+			if len(stockLogs) > 0 {
+				latestStockLog := stockLogs[0]
+				log.Stock = latestStockLog.Stock
+				log.Stock += log.Increase
+			} else {
+				log.Stock += log.Increase
+			}
+
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (s *recordingService) ConsumeRecordingStocks(
+	ctx context.Context,
+	tx *gorm.DB,
+	stocks []entity.RecordingStock,
+	note string,
+	actorID uint,
+) error {
+	return s.consumeRecordingStocks(ctx, tx, stocks, note, actorID)
+}
+
+func (s *recordingService) releaseRecordingStocks(
+	ctx context.Context,
+	tx *gorm.DB,
+	stocks []entity.RecordingStock,
+	note string,
+	actorID uint,
+) error {
+	if len(stocks) == 0 || s.FifoSvc == nil {
+		return nil
+	}
+	if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
+		return errors.New("stock log repository is not available")
+	}
+
+	for _, stock := range stocks {
+		if stock.Id == 0 {
+			continue
+		}
+		if err := s.FifoSvc.ReleaseUsage(ctx, commonSvc.StockReleaseRequest{
+			UsableKey: recordingStockUsableKey,
+			UsableID:  stock.Id,
+			Tx:        tx,
+		}); err != nil {
+			s.Log.Errorf("Failed to release FIFO stock for recording stock %d: %+v", stock.Id, err)
+			return err
+		}
+
+		if err := s.Repository.UpdateStockUsage(tx, stock.Id, 0, 0); err != nil {
+			return err
+		}
+
+		if stock.UsageQty != nil && *stock.UsageQty > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
+			log := &entity.StockLog{
+				ProductWarehouseId: stock.ProductWarehouseId,
+				CreatedBy:          actorID,
+				Increase:           *stock.UsageQty,
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         stock.RecordingId,
+				Notes:              note,
+			}
+			stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, stock.ProductWarehouseId, 1)
+			if err != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
+			}
+			if len(stockLogs) > 0 {
+				latestStockLog := stockLogs[0]
+				log.Stock = latestStockLog.Stock
+				log.Stock += log.Increase
+			} else {
+				log.Stock += log.Increase
+			}
+
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (s *recordingService) releaseRecordingDepletions(
+	ctx context.Context,
+	tx *gorm.DB,
+	depletions []entity.RecordingDepletion,
+	note string,
+	actorID uint,
+) error {
+	if len(depletions) == 0 || s.FifoSvc == nil {
+		return nil
+	}
+	if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
+		return errors.New("stock log repository is not available")
+	}
+
+	for _, depletion := range depletions {
+		if depletion.Id == 0 {
+			continue
+		}
+
+		sourceWarehouseID := uint(0)
+		if depletion.SourceProductWarehouseId != nil {
+			sourceWarehouseID = *depletion.SourceProductWarehouseId
+		}
+		if sourceWarehouseID == 0 {
+			return fiber.NewError(fiber.StatusBadRequest, "Source product warehouse tidak ditemukan untuk depletion")
+		}
+		if err := s.FifoSvc.ReleaseUsage(ctx, commonSvc.StockReleaseRequest{
+			UsableKey: recordingDepletionUsableKey,
+			UsableID:  depletion.Id,
+			Tx:        tx,
+		}); err != nil {
+			s.Log.Errorf("Failed to release FIFO stock for recording depletion %d: %+v", depletion.Id, err)
+			return err
+		}
+
+		if err := s.Repository.UpdateDepletionPending(tx, depletion.Id, 0); err != nil {
+			return err
+		}
+
+		logIncrease := depletion.Qty
+		if depletion.PendingQty > 0 {
+			logIncrease += depletion.PendingQty
+		}
+		if logIncrease > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
+			log := &entity.StockLog{
+				ProductWarehouseId: sourceWarehouseID,
+				CreatedBy:          actorID,
+				Increase:           logIncrease,
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         depletion.RecordingId,
+				Notes:              note,
+			}
+			stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, sourceWarehouseID, 1)
+			if err != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
+			}
+			if len(stockLogs) > 0 {
+				latestStockLog := stockLogs[0]
+				log.Stock = latestStockLog.Stock
+				log.Stock += log.Increase
+			} else {
+				log.Stock += log.Increase
+			}
+
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
+
+		destDelta := depletion.Qty + depletion.PendingQty
+		if depletion.ProductWarehouseId != 0 && destDelta > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
+			if depletion.ProductWarehouseId == sourceWarehouseID {
+				continue
+			}
+			log := &entity.StockLog{
+				ProductWarehouseId: depletion.ProductWarehouseId,
+				CreatedBy:          actorID,
+				Decrease:           destDelta,
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         depletion.RecordingId,
+				Notes:              note,
+			}
+			stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, depletion.ProductWarehouseId, 1)
+			if err != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
+			}
+			if len(stockLogs) > 0 {
+				latestStockLog := stockLogs[0]
+				log.Stock = latestStockLog.Stock
+				log.Stock -= log.Decrease
+			} else {
+				log.Stock -= log.Decrease
+			}
+
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (s *recordingService) ReleaseRecordingStocks(
+	ctx context.Context,
+	tx *gorm.DB,
+	stocks []entity.RecordingStock,
+	note string,
+	actorID uint,
+) error {
+	return s.releaseRecordingStocks(ctx, tx, stocks, note, actorID)
+}
+
+func (s *recordingService) logRecordingEggUsage(
+	ctx context.Context,
+	tx *gorm.DB,
+	eggs []entity.RecordingEgg,
+	note string,
+	actorID uint,
+) error {
+	if len(eggs) == 0 || s.StockLogRepo == nil {
+		return nil
+	}
+	if strings.TrimSpace(note) == "" || actorID == 0 {
+		return nil
+	}
+
+	logs := make([]*entity.StockLog, 0, len(eggs))
+	for _, egg := range eggs {
+		if egg.ProductWarehouseId == 0 || egg.Qty <= 0 {
+			continue
+		}
+		stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, egg.ProductWarehouseId, 1)
+		if err != nil {
+			s.Log.Errorf("Failed to get stock logs: %+v", err)
+			return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
+		}
+		latestStockLog := &entity.StockLog{}
+		if len(stockLogs) > 0 {
+			latestStockLog = stockLogs[0]
+		} else {
+			latestStockLog.Stock = 0
+		}
+		logs = append(logs, &entity.StockLog{
+			ProductWarehouseId: egg.ProductWarehouseId,
+			CreatedBy:          actorID,
+			Decrease:           float64(egg.Qty),
+			LoggableType:       string(utils.StockLogTypeRecording),
+			LoggableId:         egg.RecordingId,
+			Notes:              note,
+			Stock:              latestStockLog.Stock - float64(egg.Qty),
+		})
+	}
+	if len(logs) == 0 {
+		return nil
+	}
+
+	return s.StockLogRepo.WithTx(tx).CreateMany(ctx, logs, nil)
+}
+
+func (s *recordingService) logRecordingEggRollback(
+	ctx context.Context,
+	tx *gorm.DB,
+	eggs []entity.RecordingEgg,
+	note string,
+	actorID uint,
+) error {
+	if len(eggs) == 0 || s.StockLogRepo == nil {
+		return nil
+	}
+	if strings.TrimSpace(note) == "" || actorID == 0 {
+		return nil
+	}
+
+	for _, egg := range eggs {
+		if egg.ProductWarehouseId == 0 || egg.Qty <= 0 {
+			continue
+		}
+		log := &entity.StockLog{
+			ProductWarehouseId: egg.ProductWarehouseId,
+			CreatedBy:          actorID,
+			Decrease:           float64(egg.Qty),
+			LoggableType:       string(utils.StockLogTypeRecording),
+			LoggableId:         egg.RecordingId,
+			Notes:              note,
+		}
+		if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (s *recordingService) replenishRecordingEggs(
+	ctx context.Context,
+	tx *gorm.DB,
+	eggs []entity.RecordingEgg,
+	note string,
+	actorID uint,
+) error {
+	if len(eggs) == 0 || s.FifoSvc == nil {
+		return nil
+	}
+	if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
+		return errors.New("stock log repository is not available")
+	}
+
+	for _, egg := range eggs {
+		if egg.Id == 0 || egg.ProductWarehouseId == 0 || egg.Qty <= 0 {
+			continue
+		}
+		if _, err := s.FifoSvc.Replenish(ctx, commonSvc.StockReplenishRequest{
+			StockableKey:       fifo.StockableKeyRecordingEgg,
+			StockableID:        egg.Id,
+			ProductWarehouseID: egg.ProductWarehouseId,
+			Quantity:           float64(egg.Qty),
+			Tx:                 tx,
+		}); err != nil {
+			s.Log.Errorf("Failed to replenish FIFO stock for recording egg %d: %+v", egg.Id, err)
+			return err
+		}
+
+		if strings.TrimSpace(note) != "" && actorID != 0 {
+			log := &entity.StockLog{
+				ProductWarehouseId: egg.ProductWarehouseId,
+				CreatedBy:          actorID,
+				Increase:           float64(egg.Qty),
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         egg.RecordingId,
+				Notes:              note,
+			}
+			stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, egg.ProductWarehouseId, 1)
+			if err != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
+			}
+			if len(stockLogs) > 0 {
+				latestStockLog := stockLogs[0]
+				log.Stock = latestStockLog.Stock
+				log.Stock += log.Increase
+			} else {
+				log.Stock += log.Increase
+			}
+
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+type desiredStock struct {
+	Usage   float64
+	Pending float64
+}
+
+type desiredDepletion struct {
+	Qty     float64
+	Pending float64
+}
+
+func resetStockQuantitiesForFIFO(stocks []entity.RecordingStock, enabled bool) []desiredStock {
+	desired := make([]desiredStock, len(stocks))
+	for i := range stocks {
+		if stocks[i].UsageQty != nil {
+			desired[i].Usage = *stocks[i].UsageQty
+		}
+		if stocks[i].PendingQty != nil {
+			desired[i].Pending = *stocks[i].PendingQty
+		}
+		if !enabled {
+			continue
+		}
+		zero := 0.0
+		stocks[i].UsageQty = &zero
+		stocks[i].PendingQty = &zero
+	}
+	return desired
+}
+
+func applyStockDesiredQuantities(stocks []entity.RecordingStock, desired []desiredStock, enabled bool) {
+	if !enabled {
+		return
+	}
+	for i := range stocks {
+		if i >= len(desired) {
+			break
+		}
+		usage := desired[i].Usage
+		pending := desired[i].Pending
+		stocks[i].UsageQty = &usage
+		stocks[i].PendingQty = &pending
+	}
+}
+
+func resetDepletionQuantitiesForFIFO(depletions []entity.RecordingDepletion, enabled bool) []desiredDepletion {
+	desired := make([]desiredDepletion, len(depletions))
+	for i := range depletions {
+		desired[i].Qty = depletions[i].Qty
+		desired[i].Pending = depletions[i].PendingQty
+		if !enabled {
+			continue
+		}
+		depletions[i].Qty = 0
+		depletions[i].PendingQty = 0
+	}
+	return desired
+}
+
+func applyDepletionDesiredQuantities(depletions []entity.RecordingDepletion, desired []desiredDepletion, enabled bool) {
+	if !enabled {
+		return
+	}
+	for i := range depletions {
+		if i >= len(desired) {
+			break
+		}
+		depletions[i].Qty = desired[i].Qty
+		depletions[i].PendingQty = desired[i].Pending
+	}
+}
+
+func (s *recordingService) syncRecordingStocks(
+	ctx context.Context,
+	tx *gorm.DB,
+	recordingID uint,
+	existing []entity.RecordingStock,
+	incoming []validation.Stock,
+	note string,
+	actorID uint,
+) error {
+	if s.FifoSvc == nil {
+		if err := s.Repository.DeleteStocks(tx, recordingID); err != nil {
+			return err
+		}
+		mapped := recordingutil.MapStocks(recordingID, incoming)
+		return s.Repository.CreateStocks(tx, mapped)
+	}
+
+	existingByWarehouse := make(map[uint][]entity.RecordingStock)
+	for _, stock := range existing {
+		existingByWarehouse[stock.ProductWarehouseId] = append(existingByWarehouse[stock.ProductWarehouseId], stock)
+	}
+
+	stocksToConsume := make([]entity.RecordingStock, 0, len(incoming))
+	for _, item := range incoming {
+		list := existingByWarehouse[item.ProductWarehouseId]
+		var stock entity.RecordingStock
+		if len(list) > 0 {
+			stock = list[0]
+			existingByWarehouse[item.ProductWarehouseId] = list[1:]
+		} else {
+			zero := 0.0
+			stock = entity.RecordingStock{
+				RecordingId:        recordingID,
+				ProductWarehouseId: item.ProductWarehouseId,
+				UsageQty:           &zero,
+				PendingQty:         &zero,
+			}
+			if err := tx.Create(&stock).Error; err != nil {
+				return err
+			}
+		}
+
+		desired := item.Qty
+		stock.UsageQty = &desired
+		zero := 0.0
+		stock.PendingQty = &zero
+		stocksToConsume = append(stocksToConsume, stock)
+	}
+
+	var leftovers []entity.RecordingStock
+	for _, list := range existingByWarehouse {
+		leftovers = append(leftovers, list...)
+	}
+	if len(leftovers) > 0 {
+		if err := s.releaseRecordingStocks(ctx, tx, leftovers, note, actorID); err != nil {
+			return err
+		}
+		ids := make([]uint, 0, len(leftovers))
+		for _, stock := range leftovers {
+			if stock.Id != 0 {
+				ids = append(ids, stock.Id)
+			}
+		}
+		if len(ids) > 0 {
+			if err := tx.Where("id IN ?", ids).Delete(&entity.RecordingStock{}).Error; err != nil {
+				return err
+			}
+		}
+	}
+
+	if len(stocksToConsume) == 0 {
+		return nil
+	}
+	return s.consumeRecordingStocks(ctx, tx, stocksToConsume, note, actorID)
+}

internal/modules/production/recordings/validations/recording.validation.go

@@ -1,7 +1,5 @@
 package validation
 
-import "time"
-
 type (
 	Stock struct {
 		ProductWarehouseId uint    `json:"product_warehouse_id" validate:"required,number,min=1"`
@@ -37,7 +35,6 @@ type Update struct {
 type Query struct {
 	Page                  int    `query:"page" validate:"omitempty,number,min=1"`
 	Limit                 int    `query:"limit" validate:"omitempty,number,min=1,max=100"`
-	Offset                int    `query:"-" validate:"omitempty,number,min=0"`
 	ProjectFlockKandangId uint   `query:"project_flock_kandang_id" validate:"omitempty,number,min=1"`
 	Search                string `query:"search" validate:"omitempty,max=50"`
 }
@@ -47,9 +44,3 @@ type Approve struct {
 	ApprovableIds []uint  `json:"approvable_ids" validate:"required_strict,min=1,dive,gt=0"`
 	Notes         *string `json:"notes,omitempty" validate:"omitempty,max=500"`
 }
-
-type GetRecordingNextDay struct {
-	ProjectFlockKandangId uint       `json:"project_flock_kandang_id" query:"project_flock_kandang_id" validate:"required,number,min=1"`
-	RecordTime            *string    `json:"record_date" query:"record_date" validate:"required,datetime=2006-01-02"`
-	RecordTimeValue       *time.Time `query:"-" validate:"-"`
-}

internal/modules/production/transfer_layings/module.go

@@ -2,6 +2,7 @@ package transfer_layings
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
@@ -13,6 +14,7 @@ import (
 	rTransferLaying "gitlab.com/mbugroup/lti-api.git/internal/modules/production/transfer_layings/repositories"
 	sTransferLaying "gitlab.com/mbugroup/lti-api.git/internal/modules/production/transfer_layings/services"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 
 	rInventory "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
 	rWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/master/warehouses/repositories"
@@ -32,7 +34,45 @@ func (TransferLayingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, val
 	projectFlockPopulationRepo := rProjectFlock.NewProjectFlockPopulationRepository(db)
 	productWarehouseRepo := rInventory.NewProductWarehouseRepository(db)
 	warehouseRepo := rWarehouse.NewWarehouseRepository(db)
-	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
+
+	stockAllocationRepo := commonRepo.NewStockAllocationRepository(db)
+	fifoService := commonSvc.NewFifoService(db, stockAllocationRepo, productWarehouseRepo, utils.Log)
+
+	// daftarin jadi stockable
+	if err := fifoService.RegisterStockable(fifo.StockableConfig{
+		Key:   fifo.StockableKeyTransferToLayingIn,
+		Table: "laying_transfer_targets",
+		Columns: fifo.StockableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			TotalQuantity:      "total_qty",
+			TotalUsedQuantity:  "total_used",
+			CreatedAt:          "created_at",
+		},
+		OrderBy: []string{"created_at ASC", "id ASC"},
+	}); err != nil {
+		if !strings.Contains(strings.ToLower(err.Error()), "already registered") {
+			panic(fmt.Sprintf("failed to register transfer to laying stockable workflow: %v", err))
+		}
+	}
+
+	// daftarin jadi usable
+	if err := fifoService.RegisterUsable(fifo.UsableConfig{
+		Key:   fifo.UsableKeyTransferToLayingOut,
+		Table: "laying_transfer_sources",
+		Columns: fifo.UsableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			UsageQuantity:      "usage_qty",
+			PendingQuantity:    "pending_usage_qty",
+			CreatedAt:          "created_at",
+		},
+		OrderBy: []string{"created_at ASC", "id ASC"},
+	}); err != nil {
+		if !strings.Contains(strings.ToLower(err.Error()), "already registered") {
+			panic(fmt.Sprintf("failed to register transfer to laying usable workflow: %v", err))
+		}
+	}
 
 	approvalRepo := commonRepo.NewApprovalRepository(db)
 	approvalService := commonSvc.NewApprovalService(approvalRepo)
@@ -50,7 +90,7 @@ func (TransferLayingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, val
 		productWarehouseRepo,
 		warehouseRepo,
 		approvalService,
-		fifoStockV2Service,
+		fifoService,
 		validate,
 	)
 	userService := sUser.NewUserService(userRepo, validate)

internal/modules/production/transfer_layings/services/fifo_stock_v2_helper.go

@@ -1,87 +0,0 @@
-package service
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gorm.io/gorm"
-)
-
-const (
-	transferLayingInFunctionCode = "TRANSFER_TO_LAYING_IN"
-	transferLayingStockableLane  = "STOCKABLE"
-	transferLayingSourceTable    = "laying_transfer_targets"
-)
-
-func reflowTransferLayingScope(
-	ctx context.Context,
-	fifoStockV2Svc commonSvc.FifoStockV2Service,
-	tx *gorm.DB,
-	productWarehouseID uint,
-	asOf *time.Time,
-) error {
-	if fifoStockV2Svc == nil {
-		return fmt.Errorf("FIFO v2 service is not available")
-	}
-	if tx == nil {
-		return fmt.Errorf("transaction is required")
-	}
-	if productWarehouseID == 0 {
-		return fmt.Errorf("product warehouse id is required")
-	}
-
-	flagGroupCode, err := resolveTransferLayingFlagGroupByProductWarehouse(ctx, tx, productWarehouseID)
-	if err != nil {
-		return err
-	}
-	if strings.TrimSpace(flagGroupCode) == "" {
-		return fmt.Errorf("flag group code is not found for product warehouse %d", productWarehouseID)
-	}
-
-	_, err = fifoStockV2Svc.Reflow(ctx, commonSvc.FifoStockV2ReflowRequest{
-		FlagGroupCode:      flagGroupCode,
-		ProductWarehouseID: productWarehouseID,
-		AsOf:               asOf,
-		Tx:                 tx,
-	})
-	return err
-}
-
-func resolveTransferLayingFlagGroupByProductWarehouse(ctx context.Context, tx *gorm.DB, productWarehouseID uint) (string, error) {
-	type row struct {
-		FlagGroupCode string `gorm:"column:flag_group_code"`
-	}
-
-	var selected row
-	err := tx.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules rr").
-		Select("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 = ?", transferLayingStockableLane).
-		Where("rr.function_code = ?", transferLayingInFunctionCode).
-		Where("rr.source_table = ?", transferLayingSourceTable).
-		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.id ASC").
-		Limit(1).
-		Take(&selected).Error
-	if err != nil {
-		return "", err
-	}
-
-	return strings.TrimSpace(selected.FlagGroupCode), nil
-}

internal/modules/production/transfer_layings/services/transfer_laying.service.go

@@ -19,6 +19,7 @@ import (
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/transfer_layings/validations"
 	rStockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
@@ -50,7 +51,7 @@ type transferLayingService struct {
 	WarehouseRepo              rWarehouse.WarehouseRepository
 	StockLogRepo               rStockLogs.StockLogRepository
 	ApprovalService            commonSvc.ApprovalService
-	FifoStockV2Svc             commonSvc.FifoStockV2Service
+	FifoSvc                    commonSvc.FifoService
 }
 
 func NewTransferLayingService(
@@ -63,7 +64,7 @@ func NewTransferLayingService(
 	productWarehouseRepo rInventory.ProductWarehouseRepository,
 	warehouseRepo rWarehouse.WarehouseRepository,
 	approvalService commonSvc.ApprovalService,
-	fifoStockV2Svc commonSvc.FifoStockV2Service,
+	fifoSvc commonSvc.FifoService,
 	validate *validator.Validate,
 ) TransferLayingService {
 	return &transferLayingService{
@@ -79,7 +80,7 @@ func NewTransferLayingService(
 		WarehouseRepo:              warehouseRepo,
 		StockLogRepo:               rStockLogs.NewStockLogRepository(repo.DB()),
 		ApprovalService:            approvalService,
-		FifoStockV2Svc:             fifoStockV2Svc,
+		FifoSvc:                    fifoSvc,
 	}
 }
 
@@ -743,6 +744,7 @@ func (s transferLayingService) Approval(c *fiber.Ctx, req *validation.Approve) (
 	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
 		repoTx := s.Repository.WithTx(dbTransaction)
 		approvalSvcTx := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
+		stockAllocationRepo := commonRepo.NewStockAllocationRepository(dbTransaction)
 		sourceRepoTx := repository.NewLayingTransferSourceRepository(dbTransaction)
 		targetRepoTx := repository.NewLayingTransferTargetRepository(dbTransaction)
 		stockLogRepoTx := rStockLogs.NewStockLogRepository(dbTransaction)
@@ -769,9 +771,6 @@ func (s transferLayingService) Approval(c *fiber.Ctx, req *validation.Approve) (
 			}
 
 			if action == entity.ApprovalActionApproved {
-				if s.FifoStockV2Svc == nil {
-					return fiber.NewError(fiber.StatusInternalServerError, "FIFO v2 service is not available")
-				}
 
 				sources, err := sourceRepoTx.GetByLayingTransferId(c.Context(), approvableID)
 				if err != nil {
@@ -793,70 +792,58 @@ func (s transferLayingService) Approval(c *fiber.Ctx, req *validation.Approve) (
 					totalSourceRequested += source.RequestedQty
 				}
 
-				sourceBeforeUsage := make(map[uint]float64, len(sources))
-				affectedPW := make(map[uint]struct{})
-
 				for _, source := range sources {
 					if source.ProductWarehouseId == nil {
 						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Source product warehouse tidak ditemukan untuk transfer %d", approvableID))
 					}
 
-					sourceShare := 0.0
+					sourceShare := (source.RequestedQty / totalSourceRequested) * totalTargetQty
-					if totalSourceRequested > 0 {
+
-						sourceShare = (source.RequestedQty / totalSourceRequested) * totalTargetQty
+					consumeResult, err := s.FifoSvc.Consume(c.Context(), commonSvc.StockConsumeRequest{
+						UsableKey:          fifo.UsableKeyTransferToLayingOut,
+						UsableID:           source.Id,
+						ProductWarehouseID: *source.ProductWarehouseId,
+						Quantity:           sourceShare,
+						AllowPending:       false,
+						Tx:                 dbTransaction,
+					})
+					if err != nil {
+						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Gagal consume FIFO stock: %v", err))
 					}
 
-					sourceBeforeUsage[source.Id] = source.UsageQty
-
 					if err := sourceRepoTx.PatchOne(c.Context(), source.Id, map[string]interface{}{
-						"usage_qty":         sourceShare,
+						"usage_qty":         source.UsageQty + consumeResult.UsageQuantity,
-						"pending_usage_qty": 0,
+						"pending_usage_qty": consumeResult.PendingQuantity,
 					}, nil); err != nil {
 						return fiber.NewError(fiber.StatusInternalServerError, "Gagal update source usage qty")
 					}
 
-					affectedPW[*source.ProductWarehouseId] = struct{}{}
+					targetShares := distributeProportionalWithRounding(targets, totalTargetQty, sourceShare)
-				}
 
-				for _, target := range targets {
+					for i, target := range targets {
-					if target.ProductWarehouseId == nil {
+						roundedQty := math.Round(targetShares[i])
-						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Target product warehouse tidak ditemukan untuk transfer %d", approvableID))
+						if roundedQty <= 0 {
-					}
-
-					if err := targetRepoTx.PatchOne(c.Context(), target.Id, map[string]interface{}{
-						"total_qty": target.TotalQty,
-					}, nil); err != nil {
-						return fiber.NewError(fiber.StatusInternalServerError, "Gagal update target total qty")
-					}
-					affectedPW[*target.ProductWarehouseId] = struct{}{}
-				}
-
-				for pwID := range affectedPW {
-					asOfCopy := transfer.TransferDate
-					if err := reflowTransferLayingScope(c.Context(), s.FifoStockV2Svc, dbTransaction, pwID, &asOfCopy); err != nil {
-						return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Gagal reflow FIFO stock transfer laying (pw=%d): %v", pwID, err))
-					}
-				}
-
-				for _, source := range sources {
-					if source.ProductWarehouseId == nil {
 							continue
 						}
-					refreshedSource, err := sourceRepoTx.GetByID(c.Context(), source.Id, nil)
+						mappingAllocation := &entity.StockAllocation{
-					if err != nil {
+							StockableType:      fifo.UsableKeyTransferToLayingOut.String(),
-						return fiber.NewError(fiber.StatusInternalServerError, "Gagal refresh source transfer setelah reflow")
+							StockableId:        source.Id,
+							UsableType:         fifo.StockableKeyTransferToLayingIn.String(),
+							UsableId:           target.Id,
+							ProductWarehouseId: *source.ProductWarehouseId,
+							Qty:                roundedQty,
+							Status:             entity.StockAllocationStatusActive,
+						}
+						if err := stockAllocationRepo.CreateOne(c.Context(), mappingAllocation, nil); err != nil {
+							return fiber.NewError(fiber.StatusInternalServerError, "Gagal create mapping allocation source→target")
 						}
-
-					usageDelta := refreshedSource.UsageQty - sourceBeforeUsage[source.Id]
-					if usageDelta <= 0 {
-						continue
 					}
 
 					stockLogDecrease := &entity.StockLog{
 						ProductWarehouseId: *source.ProductWarehouseId,
 						CreatedBy:          actorID,
 						Increase:           0,
-						Decrease:           usageDelta,
+						Decrease:           sourceShare,
 						LoggableType:       string(utils.StockLogTypeTransferLaying),
 						LoggableId:         approvableID,
 						Notes:              fmt.Sprintf("TL #%s", transfer.TransferNumber),
@@ -880,7 +867,26 @@ func (s transferLayingService) Approval(c *fiber.Ctx, req *validation.Approve) (
 
 				for _, target := range targets {
 					if target.ProductWarehouseId == nil {
-						continue
+						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Target product warehouse tidak ditemukan untuk transfer %d", approvableID))
+					}
+
+					note := fmt.Sprintf("Transfer to Laying #%s", transfer.TransferNumber)
+					_, err := s.FifoSvc.Replenish(c.Context(), commonSvc.StockReplenishRequest{
+						StockableKey:       fifo.StockableKeyTransferToLayingIn,
+						StockableID:        target.Id,
+						ProductWarehouseID: *target.ProductWarehouseId,
+						Quantity:           target.TotalQty,
+						Note:               &note,
+						Tx:                 dbTransaction,
+					})
+					if err != nil {
+						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Gagal replenish stock ke target warehouse: %v", err))
+					}
+
+					if err := targetRepoTx.PatchOne(c.Context(), target.Id, map[string]interface{}{
+						"total_qty": target.TotalQty,
+					}, nil); err != nil {
+						return fiber.NewError(fiber.StatusInternalServerError, "Gagal update target total qty")
 					}
 
 					stockLogIncrease := &entity.StockLog{

internal/modules/production/uniformities/services/uniformity.service.go

@@ -465,11 +465,6 @@ func (s *uniformityService) CreateOne(c *fiber.Ctx, req *validation.Create, file
 		); err != nil {
 			return err
 		}
-		if strings.EqualFold(category, string(utils.ProjectFlockCategoryGrowing)) {
-			if err := s.updateGrowingFcrForWeek(tx, createBody.ProjectFlockKandangId, createBody.Week, calculation.MeanUp); err != nil {
-				return err
-			}
-		}
 		return nil
 	}); err != nil {
 		s.Log.Errorf("Failed to create uniformity: %+v", err)
@@ -638,9 +633,6 @@ func (s uniformityService) UpdateOne(c *fiber.Ctx, req *validation.Update, id ui
 			return nil, err
 		}
 
-		if err := s.updateGrowingFcrFromUniformity(c.Context(), id); err != nil {
-			return nil, err
-		}
 		return s.GetOne(c, id)
 	}
 
@@ -702,10 +694,6 @@ func (s uniformityService) UpdateOne(c *fiber.Ctx, req *validation.Update, id ui
 		}
 	}
 
-	if err := s.updateGrowingFcrFromUniformity(c.Context(), id); err != nil {
-		return nil, err
-	}
-
 	return s.GetOne(c, id)
 }
 
@@ -736,48 +724,7 @@ func (s uniformityService) DeleteOne(c *fiber.Ctx, id uint) error {
 		return err
 	}
 
-	type uniformityContext struct {
+	if err := s.Repository.DeleteOne(c.Context(), id); err != nil {
-		ID                    uint
-		Week                  int
-		ProjectFlockKandangId uint
-		Category              string
-	}
-	var ctxRow uniformityContext
-	if err := s.Repository.DB().WithContext(c.Context()).
-		Table("project_flock_kandang_uniformity u").
-		Select("u.id, u.week, u.project_flock_kandang_id, pf.category").
-		Joins("JOIN project_flock_kandangs pfk ON pfk.id = u.project_flock_kandang_id").
-		Joins("JOIN project_flocks pf ON pf.id = pfk.project_flock_id").
-		Where("u.id = ?", id).
-		Scan(&ctxRow).Error; err != nil {
-		return err
-	}
-
-	if ctxRow.ID == 0 {
-		return fiber.NewError(fiber.StatusNotFound, "Uniformity not found")
-	}
-
-	if err := s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
-		repoTx := s.Repository.WithTx(tx)
-		if err := repoTx.DeleteOne(c.Context(), id); err != nil {
-			return err
-		}
-
-		if strings.EqualFold(ctxRow.Category, string(utils.ProjectFlockCategoryGrowing)) {
-			startDay := (ctxRow.Week-1)*7 + 1
-			endDay := ctxRow.Week * 7
-			if ctxRow.Week > 0 {
-				if err := tx.Model(&entity.Recording{}).
-					Where("project_flock_kandangs_id = ?", ctxRow.ProjectFlockKandangId).
-					Where("day BETWEEN ? AND ?", startDay, endDay).
-					Update("fcr_value", 0).Error; err != nil {
-					return err
-				}
-			}
-		}
-
-		return nil
-	}); err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return fiber.NewError(fiber.StatusNotFound, "Uniformity not found")
 		}
@@ -787,58 +734,6 @@ func (s uniformityService) DeleteOne(c *fiber.Ctx, id uint) error {
 	return nil
 }
 
-func (s *uniformityService) updateGrowingFcrFromUniformity(ctx context.Context, uniformityID uint) error {
-	if uniformityID == 0 {
-		return nil
-	}
-
-	type uniformityRow struct {
-		ID                    uint
-		Week                  int
-		MeanUp                float64
-		ProjectFlockKandangId uint
-		Category              string
-	}
-	var row uniformityRow
-	if err := s.Repository.DB().WithContext(ctx).
-		Table("project_flock_kandang_uniformity u").
-		Select("u.id, u.week, u.mean_up, u.project_flock_kandang_id, pf.category").
-		Joins("JOIN project_flock_kandangs pfk ON pfk.id = u.project_flock_kandang_id").
-		Joins("JOIN project_flocks pf ON pf.id = pfk.project_flock_id").
-		Where("u.id = ?", uniformityID).
-		Scan(&row).Error; err != nil {
-		return err
-	}
-	if row.ID == 0 {
-		return nil
-	}
-	if !strings.EqualFold(row.Category, string(utils.ProjectFlockCategoryGrowing)) {
-		return nil
-	}
-
-	return s.updateGrowingFcrForWeek(s.Repository.DB().WithContext(ctx), row.ProjectFlockKandangId, row.Week, row.MeanUp)
-}
-
-func (s *uniformityService) updateGrowingFcrForWeek(tx *gorm.DB, projectFlockKandangID uint, week int, meanUp float64) error {
-	if tx == nil || projectFlockKandangID == 0 || week <= 0 {
-		return nil
-	}
-	startDay := (week-1)*7 + 1
-	endDay := week * 7
-	meanBw := meanUp / 1.10
-	if meanBw <= 0 {
-		return tx.Model(&entity.Recording{}).
-			Where("project_flock_kandangs_id = ?", projectFlockKandangID).
-			Where("day BETWEEN ? AND ?", startDay, endDay).
-			Update("fcr_value", 0).Error
-	}
-
-	return tx.Model(&entity.Recording{}).
-		Where("project_flock_kandangs_id = ?", projectFlockKandangID).
-		Where("day BETWEEN ? AND ?", startDay, endDay).
-		Update("fcr_value", gorm.Expr("CASE WHEN feed_intake IS NULL OR feed_intake = 0 THEN 0 ELSE feed_intake / ? END", meanBw)).Error
-}
-
 func (s uniformityService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entity.ProjectFlockKandangUniformity, error) {
 	if err := s.Validate.Struct(req); err != nil {
 		return nil, err

internal/modules/purchases/dto/purchase.dto.go

@@ -29,7 +29,7 @@ type PurchaseListDTO struct {
 	DueDate        *time.Time                        `json:"due_date"`
 	CreatedUser    *userDTO.UserRelationDTO          `json:"created_user"`
 	RequesterName  string                            `json:"requester_name"`
-	PoExpedition   []PoExpeditionDTO                `json:"po_expedition"`
+	PoExpedition   []string                          `json:"po_expedition"`
 	Products       []productDTO.ProductRelationDTO   `json:"products"`
 	Location       *locationDTO.LocationRelationDTO  `json:"location"`
 	Area           *areaDTO.AreaRelationDTO          `json:"area"`
@@ -67,12 +67,6 @@ type PurchaseItemDTO struct {
 	VehicleNumber      *string                            `json:"vehicle_number"`
 	TransportPerItem   *float64                           `json:"transport_per_item,omitempty"`
 	ExpeditionVendor   *supplierDTO.SupplierRelationDTO   `json:"expedition_vendor,omitempty"`
-	HasChickin         bool                               `json:"has_chickin"`
-}
-
-type PoExpeditionDTO struct {
-	Id       uint64 `json:"id"`
-	Refrence string `json:"refrence"`
 }
 
 func ToPurchaseRelationDTO(p *entity.Purchase) PurchaseRelationDTO {
@@ -101,7 +95,6 @@ func ToPurchaseItemDTO(item entity.PurchaseItem) PurchaseItemDTO {
 		TravelNumber:       item.TravelNumber,
 		TravelDocumentPath: item.TravelNumberDocs,
 		VehicleNumber:      item.VehicleNumber,
-		HasChickin:         item.HasChickin,
 	}
 
 	if item.Product != nil && item.Product.Id != 0 {
@@ -171,12 +164,12 @@ func ToPurchaseListDTO(p entity.Purchase) PurchaseListDTO {
 	}
 
 	var (
-		poExpedition = make([]PoExpeditionDTO, 0)
+		poExpedition []string
 		location     *locationDTO.LocationRelationDTO
 		area         *areaDTO.AreaRelationDTO
 	)
 	productMap := make(map[uint]productDTO.ProductRelationDTO)
-	expeditionRefSet := make(map[uint64]struct{})
+	expeditionRefSet := make(map[string]struct{})
 	for i := range p.Items {
 		item := p.Items[i]
 		if item.Product != nil && item.Product.Id != 0 {
@@ -185,15 +178,11 @@ func ToPurchaseListDTO(p entity.Purchase) PurchaseListDTO {
 			}
 		}
 		if item.ExpenseNonstock != nil && item.ExpenseNonstock.Expense != nil {
-			exp := item.ExpenseNonstock.Expense
+			ref := strings.TrimSpace(item.ExpenseNonstock.Expense.ReferenceNumber)
-			ref := strings.TrimSpace(exp.ReferenceNumber)
+			if ref != "" {
-			if exp.Id != 0 && ref != "" {
+				if _, exists := expeditionRefSet[ref]; !exists {
-				if _, exists := expeditionRefSet[exp.Id]; !exists {
+					expeditionRefSet[ref] = struct{}{}
-					expeditionRefSet[exp.Id] = struct{}{}
+					poExpedition = append(poExpedition, ref)
-					poExpedition = append(poExpedition, PoExpeditionDTO{
-						Id:       exp.Id,
-						Refrence: ref,
-					})
 				}
 			}
 		}

internal/modules/purchases/module.go

@@ -23,6 +23,7 @@ import (
 	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
 	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
 	utils "gitlab.com/mbugroup/lti-api.git/internal/utils"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 	"gorm.io/gorm"
 )
 
@@ -39,6 +40,7 @@ func (PurchaseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	expenseRepository := expenseRepo.NewExpenseRepository(db)
 	expenseRealizationRepo := expenseRepo.NewExpenseRealizationRepository(db)
 	projectFlockKandangRepository := projectFlockKandangRepo.NewProjectFlockKandangRepository(db)
+	stockAllocRepo := commonRepo.NewStockAllocationRepository(db)
 
 	approvalRepo := commonRepo.NewApprovalRepository(db)
 	approvalService := commonSvc.NewApprovalService(approvalRepo)
@@ -71,7 +73,19 @@ func (PurchaseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		expenseServiceInstance,
 	)
 
-	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
+	fifoService := commonSvc.NewFifoService(db, stockAllocRepo, productWarehouseRepo, utils.Log)
+	_ = fifoService.RegisterStockable(fifo.StockableConfig{
+		Key:   fifo.StockableKeyPurchaseItems,
+		Table: "purchase_items",
+		Columns: fifo.StockableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			TotalQuantity:      "total_qty",
+			TotalUsedQuantity:  "total_used",
+			CreatedAt:          "id",
+		},
+		OrderBy: []string{"id ASC"},
+	})
 
 	purchaseService := service.NewPurchaseService(
 		validate,
@@ -83,7 +97,7 @@ func (PurchaseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		projectFlockKandangRepository,
 		approvalService,
 		expenseBridge,
-		fifoStockV2Service,
+		fifoService,
 		documentSvc,
 	)
 

internal/modules/purchases/services/fifo_stock_v2_helper.go

@@ -1,93 +0,0 @@
-package service
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	"gorm.io/gorm"
-)
-
-const (
-	purchaseInFunctionCode = "PURCHASE_IN"
-	purchaseStockableLane  = "STOCKABLE"
-	purchaseSourceTable    = "purchase_items"
-)
-
-func reflowPurchaseScope(
-	ctx context.Context,
-	fifoStockV2Svc commonSvc.FifoStockV2Service,
-	tx *gorm.DB,
-	productWarehouseID uint,
-	asOf *time.Time,
-) error {
-	if fifoStockV2Svc == nil {
-		return fmt.Errorf("FIFO v2 service is not available")
-	}
-	if productWarehouseID == 0 {
-		return fmt.Errorf("product warehouse id is required")
-	}
-
-	flagGroupCode, err := resolvePurchaseFlagGroupByProductWarehouse(ctx, tx, productWarehouseID)
-	if err != nil {
-		return err
-	}
-	if strings.TrimSpace(flagGroupCode) == "" {
-		return fmt.Errorf("flag group code is not found for product warehouse %d", productWarehouseID)
-	}
-
-	_, err = fifoStockV2Svc.Reflow(ctx, commonSvc.FifoStockV2ReflowRequest{
-		FlagGroupCode:      flagGroupCode,
-		ProductWarehouseID: productWarehouseID,
-		AsOf:               asOf,
-		Tx:                 tx,
-	})
-	return err
-}
-
-func resolvePurchaseFlagGroupByProductWarehouse(ctx context.Context, tx *gorm.DB, productWarehouseID uint) (string, error) {
-	type row struct {
-		FlagGroupCode string `gorm:"column:flag_group_code"`
-	}
-
-	var selected row
-	err := tx.WithContext(ctx).
-		Table("fifo_stock_v2_route_rules rr").
-		Select("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 = ?", purchaseStockableLane).
-		Where("rr.function_code = ?", purchaseInFunctionCode).
-		Where("rr.source_table = ?", purchaseSourceTable).
-		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.id ASC").
-		Limit(1).
-		Take(&selected).Error
-	if err != nil {
-		return "", err
-	}
-
-	return strings.TrimSpace(selected.FlagGroupCode), nil
-}
-
-func assignEarliestAsOf(m map[uint]time.Time, productWarehouseID uint, asOf time.Time) {
-	if productWarehouseID == 0 {
-		return
-	}
-	if current, ok := m[productWarehouseID]; !ok || asOf.Before(current) {
-		m[productWarehouseID] = asOf
-	}
-}

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

@@ -57,7 +57,7 @@ type purchaseService struct {
 	ProjectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository
 	ApprovalSvc             commonSvc.ApprovalService
 	ExpenseBridge           PurchaseExpenseBridge
-	FifoStockV2Svc          commonSvc.FifoStockV2Service
+	FifoSvc                 commonSvc.FifoService
 	DocumentSvc             commonSvc.DocumentService
 	approvalWorkflow        approvalutils.ApprovalWorkflowKey
 }
@@ -77,7 +77,7 @@ func NewPurchaseService(
 	projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository,
 	approvalSvc commonSvc.ApprovalService,
 	expenseBridge PurchaseExpenseBridge,
-	fifoStockV2Svc commonSvc.FifoStockV2Service,
+	fifoSvc commonSvc.FifoService,
 	documentSvc commonSvc.DocumentService,
 ) PurchaseService {
 	return &purchaseService{
@@ -91,7 +91,7 @@ func NewPurchaseService(
 		ProjectFlockKandangRepo: projectFlockKandangRepo,
 		ApprovalSvc:             approvalSvc,
 		ExpenseBridge:           expenseBridge,
-		FifoStockV2Svc:          fifoStockV2Svc,
+		FifoSvc:                 fifoSvc,
 		DocumentSvc:             documentSvc,
 		approvalWorkflow:        utils.ApprovalWorkflowPurchase,
 	}
@@ -255,17 +255,6 @@ func (s *purchaseService) GetOne(c *fiber.Ctx, id uint) (*entity.Purchase, error
 	if err := s.attachLatestApproval(c.Context(), purchase); err != nil {
 		s.Log.Warnf("Unable to attach latest approval for purchase %d: %+v", id, err)
 	}
-	if len(purchase.Items) > 0 {
-		lockedIDs, err := s.resolveChickinLockedItemIDs(c.Context(), s.PurchaseRepo.DB(), purchase.Items)
-		if err != nil {
-			return nil, err
-		}
-		for i := range purchase.Items {
-			if _, ok := lockedIDs[purchase.Items[i].Id]; ok {
-				purchase.Items[i].HasChickin = true
-			}
-		}
-	}
 	s.applyTravelDocumentURLs(c.Context(), purchase)
 
 	return purchase, nil
@@ -509,37 +498,6 @@ func (s *purchaseService) ApproveStaffPurchase(c *fiber.Ctx, id uint, req *valid
 		return nil, utils.BadRequest("Items must not be empty for staff approval")
 	}
 
-	if action == entity.ApprovalActionApproved {
-		itemByID := make(map[uint]entity.PurchaseItem, len(purchase.Items))
-		for i := range purchase.Items {
-			if purchase.Items[i].Id == 0 {
-				continue
-			}
-			itemByID[purchase.Items[i].Id] = purchase.Items[i]
-		}
-		lockedIDs, err := s.resolveChickinLockedItemIDs(ctx, s.PurchaseRepo.DB(), purchase.Items)
-		if err != nil {
-			return nil, err
-		}
-		if len(lockedIDs) > 0 {
-			for _, payload := range req.Items {
-				if payload.PurchaseItemID == 0 || payload.Qty == nil {
-					continue
-				}
-				if _, locked := lockedIDs[payload.PurchaseItemID]; !locked {
-					continue
-				}
-				item, ok := itemByID[payload.PurchaseItemID]
-				if !ok {
-					continue
-				}
-				if *payload.Qty != item.SubQty {
-					return nil, utils.BadRequest("Purchase sudah chickin, qty tidak bisa diubah")
-				}
-			}
-		}
-	}
-
 	payload, err := s.buildStaffAdjustmentPayload(c.Context(), purchase, req, syncReceiving)
 	if err != nil {
 		return nil, err
@@ -787,37 +745,6 @@ func (s *purchaseService) ReceiveProducts(c *fiber.Ctx, id uint, req *validation
 			req.Items[idx].TravelDocumentPath = &uploadedURL
 		}
 	}
-	if action == entity.ApprovalActionApproved {
-		itemByID := make(map[uint]entity.PurchaseItem, len(purchase.Items))
-		for i := range purchase.Items {
-			if purchase.Items[i].Id == 0 {
-				continue
-			}
-			itemByID[purchase.Items[i].Id] = purchase.Items[i]
-		}
-		lockedIDs, err := s.resolveChickinLockedItemIDs(ctx, s.PurchaseRepo.DB(), purchase.Items)
-		if err != nil {
-			return nil, err
-		}
-		if len(lockedIDs) > 0 {
-			for _, payload := range req.Items {
-				if _, used := lockedIDs[payload.PurchaseItemID]; !used {
-					continue
-				}
-				item, ok := itemByID[payload.PurchaseItemID]
-				if !ok {
-					continue
-				}
-				receivedQty := item.SubQty
-				if payload.ReceivedQty != nil {
-					receivedQty = *payload.ReceivedQty
-				}
-				if receivedQty != item.TotalQty {
-					return nil, utils.BadRequest("Purchase sudah chickin, qty penerimaan tidak bisa diubah")
-				}
-			}
-		}
-	}
 
 	itemMap := make(map[uint]*entity.PurchaseItem, len(purchase.Items))
 	for i := range purchase.Items {
@@ -970,11 +897,21 @@ func (s *purchaseService) ReceiveProducts(c *fiber.Ctx, id uint, req *validation
 		pwRepoTx := rProductWarehouse.NewProductWarehouseRepository(tx)
 		stockLogRepoTx := rStockLogs.NewStockLogRepository(tx)
 
+		deltas := make(map[uint]float64)
 		affected := make(map[uint]struct{})
 		updates := make([]rPurchase.PurchaseReceivingUpdate, 0, len(prepared))
 		priceUpdates := make([]rPurchase.PurchasePricingUpdate, 0, len(prepared))
 		totalQtyDeltas := make(map[uint]float64)
-		reflowAsOfByPW := make(map[uint]time.Time)
+		fifoAdds := make([]struct {
+			itemID uint
+			pwID   uint
+			qty    float64
+		}, 0, len(prepared))
+		fifoSubs := make([]struct {
+			itemID uint
+			pwID   uint
+			qty    float64
+		}, 0, len(prepared))
 		logEntries := make([]struct {
 			itemID uint
 			pwID   uint
@@ -997,15 +934,6 @@ func (s *purchaseService) ReceiveProducts(c *fiber.Ctx, id uint, req *validation
 			if err != nil {
 				return err
 			}
-			// Safety: ensure the PW we got matches the purchase item product.
-			if pwDetail, err := pwRepoTx.GetDetailByID(c.Context(), pwID); err != nil {
-				return err
-			} else if pwDetail.ProductId != uint(item.ProductId) {
-				return fiber.NewError(
-					fiber.StatusBadRequest,
-					fmt.Sprintf("Product warehouse %d belongs to product %d, not purchase item product %d", pwID, pwDetail.ProductId, item.ProductId),
-				)
-			}
 			newPWID = &pwID
 
 			deltaQty := prep.receivedQty - item.TotalQty
@@ -1016,14 +944,31 @@ func (s *purchaseService) ReceiveProducts(c *fiber.Ctx, id uint, req *validation
 					delta  float64
 				}{itemID: item.Id, pwID: *newPWID, delta: deltaQty})
 			}
-			if newPWID != nil {
+			switch {
-				assignEarliestAsOf(reflowAsOfByPW, *newPWID, prep.receivedDate.UTC())
+			case deltaQty > 0 && newPWID != nil:
-			}
+				if s.FifoSvc != nil {
-			if deltaQty != 0 {
+					fifoAdds = append(fifoAdds, struct {
+						itemID uint
+						pwID   uint
+						qty    float64
+					}{itemID: item.Id, pwID: *newPWID, qty: deltaQty})
+				} else {
+					deltas[*newPWID] += deltaQty
 					totalQtyDeltas[item.Id] += deltaQty
 				}
-			if deltaQty < 0 && newPWID != nil {
+			case deltaQty < 0 && newPWID != nil:
+				if s.FifoSvc != nil {
+					fifoSubs = append(fifoSubs, struct {
+						itemID uint
+						pwID   uint
+						qty    float64
+					}{itemID: item.Id, pwID: *newPWID, qty: deltaQty})
 					affected[*newPWID] = struct{}{}
+				} else {
+					deltas[*newPWID] += deltaQty // negative
+					affected[*newPWID] = struct{}{}
+					totalQtyDeltas[item.Id] += deltaQty
+				}
 			}
 
 			dateCopy := prep.receivedDate
@@ -1059,6 +1004,10 @@ func (s *purchaseService) ReceiveProducts(c *fiber.Ctx, id uint, req *validation
 			return err
 		}
 
+		if err := pwRepoTx.AdjustQuantities(c.Context(), deltas, nil); err != nil {
+			return err
+		}
+
 		if len(priceUpdates) > 0 {
 			if err := repoTx.UpdatePricing(c.Context(), purchase.Id, priceUpdates); err != nil {
 				return err
@@ -1088,13 +1037,32 @@ func (s *purchaseService) ReceiveProducts(c *fiber.Ctx, id uint, req *validation
 			}
 		}
 
-		if len(reflowAsOfByPW) > 0 {
+		if s.FifoSvc != nil {
-			if s.FifoStockV2Svc == nil {
+			for _, adj := range fifoAdds {
-				return fiber.NewError(fiber.StatusInternalServerError, "FIFO v2 service is not available")
+				if adj.pwID == 0 || adj.qty <= 0 {
+					continue
 				}
-			for pwID, asOf := range reflowAsOfByPW {
+				if _, err := s.FifoSvc.Replenish(c.Context(), commonSvc.StockReplenishRequest{
-				asOfCopy := asOf
+					StockableKey:       fifo.StockableKeyPurchaseItems,
-				if err := reflowPurchaseScope(c.Context(), s.FifoStockV2Svc, tx, pwID, &asOfCopy); err != nil {
+					StockableID:        adj.itemID,
+					ProductWarehouseID: adj.pwID,
+					Quantity:           adj.qty,
+					Tx:                 tx,
+				}); err != nil {
+					return err
+				}
+			}
+			for _, adj := range fifoSubs {
+				if adj.pwID == 0 || adj.qty >= 0 {
+					continue
+				}
+				if err := s.FifoSvc.AdjustStockableQuantity(c.Context(), commonSvc.StockAdjustRequest{
+					StockableKey:       fifo.StockableKeyPurchaseItems,
+					StockableID:        adj.itemID,
+					ProductWarehouseID: adj.pwID,
+					Quantity:           adj.qty,
+					Tx:                 tx,
+				}); err != nil {
 					return err
 				}
 			}
@@ -1381,14 +1349,6 @@ func (s *purchaseService) DeletePurchase(c *fiber.Ctx, id uint) error {
 	}
 
 	transactionErr := s.PurchaseRepo.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		lockedIDs, err := s.resolveChickinLockedItemIDs(ctx, tx, itemsToDelete)
-		if err != nil {
-			return err
-		}
-		if len(lockedIDs) > 0 {
-			return utils.BadRequest("Purchase already chickin, failed to delete purchase")
-		}
-
 		if err := s.rollbackPurchaseStock(ctx, tx, itemsToDelete, note, actorID); err != nil {
 			return err
 		}
@@ -1405,10 +1365,6 @@ func (s *purchaseService) DeletePurchase(c *fiber.Ctx, id uint) error {
 		return nil
 	})
 	if transactionErr != nil {
-		var fe *fiber.Error
-		if errors.As(transactionErr, &fe) {
-			return fe
-		}
 		if errors.Is(transactionErr, gorm.ErrRecordNotFound) {
 			return utils.NotFound("Purchase not found")
 		}
@@ -1437,9 +1393,10 @@ func (s *purchaseService) rollbackPurchaseStock(ctx context.Context, tx *gorm.DB
 		return nil
 	}
 
+	pwRepoTx := rProductWarehouse.NewProductWarehouseRepository(tx)
 	stockLogRepoTx := rStockLogs.NewStockLogRepository(tx)
+	deltas := make(map[uint]float64)
 	affected := make(map[uint]struct{})
-	reflowAsOfByPW := make(map[uint]time.Time)
 	logEntries := make([]struct {
 		pwID uint
 		qty  float64
@@ -1455,42 +1412,41 @@ func (s *purchaseService) rollbackPurchaseStock(ctx context.Context, tx *gorm.DB
 		pwID := *item.ProductWarehouseId
 		qty := item.TotalQty
 
-		if err := tx.WithContext(ctx).
+		if s.FifoSvc != nil {
-			Model(&entity.PurchaseItem{}).
+			if err := s.FifoSvc.AdjustStockableQuantity(ctx, commonSvc.StockAdjustRequest{
-			Where("id = ?", item.Id).
+				StockableKey:       fifo.StockableKeyPurchaseItems,
-			Update("total_qty", 0).Error; err != nil {
+				StockableID:        item.Id,
+				ProductWarehouseID: pwID,
+				Quantity:           -qty,
+				Tx:                 tx,
+			}); err != nil {
 				return err
 			}
-
+			logEntries = append(logEntries, struct {
-		affected[pwID] = struct{}{}
+				pwID uint
-		if item.ReceivedDate != nil {
+				qty  float64
-			assignEarliestAsOf(reflowAsOfByPW, pwID, item.ReceivedDate.UTC())
+			}{pwID: pwID, qty: qty})
-		} else {
+			continue
-			assignEarliestAsOf(reflowAsOfByPW, pwID, time.Now().UTC())
 		}
+
+		deltas[pwID] -= qty
+		affected[pwID] = struct{}{}
 		logEntries = append(logEntries, struct {
 			pwID uint
 			qty  float64
 		}{pwID: pwID, qty: qty})
 	}
 
-	if len(reflowAsOfByPW) > 0 {
+	if s.FifoSvc == nil && len(deltas) > 0 {
-		if s.FifoStockV2Svc == nil {
+		if err := pwRepoTx.AdjustQuantities(ctx, deltas, nil); err != nil {
-			return fiber.NewError(fiber.StatusInternalServerError, "FIFO v2 service is not available")
-		}
-		for pwID, asOf := range reflowAsOfByPW {
-			asOfCopy := asOf
-			if err := reflowPurchaseScope(ctx, s.FifoStockV2Svc, tx, pwID, &asOfCopy); err != nil {
 			return err
 		}
-		}
-	}
-
 		if len(affected) > 0 {
-		if err := rProductWarehouse.NewProductWarehouseRepository(tx).CleanupEmpty(ctx, affected); err != nil {
+			if err := pwRepoTx.CleanupEmpty(ctx, affected); err != nil {
 				return err
 			}
 		}
+	}
 
 	if strings.TrimSpace(note) != "" && actorID != 0 && len(logEntries) > 0 {
 		logs := make([]*entity.StockLog, 0, len(logEntries))
@@ -1885,68 +1841,6 @@ func (s *purchaseService) applyTravelDocumentURLs(ctx context.Context, purchase
 	}
 }
 
-func collectPurchaseItemIDs(items []entity.PurchaseItem) []uint {
-	itemIDs := make([]uint, 0, len(items))
-	for i := range items {
-		if items[i].Id == 0 {
-			continue
-		}
-		itemIDs = append(itemIDs, items[i].Id)
-	}
-	return itemIDs
-}
-
-func (s *purchaseService) resolveChickinLockedItemIDs(ctx context.Context, db *gorm.DB, items []entity.PurchaseItem) (map[uint]struct{}, error) {
-	itemIDs := collectPurchaseItemIDs(items)
-	return s.resolveChickinLockedItemIDsByItemID(ctx, db, itemIDs)
-}
-
-func (s *purchaseService) resolveChickinLockedItemIDsByItemID(ctx context.Context, db *gorm.DB, itemIDs []uint) (map[uint]struct{}, error) {
-	locked := make(map[uint]struct{})
-	if len(itemIDs) == 0 {
-		return locked, nil
-	}
-	if db == nil {
-		return nil, errors.New("database is required")
-	}
-
-	var allocationLockedIDs []uint
-	if err := db.WithContext(ctx).
-		Model(&entity.StockAllocation{}).
-		Distinct("stockable_id").
-		Where("stockable_type = ? AND stockable_id IN ? AND usable_type = ? AND status IN ? AND allocation_purpose = ?",
-			fifo.StockableKeyPurchaseItems.String(),
-			itemIDs,
-			fifo.UsableKeyProjectChickin.String(),
-			[]string{entity.StockAllocationStatusActive, entity.StockAllocationStatusPending},
-			entity.StockAllocationPurposeConsume,
-		).
-		Pluck("stockable_id", &allocationLockedIDs).Error; err != nil {
-		return nil, err
-	}
-	for _, itemID := range allocationLockedIDs {
-		locked[itemID] = struct{}{}
-	}
-
-	var conversionLockedIDs []uint
-	if err := db.WithContext(ctx).
-		Table("purchase_items pi").
-		Distinct("pi.id").
-		Joins("JOIN project_chickins pc ON pc.product_warehouse_id = pi.product_warehouse_id AND pc.deleted_at IS NULL").
-		Joins("JOIN project_flock_populations pfp ON pfp.project_chickin_id = pc.id AND pfp.deleted_at IS NULL").
-		Where("pi.id IN ?", itemIDs).
-		Where("pi.project_flock_kandang_id IS NOT NULL").
-		Where("pc.project_flock_kandang_id = pi.project_flock_kandang_id").
-		Pluck("pi.id", &conversionLockedIDs).Error; err != nil {
-		return nil, err
-	}
-	for _, itemID := range conversionLockedIDs {
-		locked[itemID] = struct{}{}
-	}
-
-	return locked, nil
-}
-
 func collectPFKIDsFromPurchase(p *entity.Purchase) []uint {
 	seen := make(map[uint]struct{})
 	ids := make([]uint, 0)

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

@@ -147,16 +147,15 @@ func (r *hppPerKandangRepository) GetFeedOvkDocCostByPeriod(ctx context.Context,
 		Table("project_chickins AS pc").
 		Select(`
 			pfk.id AS project_flock_kandang_id,
-			COALESCE(SUM(sa.qty * COALESCE(pi.price, 0)), 0) AS doc_cost,
+			COALESCE(SUM(pc.usage_qty * COALESCE(pi.price, 0)), 0) AS doc_cost,
-			COALESCE(SUM(sa.qty), 0) AS doc_qty,
+			COALESCE(SUM(pc.usage_qty), 0) AS doc_qty,
 			s.id AS supplier_id,
 			s.name AS supplier_name,
 			s.alias AS supplier_alias`).
 		Joins("JOIN project_flock_kandangs AS pfk ON pfk.id = pc.project_flock_kandang_id").
 		Joins("JOIN kandangs AS k ON k.id = pfk.kandang_id").
 		Joins("JOIN locations AS loc ON loc.id = k.location_id").
-		Joins("LEFT JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = pc.id AND sa.stockable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?", fifo.UsableKeyProjectChickin.String(), fifo.StockableKeyPurchaseItems.String(), entity.StockAllocationStatusActive, entity.StockAllocationPurposeTraceChickin).
+		Joins("LEFT JOIN purchase_items AS pi ON pi.product_warehouse_id = pc.product_warehouse_id").
-		Joins("LEFT JOIN purchase_items AS pi ON pi.id = sa.stockable_id").
 		Joins("LEFT JOIN purchases AS pur ON pur.id = pi.purchase_id").
 		Joins("LEFT JOIN suppliers AS s ON s.id = pur.supplier_id").
 		Where("pc.project_flock_kandang_id IN ?", projectFlockKandangIDs).
@@ -222,14 +221,13 @@ func (r *hppPerKandangRepository) GetFeedOvkDocCostByPeriod(ctx context.Context,
 		Table("recordings AS r").
 		Select(`
 			r.project_flock_kandangs_id AS project_flock_kandang_id,
-			COALESCE(SUM(sa.qty * COALESCE(pi.price, 0)), 0) AS feed_cost,
 			s.id AS supplier_id,
 			s.name AS supplier_name,
 			s.alias AS supplier_alias`).
 		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("JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = rs.id AND sa.stockable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?", fifo.UsableKeyRecordingStock.String(), fifo.StockableKeyPurchaseItems.String(), entity.StockAllocationStatusActive, entity.StockAllocationPurposeConsume).
+		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()).
 		Joins("JOIN purchase_items AS pi ON pi.id = sa.stockable_id").
 		Joins("LEFT JOIN purchases AS pur ON pur.id = pi.purchase_id").
 		Joins("LEFT JOIN suppliers AS s ON s.id = pur.supplier_id").

internal/utils/constant.go

@@ -198,136 +198,6 @@ const (
 	TransactionTypeSaldoAwal TransactionType = "SALDO_AWAL"
 )
 
-type AdjustmentTransactionType string
-
-const (
-	AdjustmentTransactionTypePembelian AdjustmentTransactionType = "PEMBELIAN"
-	AdjustmentTransactionTypeRecording AdjustmentTransactionType = "RECORDING"
-	AdjustmentTransactionTypePenjualan AdjustmentTransactionType = "PENJUALAN"
-)
-
-type AdjustmentTransactionSubtype string
-
-const (
-	AdjustmentTransactionSubtypePurchaseIn            AdjustmentTransactionSubtype = "PURCHASE_IN"
-	AdjustmentTransactionSubtypeRecordingDepletionOut AdjustmentTransactionSubtype = "RECORDING_DEPLETION_OUT"
-	AdjustmentTransactionSubtypeMarketingOut          AdjustmentTransactionSubtype = "MARKETING_OUT"
-	AdjustmentTransactionSubtypeRecordingDepletionIn  AdjustmentTransactionSubtype = "RECORDING_DEPLETION_IN"
-	AdjustmentTransactionSubtypeRecordingStockOut     AdjustmentTransactionSubtype = "RECORDING_STOCK_OUT"
-	AdjustmentTransactionSubtypeRecordingEggIn        AdjustmentTransactionSubtype = "RECORDING_EGG_IN"
-)
-
-var adjustmentSubtypesByType = map[AdjustmentTransactionType][]string{
-	AdjustmentTransactionTypePembelian: {
-		string(AdjustmentTransactionSubtypePurchaseIn),
-	},
-	AdjustmentTransactionTypeRecording: {
-		string(AdjustmentTransactionSubtypeRecordingStockOut),
-		string(AdjustmentTransactionSubtypeRecordingDepletionOut),
-		string(AdjustmentTransactionSubtypeRecordingDepletionIn),
-		string(AdjustmentTransactionSubtypeRecordingEggIn),
-	},
-	AdjustmentTransactionTypePenjualan: {
-		string(AdjustmentTransactionSubtypeMarketingOut),
-	},
-}
-
-var hiddenAdjustmentSubtypesForFrontend = map[string]struct{}{
-	string(AdjustmentTransactionSubtypeRecordingDepletionOut): {},
-}
-
-var adjustmentSubtypeToType = func() map[string]AdjustmentTransactionType {
-	out := make(map[string]AdjustmentTransactionType)
-	for txType, subtypes := range adjustmentSubtypesByType {
-		for _, subtype := range subtypes {
-			code := strings.ToUpper(strings.TrimSpace(subtype))
-			if code == "" {
-				continue
-			}
-			out[code] = txType
-		}
-	}
-	return out
-}()
-
-func AdjustmentTransactionTypes() []string {
-	return []string{
-		string(AdjustmentTransactionTypePembelian),
-		string(AdjustmentTransactionTypeRecording),
-		string(AdjustmentTransactionTypePenjualan),
-	}
-}
-
-func AdjustmentTransactionSubtypesByType() map[string][]string {
-	out := make(map[string][]string, len(adjustmentSubtypesByType))
-	for _, txType := range []AdjustmentTransactionType{
-		AdjustmentTransactionTypePembelian,
-		AdjustmentTransactionTypeRecording,
-		AdjustmentTransactionTypePenjualan,
-	} {
-		src := adjustmentSubtypesByType[txType]
-		dup := make([]string, len(src))
-		copy(dup, src)
-		out[string(txType)] = dup
-	}
-	return out
-}
-
-func AdjustmentTransactionSubtypes() []string {
-	result := make([]string, 0)
-	for _, txType := range []AdjustmentTransactionType{
-		AdjustmentTransactionTypePembelian,
-		AdjustmentTransactionTypeRecording,
-		AdjustmentTransactionTypePenjualan,
-	} {
-		result = append(result, adjustmentSubtypesByType[txType]...)
-	}
-	return result
-}
-
-func AdjustmentTransactionSubtypesByTypeForFrontend() map[string][]string {
-	out := make(map[string][]string, len(adjustmentSubtypesByType))
-	for txType, subtypes := range AdjustmentTransactionSubtypesByType() {
-		filtered := make([]string, 0, len(subtypes))
-		for _, subtype := range subtypes {
-			if _, hidden := hiddenAdjustmentSubtypesForFrontend[subtype]; hidden {
-				continue
-			}
-			filtered = append(filtered, subtype)
-		}
-		out[txType] = filtered
-	}
-	return out
-}
-
-func AdjustmentTransactionSubtypesForFrontend() []string {
-	result := make([]string, 0)
-	for _, subtype := range AdjustmentTransactionSubtypes() {
-		if _, hidden := hiddenAdjustmentSubtypesForFrontend[subtype]; hidden {
-			continue
-		}
-		result = append(result, subtype)
-	}
-	return result
-}
-
-func ResolveAdjustmentTransactionType(functionCode string) string {
-	code := strings.ToUpper(strings.TrimSpace(functionCode))
-	if txType, ok := adjustmentSubtypeToType[code]; ok {
-		return string(txType)
-	}
-	switch {
-	case strings.HasPrefix(code, "PURCHASE_"):
-		return string(AdjustmentTransactionTypePembelian)
-	case strings.HasPrefix(code, "MARKETING_"):
-		return string(AdjustmentTransactionTypePenjualan)
-	case strings.HasPrefix(code, "RECORDING_"):
-		return string(AdjustmentTransactionTypeRecording)
-	default:
-		return ""
-	}
-}
-
 // -------------------------------------------------------------------
 // Payment Party
 // -------------------------------------------------------------------

internal/utils/fifo/constants.go

@@ -17,5 +17,4 @@ const (
 	StockableKeyPurchaseItems          StockableKey = "PURCHASE_ITEMS"
 	StockableKeyProjectFlockPopulation StockableKey = "PROJECT_FLOCK_POPULATION"
 	StockableKeyRecordingEgg           StockableKey = "RECORDING_EGG"
-	StockableKeyRecordingDepletion     StockableKey = "RECORDING_DEPLETION_IN"
 )

internal/utils/recording/recording_helpers.go

@@ -1,317 +0,0 @@
-package recording
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
-	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
-	rProductionStandard "gitlab.com/mbugroup/lti-api.git/internal/modules/master/production-standards/repositories"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils"
-	"gorm.io/gorm"
-)
-
-type warnLogger interface {
-    Warnf(format string, args ...any)
-}
-
-type productWarehouseExistsRepo interface {
-    ExistsByID(ctx context.Context, id uint) (bool, error)
-}
-
-type recordingValidationRepo interface {
-    ValidateProductWarehousesByFlags(ctx context.Context, ids []uint, flags []string) (uint, error)
-}
-
-func EnsureProductWarehousesExist(ctx context.Context, repo productWarehouseExistsRepo, ids []uint) error {
-    if repo == nil || len(ids) == 0 {
-        return nil
-    }
-    for _, id := range ids {
-        ok, err := repo.ExistsByID(ctx, id)
-        if err != nil {
-            return err
-        }
-        if !ok {
-            return fmt.Errorf("product warehouse %d not found", id)
-        }
-    }
-    return nil
-}
-
-func EnsureProductWarehousesByFlags(ctx context.Context, repo recordingValidationRepo, ids []uint, flags []string, label string) error {
-	if repo == nil || len(ids) == 0 {
-		return nil
-	}
-	invalidID, err := repo.ValidateProductWarehousesByFlags(ctx, ids, flags)
-	if err != nil {
-		return err
-	}
-	if invalidID != 0 {
-		return fmt.Errorf("product warehouse %d is not a %s warehouse", invalidID, label)
-	}
-	return nil
-}
-
-type idGetter[T any] func(T) uint
-
-func CollectWarehouseIDs[T any](items []T, getID idGetter[T]) []uint {
-	if len(items) == 0 {
-		return nil
-	}
-	ids := make([]uint, 0, len(items))
-	for _, item := range items {
-		if id := getID(item); id != 0 {
-			ids = append(ids, id)
-		}
-	}
-	return ids
-}
-
-func EnsureProductWarehousesByFlagsForItems[T any](
-	ctx context.Context,
-	repo recordingValidationRepo,
-	items []T,
-	getID idGetter[T],
-	flags []string,
-	label string,
-) error {
-	ids := CollectWarehouseIDs(items, getID)
-	return EnsureProductWarehousesByFlags(ctx, repo, ids, flags, label)
-}
-
-func ComputeDepletionRate(prevRecording *entity.Recording, currentDepletion float64, totalChick int64) float64 {
-    base := 0.0
-    if prevRecording != nil && prevRecording.TotalChickQty != nil && *prevRecording.TotalChickQty > 0 {
-        base = *prevRecording.TotalChickQty
-    } else if totalChick > 0 {
-        base = float64(totalChick) + currentDepletion
-    }
-    if base <= 0 {
-        return 0
-    }
-    return (currentDepletion / base) * 100
-}
-
-func AttachLatestApprovals(ctx context.Context, items []entity.Recording, approvalSvc commonSvc.ApprovalService, logger warnLogger) error {
-    if len(items) == 0 || approvalSvc == nil {
-        return nil
-    }
-
-    ids := make([]uint, 0, len(items))
-    visited := make(map[uint]struct{}, len(items))
-    for _, item := range items {
-        if item.Id == 0 {
-            continue
-        }
-        if _, ok := visited[item.Id]; ok {
-            continue
-        }
-        visited[item.Id] = struct{}{}
-        ids = append(ids, item.Id)
-    }
-
-    if len(ids) == 0 {
-        return nil
-    }
-
-    latestMap, err := approvalSvc.LatestByTargets(ctx, utils.ApprovalWorkflowRecording, ids, func(db *gorm.DB) *gorm.DB {
-        return db.Preload("ActionUser")
-    })
-    if err != nil {
-        if logger != nil {
-            logger.Warnf("Unable to load latest approvals for recordings: %+v", err)
-        }
-        return nil
-    }
-
-    if len(latestMap) == 0 {
-        return nil
-    }
-
-    for i := range items {
-        if items[i].Id == 0 {
-            continue
-        }
-        if approval, ok := latestMap[items[i].Id]; ok {
-            items[i].LatestApproval = approval
-        }
-    }
-
-    return nil
-}
-
-func AttachLatestApproval(ctx context.Context, item *entity.Recording, approvalSvc commonSvc.ApprovalService, logger warnLogger) error {
-    if item == nil || item.Id == 0 || approvalSvc == nil {
-        return nil
-    }
-
-    latest, err := approvalSvc.LatestByTarget(ctx, utils.ApprovalWorkflowRecording, item.Id, func(db *gorm.DB) *gorm.DB {
-        return db.Preload("ActionUser")
-    })
-    if err != nil {
-        if logger != nil {
-            logger.Warnf("Unable to load approvals for recording %d: %+v", item.Id, err)
-        }
-        return nil
-    }
-    item.LatestApproval = latest
-    return nil
-}
-
-type productionStandardValues struct {
-    HenDay       *float64
-    HenHouse     *float64
-    FeedIntake   *float64
-    MaxDepletion *float64
-    EggMass      *float64
-    EggWeight    *float64
-}
-
-func AttachProductionStandards(ctx context.Context, db *gorm.DB, warnOnly bool, logger warnLogger, items ...*entity.Recording) error {
-    if len(items) == 0 {
-        return nil
-    }
-
-    type standardKey struct {
-        standardID uint
-        week       int
-    }
-    type standardCacheEntry struct {
-        values productionStandardValues
-        fcr    *float64
-    }
-
-    if db == nil {
-        return nil
-    }
-
-    standardDetailRepo := rProductionStandard.NewProductionStandardDetailRepository(db)
-    growthDetailRepo := rProductionStandard.NewStandardGrowthDetailRepository(db)
-    cache := make(map[standardKey]standardCacheEntry, len(items))
-
-    standardIDs := make(map[uint]struct{}, len(items))
-    for _, item := range items {
-        if item == nil || item.ProjectFlockKandang == nil || item.ProjectFlockKandang.ProjectFlock.Id == 0 {
-            continue
-        }
-        if item.ProjectFlockKandang.ProjectFlock.ProductionStandardId > 0 {
-            standardIDs[item.ProjectFlockKandang.ProjectFlock.ProductionStandardId] = struct{}{}
-        }
-    }
-
-    standardDetailByStd := make(map[uint]map[int]*entity.ProductionStandardDetail, len(standardIDs))
-    growthDetailByStd := make(map[uint]map[int]*entity.StandardGrowthDetail, len(standardIDs))
-
-    for standardID := range standardIDs {
-        details, err := standardDetailRepo.GetByProductionStandardID(ctx, standardID)
-        if err != nil {
-            if warnOnly {
-                if logger != nil {
-                    logger.Warnf("Unable to preload production standard detail for standard %d: %+v", standardID, err)
-                }
-            } else {
-                return err
-            }
-            continue
-        }
-        detailMap := make(map[int]*entity.ProductionStandardDetail, len(details))
-        for i := range details {
-            detail := details[i]
-            detailMap[detail.Week] = &detail
-        }
-        standardDetailByStd[standardID] = detailMap
-
-        growths, err := growthDetailRepo.GetByProductionStandardID(ctx, standardID)
-        if err != nil {
-            if warnOnly {
-                if logger != nil {
-                    logger.Warnf("Unable to preload standard growth detail for standard %d: %+v", standardID, err)
-                }
-            } else {
-                return err
-            }
-            continue
-        }
-        growthMap := make(map[int]*entity.StandardGrowthDetail, len(growths))
-        for i := range growths {
-            growth := growths[i]
-            growthMap[growth.Week] = &growth
-        }
-        growthDetailByStd[standardID] = growthMap
-    }
-
-    for _, item := range items {
-        if item == nil || item.ProjectFlockKandang == nil || item.ProjectFlockKandang.ProjectFlock.Id == 0 {
-            continue
-        }
-        standardID := item.ProjectFlockKandang.ProjectFlock.ProductionStandardId
-        if standardID == 0 {
-            continue
-        }
-        week := RecordingWeekValue(*item)
-        cacheKey := standardKey{standardID: standardID, week: week}
-        if cached, ok := cache[cacheKey]; ok {
-            applyProductionStandardValues(item, cached.values, cached.fcr)
-            continue
-        }
-        values := productionStandardValues{}
-        var fcr *float64
-        if detailMap, ok := standardDetailByStd[standardID]; ok {
-            if detail, ok := detailMap[week]; ok {
-                values.HenDay = detail.TargetHenDayProduction
-                values.HenHouse = detail.TargetHenHouseProduction
-                values.EggMass = detail.TargetEggMass
-                values.EggWeight = detail.TargetEggWeight
-                fcr = detail.StandardFCR
-            }
-        }
-        if growthMap, ok := growthDetailByStd[standardID]; ok {
-            if growth, ok := growthMap[week]; ok {
-                values.FeedIntake = growth.FeedIntake
-                values.MaxDepletion = growth.MaxDepletion
-            }
-        }
-        cache[cacheKey] = standardCacheEntry{values: values, fcr: fcr}
-        applyProductionStandardValues(item, values, fcr)
-    }
-
-    return nil
-}
-
-func applyProductionStandardValues(item *entity.Recording, values productionStandardValues, fcr *float64) {
-    item.StandardHenDay = values.HenDay
-    item.StandardHenHouse = values.HenHouse
-    item.StandardFeedIntake = values.FeedIntake
-    item.StandardMaxDepletion = values.MaxDepletion
-    item.StandardEggMass = values.EggMass
-    item.StandardEggWeight = values.EggWeight
-    item.StandardFcr = fcr
-}
-
-func RecordingWeekValue(e entity.Recording) int {
-	day := intValue(e.Day)
-	if day <= 0 {
-		return 0
-	}
-	weekBase := 1
-	if IsLayingRecording(e) {
-		weekBase = 18
-	}
-	return ((day - 1) / 7) + weekBase
-}
-
-func IsLayingRecording(e entity.Recording) bool {
-	if e.ProjectFlockKandang == nil {
-		return false
-	}
-	return strings.EqualFold(e.ProjectFlockKandang.ProjectFlock.Category, string(utils.ProjectFlockCategoryLaying))
-}
-
-func intValue(value *int) int {
-	if value == nil {
-		return 0
-	}
-	return *value
-}

internal/utils/recording/util.recording.go

@@ -1,9 +1,6 @@
 package recording
 
 import (
-	"fmt"
-	"strings"
-
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/validations"
 )
@@ -73,87 +70,3 @@ func MapEggs(recordingID uint, createdBy uint, items []validation.Egg) []entity.
 	}
 	return result
 }
-
-type EggTotals struct {
-	Qty    int
-	Weight float64
-}
-
-func StockUsageByWarehouse(items []entity.RecordingStock) map[uint]float64 {
-	return TotalsByWarehouse(items, func(stock entity.RecordingStock) (uint, float64) {
-		var usage float64
-		if stock.UsageQty != nil {
-			usage = *stock.UsageQty
-		}
-		return stock.ProductWarehouseId, usage
-	})
-}
-
-func StockUsageByWarehouseReq(items []validation.Stock) map[uint]float64 {
-	return TotalsByWarehouse(items, func(item validation.Stock) (uint, float64) {
-		return item.ProductWarehouseId, item.Qty
-	})
-}
-
-func FloatMapsEqual(a, b map[uint]float64) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for key, value := range a {
-		other, ok := b[key]
-		if !ok || !floatNearlyEqual(value, other) {
-			return false
-		}
-	}
-	return true
-}
-
-func EggTotalsEqual(a, b map[uint]EggTotals) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for key, value := range a {
-		other, ok := b[key]
-		if !ok || value.Qty != other.Qty || !floatNearlyEqual(value.Weight, other.Weight) {
-			return false
-		}
-	}
-	return true
-}
-
-func floatNearlyEqual(a, b float64) bool {
-	return a-b <= 0.000001 && b-a <= 0.000001
-}
-
-func TotalsByWarehouse[T any](items []T, get func(T) (uint, float64)) map[uint]float64 {
-	result := make(map[uint]float64)
-	for _, item := range items {
-		warehouseID, qty := get(item)
-		result[warehouseID] += qty
-	}
-	return result
-}
-
-func EggTotalsByWarehouse[T any](items []T, get func(T) (uint, int, *float64)) map[uint]EggTotals {
-	result := make(map[uint]EggTotals)
-	for _, item := range items {
-		warehouseID, qty, weightPtr := get(item)
-		weight := 0.0
-		if weightPtr != nil {
-			weight = *weightPtr
-		}
-		current := result[warehouseID]
-		current.Qty += qty
-		current.Weight += weight
-		result[warehouseID] = current
-	}
-	return result
-}
-
-func RecordingNote(action string, id uint) string {
-	action = strings.TrimSpace(action)
-	if action == "" {
-		return fmt.Sprintf("Recording#%d", id)
-	}
-	return fmt.Sprintf("Recording-%s#%d", action, id)
-}