Merge remote-tracking branch 'origin/dev/fifo-v2' into development

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

@@ -1098,6 +1098,7 @@ func (r *ClosingRepositoryImpl) FetchSapronakUsageAllocatedDetails(ctx context.C
 		Joins("LEFT JOIN product_warehouses pw_pc ON pw_pc.id = pc.product_warehouse_id").
 		Joins("LEFT JOIN products p_resolve ON p_resolve.id = COALESCE(pi.product_id, pw_ltt.product_id, pw_pc.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(`
@@ -1307,6 +1308,7 @@ 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)).
@@ -1401,6 +1403,7 @@ 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).
@@ -1433,6 +1436,7 @@ 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).
@@ -1469,6 +1473,7 @@ 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")
@@ -1496,9 +1501,10 @@ 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 = ?",
+		Joins("LEFT JOIN stock_allocations sa ON sa.usable_id = mdp.id AND sa.usable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?",
 			fifo.UsableKeyMarketingDelivery.String(),
 			entity.StockAllocationStatusActive,
+			entity.StockAllocationPurposeConsume,
 		).
 		Where("mdp.usage_qty > 0").
 		Where("sa.id IS NULL").
@@ -1613,8 +1619,9 @@ func (r *ClosingRepositoryImpl) FetchSapronakSalesAllocatedDetails(ctx context.C
 		Joins("LEFT JOIN product_warehouses pw_pc ON pw_pc.id = pc.product_warehouse_id").
 		Joins(fmt.Sprintf("LEFT JOIN products p_resolve ON p_resolve.id = CASE WHEN sa.stockable_type = '%s' THEN pw_pc.product_id ELSE COALESCE(pi.product_id, pw_ltt.product_id, pw.product_id) END", pfpType)).
 		Where("sa.status = ?", entity.StockAllocationStatusActive).
-		Where("sa.stockable_type <> ?", fifo.StockableKeyRecordingEgg.String()).
-		Where("pw_sales.project_flock_kandang_id = ?", projectFlockKandangID).
+		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).
 		Group(`
 			p_resolve.id, p_resolve.name, f.name,
@@ -1640,7 +1647,6 @@ func (r *ClosingRepositoryImpl) GetProductsWithFlagsByIDs(ctx context.Context, p
 		Preload("Flags").
 		Where("id IN ?", productIDs).
 		Find(&products).Error
-
 	if err != nil {
 		return nil, err
 	}

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

@@ -12,7 +12,7 @@ import (
 )
 
 type ConstantRepository interface {
-	GetConstants() map[string]interface{}
+	GetConstants() (map[string]interface{}, error)
 }
 
 type ConstantRepositoryImpl struct {
@@ -25,13 +25,51 @@ func NewConstantRepository(db *gorm.DB) ConstantRepository {
 	}
 }
 
-func (r *ConstantRepositoryImpl) GetConstants() map[string]interface{} {
+func (r *ConstantRepositoryImpl) GetConstants() (map[string]interface{}, error) {
 	flagList := make([]string, 0)
 	for f := range utils.AllFlagTypes() {
 		flagList = append(flagList, string(f))
 	}
 	sort.Strings(flagList)
 
+	productMainFlags := utils.ProductMainFlags()
+	productMainFlagValues := make([]string, len(productMainFlags))
+	for i, flag := range productMainFlags {
+		productMainFlagValues[i] = string(flag)
+	}
+
+	type productFlagOption struct {
+		Flag                string   `json:"flag"`
+		SubFlags            []string `json:"sub_flags"`
+		AllowWithoutSubFlag bool     `json:"allow_without_sub_flag"`
+	}
+
+	productOptions := utils.ProductFlagOptions()
+	productFlagOptions := make([]productFlagOption, 0, len(productOptions))
+	for _, option := range productOptions {
+		subFlags := make([]string, len(option.SubFlags))
+		for i, subFlag := range option.SubFlags {
+			subFlags[i] = string(subFlag)
+		}
+		productFlagOptions = append(productFlagOptions, productFlagOption{
+			Flag:                string(option.Flag),
+			SubFlags:            subFlags,
+			AllowWithoutSubFlag: option.AllowWithoutSubFlag,
+		})
+	}
+
+	productSubFlagToFlagRaw := utils.ProductSubFlagToFlag()
+	productSubFlagToFlag := make(map[string]string, len(productSubFlagToFlagRaw))
+	for subFlag, flag := range productSubFlagToFlagRaw {
+		productSubFlagToFlag[string(subFlag)] = string(flag)
+	}
+
+	legacyAliasesRaw := utils.LegacyFlagTypeAliases()
+	legacyAliases := make(map[string]string, len(legacyAliasesRaw))
+	for legacy, canonical := range legacyAliasesRaw {
+		legacyAliases[string(legacy)] = string(canonical)
+	}
+
 	type approvalStepConstant struct {
 		StepNumber uint16 `json:"step_number"`
 		StepName   string `json:"step_name"`
@@ -75,6 +113,8 @@ func (r *ConstantRepositoryImpl) GetConstants() map[string]interface{} {
 		})
 	}
 
+	adjustmentSubtypesByType := utils.AdjustmentTransactionSubtypesByTypeForFrontend()
+
 	return map[string]interface{}{
 		"flags": flagList,
 		"warehouse_types": []string{
@@ -94,6 +134,15 @@ func (r *ConstantRepositoryImpl) GetConstants() map[string]interface{} {
 			"BISNIS",
 			"INDIVIDUAL",
 		},
-		"approval_workflows": approvalWorkflows,
-	}
+			"adjustment": map[string]interface{}{
+				"transaction_subtypes": adjustmentSubtypesByType,
+			},
+			"legacy_flag_aliases": legacyAliases,
+			"product_flag_mapping": map[string]interface{}{
+				"flags":            productMainFlagValues,
+				"options":          productFlagOptions,
+				"sub_flag_to_flag": productSubFlagToFlag,
+			},
+			"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(), nil
+	return s.Repository.GetConstants()
 }

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

@@ -47,11 +47,13 @@ func (u *AdjustmentController) Adjustment(c *fiber.Ctx) error {
 
 func (u *AdjustmentController) AdjustmentHistory(c *fiber.Ctx) error {
 	query := &validation.Query{
-		Page:            c.QueryInt("page", 1),
-		Limit:           c.QueryInt("limit", 10),
-		ProductID:       uint(c.QueryInt("product_id", 0)),
-		WarehouseID:     uint(c.QueryInt("warehouse_id", 0)),
-		TransactionType: c.Query("transaction_type", ""),
+		Page:               c.QueryInt("page", 1),
+		Limit:              c.QueryInt("limit", 10),
+		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,27 +17,49 @@ type ProductRelationDTO struct {
 	ProductCategory *productCategoryDTO.ProductCategoryRelationDTO `json:"product_category,omitempty"`
 }
 
-type WarehouseRelationDTO struct {
+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 {
-	Id          uint                  `json:"id"`
-	ProductId   uint                  `json:"product_id"`
-	WarehouseId uint                  `json:"warehouse_id"`
-	Quantity    float64               `json:"quantity"`
-	Product     *ProductRelationDTO   `json:"product,omitempty"`
-	Warehouse   *WarehouseRelationDTO `json:"warehouse,omitempty"`
+	Id           uint                     `json:"id"`
+	ProductId    uint                     `json:"product_id"`
+	WarehouseId  uint                     `json:"warehouse_id"`
+	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"`
-	Increase           float64              `json:"increase"`
-	Decrease           float64              `json:"decrease"`
-	Note               string               `json:"note,omitempty"`
-	ProductWarehouseId uint                 `json:"product_warehouse_id"`
-	ProductWarehouse   *ProductWarehouseDTO `json:"product_warehouse,omitempty"`
+	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"`
+	Location           *LocationRelationDTO     `json:"location,omitempty"`
+	ProjectFlock       *ProjectFlockRelationDTO `json:"project_flock,omitempty"`
+	ProductWarehouseId uint                     `json:"product_warehouse_id"`
+	ProductWarehouse   *ProductWarehouseDTO     `json:"product_warehouse,omitempty"`
 }
 
 type AdjustmentListDTO struct {
@@ -81,31 +103,80 @@ func ToWarehouseRelationDTO(e *entity.Warehouse) *WarehouseRelationDTO {
 		return nil
 	}
 	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,
+	}
+}
+
 func ToProductWarehouseDTO(e *entity.ProductWarehouse) *ProductWarehouseDTO {
 	if e == nil {
 		return nil
 	}
 	return &ProductWarehouseDTO{
-		Id:          e.Id,
-		ProductId:   e.ProductId,
-		WarehouseId: e.WarehouseId,
-		Quantity:    e.Quantity,
-		Product:     ToProductRelationDTO(&e.Product),
-		Warehouse:   ToWarehouseRelationDTO(&e.Warehouse),
+		Id:           e.Id,
+		ProductId:    e.ProductId,
+		WarehouseId:  e.WarehouseId,
+		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,
-		Note:               "",
+		AdjNumber:          e.AdjNumber,
+		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,7 +5,6 @@ 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"
@@ -17,7 +16,6 @@ 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{}
@@ -31,41 +29,7 @@ func (AdjustmentModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validat
 	userRepo := rUser.NewUserRepository(db)
 	productRepo := rproduct.NewProductRepository(db)
 	adjustmentStockRepo := rAdjustmentStock.NewAdjustmentStockRepository(db)
-	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())
-	}
+	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
 
 	adjustmentService := sAdjustment.NewAdjustmentService(
 		productRepo,
@@ -73,7 +37,7 @@ func (AdjustmentModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validat
 		warehouseRepo,
 		productWarehouseRepo,
 		adjustmentStockRepo,
-		fifoService,
+		fifoStockV2Service,
 		validate,
 		projectFlockKandangRepo,
 	)

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

@@ -2,6 +2,7 @@ package repositories
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"strconv"
 	"strings"
@@ -14,11 +15,35 @@ 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
 }
@@ -48,6 +73,151 @@ 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,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"math"
 	"strings"
 
 	"github.com/go-playground/validator/v10"
@@ -20,7 +21,6 @@ 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,16 +39,22 @@ type adjustmentService struct {
 	ProductRepo               productRepo.ProductRepository
 	ProjectFlockKandangRepo   projectFlockKandangRepo.ProjectFlockKandangRepository
 	AdjustmentStockRepository adjustmentStockRepo.AdjustmentStockRepository
-	FifoSvc                   common.FifoService
+	FifoStockV2Svc            common.FifoStockV2Service
 }
 
+const (
+	adjustmentLaneStockable = "STOCKABLE"
+	adjustmentLaneUsable    = "USABLE"
+	flagGroupAyam           = "AYAM"
+)
+
 func NewAdjustmentService(
 	productRepo productRepo.ProductRepository,
 	stockLogsRepo stockLogsRepo.StockLogRepository,
 	warehouseRepo warehouseRepo.WarehouseRepository,
 	productWarehouseRepo ProductWarehouse.ProductWarehouseRepository,
 	adjustmentStockRepo adjustmentStockRepo.AdjustmentStockRepository,
-	fifoSvc common.FifoService,
+	fifoStockV2Svc common.FifoStockV2Service,
 	validate *validator.Validate,
 	projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository,
 ) AdjustmentService {
@@ -61,7 +67,7 @@ func NewAdjustmentService(
 		ProductRepo:               productRepo,
 		ProjectFlockKandangRepo:   projectFlockKandangRepo,
 		AdjustmentStockRepository: adjustmentStockRepo,
-		FifoSvc:                   fifoSvc,
+		FifoStockV2Svc:            fifoStockV2Svc,
 	}
 }
 
@@ -70,6 +76,9 @@ 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")
 }
 
@@ -94,47 +103,87 @@ 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(), uint(req.WarehouseID)); err != nil {
+	if err := m.EnsureWarehouseAccess(c, s.WarehouseRepo.DB(), warehouseID); err != nil {
 		return nil, err
 	}
-	if err := common.EnsureRelations(c.Context(),
-		common.RelationCheck{Name: "Product", ID: &req.ProductID, Exists: s.ProductRepo.IdExists},
-		common.RelationCheck{Name: "Warehouse", ID: &req.WarehouseID, Exists: s.WarehouseRepo.IdExists},
+	if err := common.EnsureRelations(ctx,
+		common.RelationCheck{Name: "Product", ID: &productID, Exists: s.ProductRepo.IdExists},
+		common.RelationCheck{Name: "Warehouse", ID: &warehouseID, Exists: s.WarehouseRepo.IdExists},
 	); err != nil {
 		return nil, err
 	}
 
-	if req.Quantity <= 0 {
-		return nil, fiber.NewError(fiber.StatusBadRequest, "Quantity must be greater than zero")
+	routeMeta, err := s.resolveRouteByFunctionCode(ctx, productID, functionCode)
+	if err != nil {
+		return nil, err
 	}
 
-	transactionType := strings.ToUpper(req.TransactionType)
-	if transactionType != string(utils.StockLogTransactionTypeIncrease) && transactionType != string(utils.StockLogTransactionTypeDecrease) {
-		return nil, fiber.NewError(fiber.StatusBadRequest, "Invalid transaction type")
-	}
+	transactionType := utils.ResolveAdjustmentTransactionType(routeMeta.FunctionCode)
 
 	var createdAdjustmentStockId uint
 
 	var projectFlockKandangID *uint
-	pfkID, err := s.getActiveProjectFlockKandangID(ctx, uint(req.WarehouseID))
+	pfkID, err := s.getActiveProjectFlockKandangID(ctx, warehouseID)
 	if err == nil && pfkID > 0 {
 		projectFlockKandangID = &pfkID
 	}
 
-	pw, err := s.ProductWarehouseRepo.FindByProductWarehouseAndPfk(ctx, uint(req.ProductID), uint(req.WarehouseID), projectFlockKandangID)
+	pw, err := s.ProductWarehouseRepo.FindByProductWarehouseAndPfk(ctx, productID, 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:             uint(req.ProductID),
-			WarehouseId:           uint(req.WarehouseID),
+			ProductId:             productID,
+			WarehouseId:           warehouseID,
 			Quantity:              0,
 			ProjectFlockKandangId: projectFlockKandangID,
 		}
@@ -153,96 +202,207 @@ 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 := s.ProductWarehouseRepo.FindByProductWarehouseAndPfk(ctx, uint(req.ProductID), uint(req.WarehouseID), projectFlockKandangID)
+		productWarehouse, err := productWarehouseRepoTX.FindByProductWarehouseAndPfk(ctx, productID, 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")
 		}
 
-		newLog := &entity.StockLog{
-			LoggableType:       string(utils.StockLogTypeAdjustment),
-			LoggableId:         0,
-			Notes:              req.Note,
-			ProductWarehouseId: productWarehouse.Id,
-			CreatedBy:          actorID,
-		}
-
-		stockLogs, err := s.StockLogsRepository.GetByProductWarehouse(ctx, productWarehouse.Id, 1)
-		if err != nil {
-			s.Log.Errorf("Failed to get stock logs: %+v", err)
-			return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
-		}
-
-		if len(stockLogs) > 0 {
-			latestStockLog := stockLogs[0]
-			newLog.Stock = latestStockLog.Stock
-		} else {
-			newLog.Stock = 0
-		}
-
-		if transactionType == string(utils.StockLogTransactionTypeIncrease) {
-			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))
+		if functionCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionIn) {
+			if routeMeta.Lane != adjustmentLaneStockable {
+				return fiber.NewError(fiber.StatusBadRequest, "Transaction subtype depletion in harus lane STOCKABLE")
+			}
+			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")
 			}
-			newLog.Decrease = req.Quantity
-			newLog.Stock -= newLog.Decrease
-		}
 
-		if err := s.StockLogsRepository.WithTx(tx).CreateOne(ctx, newLog, nil); err != nil {
+			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
+			}
 
-			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,
+				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
+			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")
+			}
+			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(
+				ctx,
+				stockLogRepoTX,
+				refreshedSource.Id,
+				refreshedSource.ProductWarehouseId,
+				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
+			return nil
 		}
 
 		adjustmentStock := &entity.AdjustmentStock{
 			ProductWarehouseId: productWarehouse.Id,
+			TransactionType:    transactionType,
+			FunctionCode:       routeMeta.FunctionCode,
+			Price:              req.Price,
+			GrandTotal:         grandTotal,
 		}
-		code, err := s.AdjustmentStockRepository.GenerateSequentialNumber(ctx, utils.AdjustmentStockNumberPrefix)
+		switch routeMeta.Lane {
+		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 := s.AdjustmentStockRepository.WithTx(tx).CreateOne(ctx, adjustmentStock, nil); err != nil {
-
+		if err := adjustmentStockRepoTX.CreateOne(ctx, adjustmentStock, nil); err != nil {
 			return fiber.NewError(fiber.StatusInternalServerError, "Failed to create adjustment stock record")
 		}
 
-		newLog.LoggableType = string(utils.StockLogTypeAdjustment)
-		newLog.LoggableId = adjustmentStock.Id
-		if err := s.StockLogsRepository.WithTx(tx).UpdateOne(ctx, newLog.Id, newLog, nil); err != nil {
-			return fiber.NewError(fiber.StatusInternalServerError, "Failed to link stock log")
+		var increaseQty float64
+		var decreaseQty float64
+
+		if routeMeta.Lane != adjustmentLaneStockable && routeMeta.Lane != adjustmentLaneUsable {
+			return fiber.NewError(fiber.StatusBadRequest, "Unsupported transaction subtype lane")
+		}
+		if s.FifoStockV2Svc == nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "FIFO v2 service is not available")
 		}
 
-		if transactionType == string(utils.StockLogTransactionTypeIncrease) {
+		asOf := adjustmentStock.CreatedAt
+		if _, err := s.FifoStockV2Svc.Reflow(ctx, common.FifoStockV2ReflowRequest{
+			FlagGroupCode:      routeMeta.FlagGroupCode,
+			ProductWarehouseID: productWarehouse.Id,
+			AsOf:               &asOf,
+			Tx:                 tx,
+		}); err != nil {
+			return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to reflow stock via FIFO v2: %v", err))
+		}
 
-			note := fmt.Sprintf("Stock Adjustment IN #%d", newLog.Id)
-			_, err := s.FifoSvc.Replenish(ctx, common.StockReplenishRequest{
-				StockableKey:       fifo.StockableKeyAdjustmentIn,
-				StockableID:        adjustmentStock.Id,
-				ProductWarehouseID: uint(productWarehouse.Id),
-				Quantity:           req.Quantity,
-				Note:               &note,
-				Tx:                 tx,
-			})
-			if err != nil {
-				return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to replenish stock via FIFO: %v", err))
-			}
+		refreshedAdjustment, err := adjustmentStockRepoTX.GetByID(ctx, adjustmentStock.Id, nil)
+		if err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Failed to refresh adjustment stock")
+		}
+		switch routeMeta.Lane {
+		case adjustmentLaneStockable:
+			increaseQty = refreshedAdjustment.TotalQty
+		case adjustmentLaneUsable:
+			decreaseQty = refreshedAdjustment.UsageQty
+		}
 
-		} else {
-			_, err := s.FifoSvc.Consume(ctx, common.StockConsumeRequest{
-				UsableKey:          fifo.UsableKeyAdjustmentOut,
-				UsableID:           adjustmentStock.Id,
-				ProductWarehouseID: uint(productWarehouse.Id),
-				Quantity:           req.Quantity,
-				AllowPending:       false,
-				Tx:                 tx,
-			})
-			if err != nil {
-				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to consume stock via FIFO: %v", err))
-			}
+		if err := s.createAdjustmentStockLog(
+			ctx,
+			stockLogRepoTX,
+			adjustmentStock.Id,
+			productWarehouse.Id,
+			note,
+			actorID,
+			increaseQty,
+			decreaseQty,
+		); err != nil {
+			return err
 		}
 
 		createdAdjustmentStockId = adjustmentStock.Id
@@ -261,6 +421,91 @@ 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 {
@@ -287,10 +532,98 @@ 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
@@ -313,15 +646,6 @@ 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
@@ -330,42 +654,32 @@ 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")
 	}
 
-	if query.ProductID > 0 {
-		q = q.Joins("JOIN product_warehouses ON product_warehouses.id = adjustment_stocks.product_warehouse_id").
-			Where("product_warehouses.product_id = ?", query.ProductID)
+	functionCode := strings.ToUpper(strings.TrimSpace(query.TransactionSubtype))
+	if functionCode == "" {
+		functionCode = strings.ToUpper(strings.TrimSpace(query.FunctionCode))
 	}
+	transactionType := strings.ToUpper(strings.TrimSpace(query.TransactionType))
 
-	if query.WarehouseID > 0 {
-		q = q.Joins("JOIN product_warehouses ON product_warehouses.id = adjustment_stocks.product_warehouse_id").
-			Where("product_warehouses.warehouse_id = ?", query.WarehouseID)
-	}
-
-	if query.TransactionType != "" {
-		q = q.Joins("JOIN stock_logs ON stock_logs.loggable_type = ? AND stock_logs.loggable_id = adjustment_stocks.id", "ADJUSTMENT").
-			Where("stock_logs.transaction_type = ?", strings.ToUpper(query.TransactionType))
-	}
-
-	if err = q.Count(&total).Error; err != nil {
-		s.Log.Errorf("Failed to get adjustments: %+v", err)
-		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
-
+	adjustmentStocks, total, err := s.AdjustmentStockRepository.FindHistory(
+		c.Context(),
+		adjustmentStockRepo.AdjustmentHistoryFilter{
+			ProductID:       query.ProductID,
+			WarehouseID:     query.WarehouseID,
+			TransactionType: transactionType,
+			FunctionCode:    functionCode,
+			ScopeRestrict:   scope.Restrict,
+			ScopeIDs:        scope.IDs,
+			Offset:          offset,
+			Limit:           query.Limit,
+		},
+		nil,
+	)
 	if err != nil {
 		s.Log.Errorf("Failed to get adjustments: %+v", err)
 		return nil, 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to get adjustment history")
 	}
 
-	result := make([]*entity.AdjustmentStock, len(adjustmentStocks))
-	for i := range adjustmentStocks {
-		result[i] = &adjustmentStocks[i]
-	}
-
-	return result, total, nil
+	return adjustmentStocks, total, nil
 }

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

@@ -1,17 +1,25 @@
 package validation
 
 type Create struct {
-	ProductID       uint    `json:"product_id" validate:"required"`
-	WarehouseID     uint    `json:"warehouse_id" validate:"required"`
-	TransactionType string  `json:"transaction_type" validate:"required,oneof=increase decrease"`
-	Quantity        float64 `json:"quantity" validate:"required,gt=0"`
-	Note            string  `json:"note" validate:"omitempty,max=255"`
+	ProjectFlockKandangID *uint   `json:"project_flock_kandang_id" validate:"omitempty,min=1"`
+	WarehouseID           uint    `json:"warehouse_id" validate:"omitempty,min=1"`
+	ProductID             uint    `json:"product_id" validate:"omitempty,min=1"`
+	TransactionSubtype    string  `json:"transaction_subtype" validate:"required_without=TransactionSubType,max=64"`
+	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"`
 }
 
 type Query struct {
-	Page            int    `query:"page" validate:"omitempty,min=1"`
-	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,oneof=increase decrease"`
+	Page               int    `query:"page" validate:"omitempty,min=1"`
+	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"`
+	TransactionSubtype string `query:"transaction_subtype" validate:"omitempty,max=64"`
+	FunctionCode       string `query:"function_code" validate:"omitempty,max=64"`
 }

internal/modules/inventory/transfers/module.go

@@ -24,7 +24,6 @@ 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{}
@@ -40,10 +39,10 @@ func (TransferModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	userRepo := rUser.NewUserRepository(db)
 	warehouseRepo := rWarehouse.NewWarehouseRepository(db)
 	projectFlockKandangRepo := rProjectFlockKandang.NewProjectFlockKandangRepository(db)
+	projectFlockPopulationRepo := rProjectFlockKandang.NewProjectFlockPopulationRepository(db)
 	kandangRepo := rKandang.NewKandangRepository(db)
 	nonstockRepo := rNonstock.NewNonstockRepository(db)
 	documentRepo := commonRepo.NewDocumentRepository(db)
-	stockAllocRepo := commonRepo.NewStockAllocationRepository(db)
 	expenseRepository := expenseRepo.NewExpenseRepository(db)
 	expenseRealizationRepo := expenseRepo.NewExpenseRealizationRepository(db)
 
@@ -52,7 +51,6 @@ 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 {
@@ -70,7 +68,7 @@ func (TransferModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		validate,
 	)
 
-	fifoService := commonSvc.NewFifoService(db, stockAllocRepo, productWarehouseRepo, utils.Log)
+	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
 	expenseBridge := sTransfer.NewTransferExpenseBridge(
 		db,
 		stockTransferRepo,
@@ -79,39 +77,7 @@ func (TransferModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		expenseServiceInstance,
 	)
 
-	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)
+	transferService := sTransfer.NewTransferService(validate, stockTransferRepo, stockTransferDetailRepo, stockTransferDeliveryRepo, StockTransferDeliveryItemRepo, stockLogsRepo, productWarehouseRepo, supplierRepo, warehouseRepo, projectFlockKandangRepo, projectFlockPopulationRepo, documentSvc, fifoStockV2Service, expenseBridge)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	TransferRoutes(router, userService, transferService)

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

@@ -11,6 +11,7 @@ import (
 	"github.com/gofiber/fiber/v2"
 	"github.com/sirupsen/logrus"
 	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+	fifoV2 "gitlab.com/mbugroup/lti-api.git/internal/common/service/fifo_stock_v2"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
 	rProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
@@ -44,12 +45,13 @@ type transferService struct {
 	SupplierRepo                  rSupplier.SupplierRepository
 	WarehouseRepo                 warehouseRepo.WarehouseRepository
 	ProjectFlockKandangRepo       projectFlockKandangRepo.ProjectFlockKandangRepository
+	ProjectFlockPopulationRepo    projectFlockKandangRepo.ProjectFlockPopulationRepository
 	DocumentSvc                   commonSvc.DocumentService
-	FifoSvc                       commonSvc.FifoService
+	FifoStockV2Svc                commonSvc.FifoStockV2Service
 	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, fifoSvc commonSvc.FifoService, 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, projectFlockPopulationRepo projectFlockKandangRepo.ProjectFlockPopulationRepository, documentSvc commonSvc.DocumentService, fifoStockV2Svc commonSvc.FifoStockV2Service, expenseBridge TransferExpenseBridge) TransferService {
 	return &transferService{
 		Log:                           utils.Log,
 		Validate:                      validate,
@@ -62,8 +64,9 @@ func NewTransferService(validate *validator.Validate, stockTransferRepo rStockTr
 		SupplierRepo:                  supplierRepo,
 		WarehouseRepo:                 warehouseRepo,
 		ProjectFlockKandangRepo:       projectFlockKandangRepo,
+		ProjectFlockPopulationRepo:    projectFlockPopulationRepo,
 		DocumentSvc:                   documentSvc,
-		FifoSvc:                       fifoSvc,
+		FifoStockV2Svc:                fifoStockV2Svc,
 		ExpenseBridge:                 expenseBridge,
 	}
 }
@@ -442,36 +445,91 @@ 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")
+			}
 
-			consumeResult, err := s.FifoSvc.Consume(c.Context(), commonSvc.StockConsumeRequest{
-				UsableKey:          fifo.UsableKeyStockTransferOut,
-				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("Stok tidak mencukupi untuk produk %d di gudang asal. Error: %v", product.ProductID, err))
+			flagGroupCode, ok := flagGroupByProduct[uint(product.ProductID)]
+			if !ok {
+				flagGroupCode, err = s.resolveTransferFlagGroup(c.Context(), tx, uint(product.ProductID))
+				if err != nil {
+					return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("FIFO v2 route tidak ditemukan untuk produk %d: %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":   consumeResult.UsageQuantity,
-					"pending_qty": consumeResult.PendingQuantity,
+					"usage_qty":   product.ProductQty,
+					"pending_qty": 0,
+					"total_qty":   product.ProductQty,
 				}).Error; err != nil {
-				s.Log.Errorf("Failed to update tracking usage for detail_id=%d, product_id=%d: %+v", detail.Id, product.ProductID, err)
+				s.Log.Errorf("Failed to update transfer detail seed fields 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))
+			}
+
+			if strings.EqualFold(flagGroupCode, "AYAM") && outUsageQty > 0 {
+				if err := s.allocatePopulationForStockTransferOut(
+					c.Context(),
+					tx,
+					detail,
+					uint(*detail.SourceProductWarehouseID),
+					outUsageQty,
+				); err != nil {
+					return err
+				}
+			}
+
 			stockLogDecrease := &entity.StockLog{
 				ProductWarehouseId: uint(*detail.SourceProductWarehouseID),
 				CreatedBy:          uint(actorID),
 				Increase:           0,
-				Decrease:           product.ProductQty,
+				Decrease:           outUsageQty,
 				LoggableType:       string(utils.StockLogTypeTransfer),
 				LoggableId:         uint(detail.Id),
 				Notes:              "",
@@ -492,33 +550,12 @@ func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferReques
 				return fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok keluar")
 			}
 
-			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")
-			}
+			inAddedQty := outUsageQty
 
 			stockLogIncrease := &entity.StockLog{
 				ProductWarehouseId: uint(*detail.DestProductWarehouseID),
 				CreatedBy:          uint(actorID),
-				Increase:           product.ProductQty,
+				Increase:           inAddedQty,
 				Decrease:           0,
 				LoggableType:       string(utils.StockLogTypeTransfer),
 				LoggableId:         uint(detail.Id),
@@ -596,6 +633,98 @@ func (s *transferService) CreateOne(c *fiber.Ctx, req *validation.TransferReques
 	return result, nil
 }
 
+func (s *transferService) allocatePopulationForStockTransferOut(
+	ctx context.Context,
+	tx *gorm.DB,
+	detail *entity.StockTransferDetail,
+	sourceProductWarehouseID uint,
+	consumeQty float64,
+) error {
+	if consumeQty <= 0 {
+		return nil
+	}
+	if tx == nil {
+		return errors.New("transaction is required")
+	}
+	if detail == nil || detail.Id == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Data transfer detail tidak valid")
+	}
+	if sourceProductWarehouseID == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Gudang sumber tidak valid")
+	}
+
+	pw, err := s.ProductWarehouseRepo.WithTx(tx).GetByID(ctx, sourceProductWarehouseID, nil)
+	if err != nil {
+		return err
+	}
+	if pw.ProjectFlockKandangId == nil || *pw.ProjectFlockKandangId == 0 {
+		return nil
+	}
+
+	populations, err := s.ProjectFlockPopulationRepo.WithTx(tx).GetByProjectFlockKandangIDAndProductWarehouseID(
+		ctx,
+		*pw.ProjectFlockKandangId,
+		sourceProductWarehouseID,
+	)
+	if err != nil {
+		return err
+	}
+	if len(populations) == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Populasi tidak ditemukan untuk transfer")
+	}
+
+	return fifoV2.AllocatePopulationConsumption(
+		ctx,
+		tx,
+		populations,
+		sourceProductWarehouseID,
+		fifo.UsableKeyStockTransferOut.String(),
+		uint(detail.Id),
+		consumeQty,
+	)
+}
+
+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/module.go

@@ -2,7 +2,6 @@ package marketing
 
 import (
 	"fmt"
-	"strings"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
@@ -20,7 +19,6 @@ 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,26 +31,10 @@ func (MarketingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	userRepo := rUser.NewUserRepository(db)
 	customerRepo := rCustomer.NewCustomerRepository(db)
 	productWarehouseRepo := rProductWarehouse.NewProductWarehouseRepository(db)
+	projectFlockPopulationRepo := rProjectFlockKandang.NewProjectFlockPopulationRepository(db)
 	stockLogRepo := rShared.NewStockLogRepository(db)
 
-	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))
-		}
-	}
+	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
 
 	approvalRepo := commonRepo.NewApprovalRepository(db)
 	approvalSvc := commonSvc.NewApprovalService(approvalRepo)
@@ -64,8 +46,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, fifoService, warehouseRepo, projectFlockKandangRepo, validate)
-	deliveryOrdersService := service.NewDeliveryOrdersService(marketingRepo, marketingProductRepo, marketingDeliveryProductRepo, stockLogRepo, approvalSvc, fifoService, validate)
+	salesOrdersService := service.NewSalesOrdersService(marketingRepo, customerRepo, productWarehouseRepo, userRepo, approvalSvc, fifoStockV2Service, warehouseRepo, projectFlockKandangRepo, validate)
+	deliveryOrdersService := service.NewDeliveryOrdersService(marketingRepo, marketingProductRepo, marketingDeliveryProductRepo, stockLogRepo, productWarehouseRepo, projectFlockPopulationRepo, approvalSvc, fifoStockV2Service, validate)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	RegisterRoutes(router, userService, salesOrdersService, deliveryOrdersService)

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

@@ -6,13 +6,17 @@ import (
 	"fmt"
 	"strings"
 	"time"
+
 	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+	fifoV2 "gitlab.com/mbugroup/lti-api.git/internal/common/service/fifo_stock_v2"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
+	rProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
 	"gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/dto"
 	marketingRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/repositories"
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/validations"
+	rProjectFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
 	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"
@@ -35,8 +39,10 @@ type deliveryOrdersService struct {
 	MarketingProductRepo         marketingRepo.MarketingProductRepository
 	MarketingDeliveryProductRepo marketingRepo.MarketingDeliveryProductRepository
 	StockLogRepo                 rShared.StockLogRepository
+	ProductWarehouseRepo         rProductWarehouse.ProductWarehouseRepository
+	ProjectFlockPopulationRepo   rProjectFlock.ProjectFlockPopulationRepository
 	ApprovalSvc                  commonSvc.ApprovalService
-	FifoSvc                      commonSvc.FifoService
+	FifoStockV2Svc               commonSvc.FifoStockV2Service
 }
 
 func NewDeliveryOrdersService(
@@ -44,8 +50,10 @@ func NewDeliveryOrdersService(
 	marketingProductRepo marketingRepo.MarketingProductRepository,
 	marketingDeliveryProductRepo marketingRepo.MarketingDeliveryProductRepository,
 	stockLogRepo rShared.StockLogRepository,
+	productWarehouseRepo rProductWarehouse.ProductWarehouseRepository,
+	projectFlockPopulationRepo rProjectFlock.ProjectFlockPopulationRepository,
 	approvalSvc commonSvc.ApprovalService,
-	fifoSvc commonSvc.FifoService,
+	fifoStockV2Svc commonSvc.FifoStockV2Service,
 	validate *validator.Validate,
 ) DeliveryOrdersService {
 	return &deliveryOrdersService{
@@ -54,8 +62,10 @@ func NewDeliveryOrdersService(
 		MarketingProductRepo:         marketingProductRepo,
 		MarketingDeliveryProductRepo: marketingDeliveryProductRepo,
 		StockLogRepo:                 stockLogRepo,
+		ProductWarehouseRepo:         productWarehouseRepo,
+		ProjectFlockPopulationRepo:   projectFlockPopulationRepo,
 		ApprovalSvc:                  approvalSvc,
-		FifoSvc:                      fifoSvc,
+		FifoStockV2Svc:               fifoStockV2Svc,
 	}
 }
 
@@ -215,7 +225,6 @@ func (s deliveryOrdersService) GetAll(c *fiber.Ctx, params *validation.DeliveryO
 		}
 		return db.Order("created_at DESC").Order("updated_at DESC")
 	})
-
 	if err != nil {
 		return nil, 0, err
 	}
@@ -260,7 +269,6 @@ func (s deliveryOrdersService) GetOne(c *fiber.Ctx, id uint) (*dto.MarketingDeta
 			return db.Preload("ActionUser")
 		})
 		if err != nil {
-
 		} else if len(approvals) > 0 {
 			if marketing.LatestApproval == nil {
 				latest := approvals[len(approvals)-1]
@@ -312,7 +320,6 @@ func (s *deliveryOrdersService) CreateOne(c *fiber.Ctx, req *validation.Delivery
 	}
 
 	err = s.MarketingRepo.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
-
 		marketingProductRepositoryTx := marketingRepo.NewMarketingProductRepository(dbTransaction)
 		marketingDeliveryProductRepositoryTx := marketingRepo.NewMarketingDeliveryProductRepository(dbTransaction)
 		approvalSvcTx := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
@@ -379,7 +386,6 @@ func (s *deliveryOrdersService) CreateOne(c *fiber.Ctx, req *validation.Delivery
 			deliveryProduct.VehicleNumber = requestedProduct.VehicleNumber
 
 			if requestedProduct.Qty > 0 {
-
 				if err := s.consumeDeliveryStock(c.Context(), dbTransaction, deliveryProduct, foundMarketingProduct, requestedProduct.Qty, actorID); err != nil {
 					return err
 				}
@@ -406,7 +412,6 @@ func (s *deliveryOrdersService) CreateOne(c *fiber.Ctx, req *validation.Delivery
 
 		return nil
 	})
-
 	if err != nil {
 		if fiberErr, ok := err.(*fiber.Error); ok {
 			return nil, fiberErr
@@ -438,7 +443,6 @@ func (s deliveryOrdersService) UpdateOne(c *fiber.Ctx, req *validation.DeliveryO
 	}
 
 	err = s.MarketingRepo.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
-
 		marketingProductRepositoryTx := marketingRepo.NewMarketingProductRepository(dbTransaction)
 		marketingDeliveryProductRepositoryTx := marketingRepo.NewMarketingDeliveryProductRepository(dbTransaction)
 		marketingRepoTx := marketingRepo.NewMarketingRepository(dbTransaction)
@@ -527,7 +531,6 @@ func (s deliveryOrdersService) UpdateOne(c *fiber.Ctx, req *validation.DeliveryO
 
 		return nil
 	})
-
 	if err != nil {
 		if fiberErr, ok := err.(*fiber.Error); ok {
 			return nil, fiberErr
@@ -567,33 +570,45 @@ func (s deliveryOrdersService) consumeDeliveryStock(ctx context.Context, tx *gor
 		return fiber.NewError(fiber.StatusBadRequest, "Delivery product warehouse mismatch with marketing product")
 	}
 
-	result, err := s.FifoSvc.Consume(ctx, commonSvc.StockConsumeRequest{
-		UsableKey:          fifo.UsableKeyMarketingDelivery,
-		UsableID:           deliveryProduct.Id,
-		ProductWarehouseID: deliveryProduct.ProductWarehouseId,
-		Quantity:           requestedQty,
-		AllowPending:       false,
-		Tx:                 tx,
-	})
+	deliveryProductRepo := marketingRepo.NewMarketingDeliveryProductRepository(tx)
+	previousUsage := deliveryProduct.UsageQty
+	deliveryProduct.UsageQty = requestedQty
+	deliveryProduct.PendingQty = 0
 
-	if err != nil {
+	if err := deliveryProductRepo.UpdateOne(ctx, deliveryProduct.Id, deliveryProduct, nil); 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))
 	}
 
-	deliveryProductRepo := marketingRepo.NewMarketingDeliveryProductRepository(tx)
+	refreshed, err := deliveryProductRepo.GetByID(ctx, deliveryProduct.Id, nil)
+	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
 
-	if err := deliveryProductRepo.UpdateFifoFields(ctx, deliveryProduct.Id, result.UsageQuantity, 0); err != nil {
-		return fiber.NewError(fiber.StatusInternalServerError, "Failed to update delivery product")
+	if err := s.allocatePopulationForMarketingDelivery(ctx, tx, deliveryProduct, marketingProduct.ProductWarehouseId); err != nil {
+		return err
 	}
 
-	if actorID > 0 && result.UsageQuantity > 0 {
+	allocatedDelta := deliveryProduct.UsageQty - previousUsage
+	if actorID > 0 && allocatedDelta > 0 {
 		decreaseLog := &entity.StockLog{
-			Decrease:           result.UsageQuantity,
+			Decrease:           allocatedDelta,
 			LoggableType:       string(utils.StockLogTypeMarketing),
 			LoggableId:         deliveryProduct.Id,
 			ProductWarehouseId: deliveryProduct.ProductWarehouseId,
 			CreatedBy:          actorID,
-			Notes:              fmt.Sprintf("FIFO consume (%.2f)", result.UsageQuantity),
+			Notes:              fmt.Sprintf("FIFO v2 reflow consume (%.2f)", allocatedDelta),
 		}
 
 		stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, deliveryProduct.ProductWarehouseId, 1)
@@ -622,35 +637,49 @@ func (s deliveryOrdersService) releaseDeliveryStock(ctx context.Context, tx *gor
 	}
 
 	deliveryProductRepo := marketingRepo.NewMarketingDeliveryProductRepository(tx)
-	currentUsage, err := deliveryProductRepo.GetUsageQty(ctx, deliveryProduct.Id)
-	if err != nil {
-		currentUsage = 0
-	}
-
-	if currentUsage == 0 {
+	currentUsage := deliveryProduct.UsageQty
+	currentPending := deliveryProduct.PendingQty
+	if currentUsage <= 0 && currentPending <= 0 {
 		return nil
 	}
 
-	if err := s.FifoSvc.ReleaseUsage(ctx, commonSvc.StockReleaseRequest{
-		UsableKey: fifo.UsableKeyMarketingDelivery,
-		UsableID:  deliveryProduct.Id,
-		Tx:        tx,
-	}); err != nil {
+	deliveryProduct.UsageQty = 0
+	deliveryProduct.PendingQty = 0
+	if err := deliveryProductRepo.UpdateOne(ctx, deliveryProduct.Id, deliveryProduct, nil); err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "Failed to reset 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("Failed to reflow stock for product warehouse %d: %v", marketingProduct.ProductWarehouseId, err))
+	}
+
+	refreshed, err := deliveryProductRepo.GetByID(ctx, deliveryProduct.Id, nil)
+	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
+
+	if err := fifoV2.ReleasePopulationConsumptionByUsable(ctx, tx, fifo.UsableKeyMarketingDelivery.String(), deliveryProduct.Id); err != nil {
 		return err
 	}
 
-	if err := deliveryProductRepo.ResetFifoFields(ctx, deliveryProduct.Id); err != nil {
-		return err
-	}
-
-	if actorID > 0 && currentUsage > 0 {
+	releasedUsage := currentUsage - deliveryProduct.UsageQty
+	if actorID > 0 && releasedUsage > 0 {
 		increaseLog := &entity.StockLog{
-			Increase:           currentUsage,
+			Increase:           releasedUsage,
 			LoggableType:       string(utils.StockLogTypeMarketing),
 			LoggableId:         deliveryProduct.Id,
 			ProductWarehouseId: marketingProduct.ProductWarehouseId,
 			CreatedBy:          actorID,
-			Notes:              fmt.Sprintf("Release delivery stock (%.2f)", currentUsage),
+			Notes:              fmt.Sprintf("FIFO v2 reflow release (%.2f)", releasedUsage),
 		}
 		stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, marketingProduct.ProductWarehouseId, 1)
 		if err != nil {
@@ -668,3 +697,57 @@ func (s deliveryOrdersService) releaseDeliveryStock(ctx context.Context, tx *gor
 
 	return nil
 }
+
+func (s deliveryOrdersService) allocatePopulationForMarketingDelivery(
+	ctx context.Context,
+	tx *gorm.DB,
+	deliveryProduct *entity.MarketingDeliveryProduct,
+	productWarehouseID uint,
+) error {
+	if deliveryProduct == nil || deliveryProduct.Id == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Delivery product tidak valid")
+	}
+	if tx == nil {
+		return errors.New("transaction is required")
+	}
+	if deliveryProduct.UsageQty <= 0 {
+		return nil
+	}
+	if productWarehouseID == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Product warehouse tidak ditemukan")
+	}
+
+	flagGroupCode, err := resolveMarketingFlagGroupByProductWarehouse(ctx, tx, productWarehouseID)
+	if err != nil {
+		return err
+	}
+	if !strings.EqualFold(flagGroupCode, "AYAM") {
+		return nil
+	}
+
+	pw, err := s.ProductWarehouseRepo.WithTx(tx).GetByID(ctx, productWarehouseID, nil)
+	if err != nil {
+		return err
+	}
+	if pw.ProjectFlockKandangId == nil || *pw.ProjectFlockKandangId == 0 {
+		return nil
+	}
+
+	populations, err := s.ProjectFlockPopulationRepo.WithTx(tx).GetByProjectFlockKandangIDAndProductWarehouseID(ctx, *pw.ProjectFlockKandangId, productWarehouseID)
+	if err != nil {
+		return err
+	}
+	if len(populations) == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Populasi tidak ditemukan untuk delivery")
+	}
+
+	return fifoV2.AllocatePopulationConsumption(
+		ctx,
+		tx,
+		populations,
+		productWarehouseID,
+		fifo.UsableKeyMarketingDelivery.String(),
+		deliveryProduct.Id,
+		deliveryProduct.UsageQty,
+	)
+}

internal/modules/marketing/services/fifo_stock_v2_helper.go

@@ -0,0 +1,97 @@
+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,7 +20,6 @@ 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"
@@ -43,12 +42,12 @@ type salesOrdersService struct {
 	ProductWarehouseRepo    productWarehouseRepo.ProductWarehouseRepository
 	UserRepo                userRepo.UserRepository
 	ApprovalSvc             commonSvc.ApprovalService
-	FifoSvc                 commonSvc.FifoService
+	FifoStockV2Svc          commonSvc.FifoStockV2Service
 	WarehouseRepo           warehouseRepo.WarehouseRepository
 	ProjectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository
 }
 
-func NewSalesOrdersService(marketingRepo repository.MarketingRepository, customerRepo customerRepo.CustomerRepository, productWarehouseRepo productWarehouseRepo.ProductWarehouseRepository, userRepo userRepo.UserRepository, approvalSvc commonSvc.ApprovalService, fifoSvc commonSvc.FifoService, warehouseRepo warehouseRepo.WarehouseRepository,
+func NewSalesOrdersService(marketingRepo repository.MarketingRepository, customerRepo customerRepo.CustomerRepository, productWarehouseRepo productWarehouseRepo.ProductWarehouseRepository, userRepo userRepo.UserRepository, approvalSvc commonSvc.ApprovalService, fifoStockV2Svc commonSvc.FifoStockV2Service, warehouseRepo warehouseRepo.WarehouseRepository,
 	projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository, validate *validator.Validate) SalesOrdersService {
 	return &salesOrdersService{
 		Log:                     utils.Log,
@@ -58,7 +57,7 @@ func NewSalesOrdersService(marketingRepo repository.MarketingRepository, custome
 		ProductWarehouseRepo:    productWarehouseRepo,
 		UserRepo:                userRepo,
 		ApprovalSvc:             approvalSvc,
-		FifoSvc:                 fifoSvc,
+		FifoStockV2Svc:          fifoStockV2Svc,
 		WarehouseRepo:           warehouseRepo,
 		ProjectFlockKandangRepo: projectFlockKandangRepo,
 	}
@@ -401,15 +400,18 @@ 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 {
-							_, err := s.FifoSvc.Consume(c.Context(), commonSvc.StockConsumeRequest{
-								UsableKey:          fifo.UsableKeyMarketingDelivery,
-								UsableID:           deliveryProduct.Id,
-								ProductWarehouseID: rp.ProductWarehouseId,
-								Quantity:           qtyDiff,
-								Tx:                 dbTransaction,
-							})
-							if err != nil {
-								return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Insufficient stock for additional quantity: %v", err))
+							nextRequestedQty := deliveryProduct.UsageQty + deliveryProduct.PendingQty + qtyDiff
+							if err := invDeliveryRepoTx.UpdateFifoFields(c.Context(), deliveryProduct.Id, nextRequestedQty, 0); err != nil {
+								return fiber.NewError(fiber.StatusInternalServerError, "Failed to update marketing delivery fifo fields")
+							}
+							if err := reflowMarketingScope(
+								c.Context(),
+								s.FifoStockV2Svc,
+								dbTransaction,
+								rp.ProductWarehouseId,
+								resolveMarketingAsOf(deliveryProduct.DeliveryDate, deliveryProduct.CreatedAt),
+							); err != nil {
+								return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to reflow stock via FIFO v2: %v", err))
 							}
 						}
 					}
@@ -464,12 +466,17 @@ 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 := s.FifoSvc.ReleaseUsage(c.Context(), commonSvc.StockReleaseRequest{
-							UsableKey: fifo.UsableKeyMarketingDelivery,
-							UsableID:  deliveryProduct.Id,
-							Tx:        dbTransaction,
-						}); err != nil {
-							return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to release stock: %v", err))
+						if err := invDeliveryRepoTx.UpdateFifoFields(c.Context(), deliveryProduct.Id, 0, 0); err != nil {
+							return fiber.NewError(fiber.StatusInternalServerError, "Failed to reset marketing delivery fifo fields")
+						}
+						if err := reflowMarketingScope(
+							c.Context(),
+							s.FifoStockV2Svc,
+							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 {
@@ -548,12 +555,17 @@ 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 := s.FifoSvc.ReleaseUsage(c.Context(), commonSvc.StockReleaseRequest{
-						UsableKey: fifo.UsableKeyMarketingDelivery,
-						UsableID:  dp.Id,
-						Tx:        dbTransaction,
-					}); err != nil {
-						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to release stock for delivery product %d: %v", dp.Id, err))
+					if err := marketingDeliveryProductRepoTx.UpdateFifoFields(c.Context(), dp.Id, 0, 0); err != nil {
+						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to reset fifo fields for delivery product %d", dp.Id))
+					}
+					if err := reflowMarketingScope(
+						c.Context(),
+						s.FifoStockV2Svc,
+						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/master/products/controllers/product.controller.go

@@ -30,6 +30,14 @@ func (u *ProductController) GetAll(c *fiber.Ctx) error {
 		ProductCategoryID: c.QueryInt("product_category_id", 0),
 	}
 
+	if isDepletionParam := c.Query("is_depletion", ""); isDepletionParam != "" {
+		value, err := strconv.ParseBool(isDepletionParam)
+		if err != nil {
+			return fiber.NewError(fiber.StatusBadRequest, "invalid is_depletion value")
+		}
+		query.IsDepletion = &value
+	}
+
 	if query.Page < 1 || query.Limit < 1 {
 		return fiber.NewError(fiber.StatusBadRequest, "page and limit must be greater than 0")
 	}

internal/modules/master/products/dto/product.dto.go

@@ -7,6 +7,7 @@ import (
 	productCategoryDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/product-categories/dto"
 	uomDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/uoms/dto"
 	userDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/users/dto"
+	utils "gitlab.com/mbugroup/lti-api.git/internal/utils"
 )
 
 // === DTO Structs ===
@@ -17,6 +18,9 @@ type ProductRelationDTO struct {
 	ProductPrice    float64                                        `gorm:"type:numeric(15,3);not null"`
 	SellingPrice    *float64                                       `gorm:"type:numeric(15,3)"`
 	Uom             *uomDTO.UomRelationDTO                         `json:"uom,omitempty"`
+	Flag            *string                                        `json:"flag,omitempty"`
+	SubFlag         *string                                        `json:"sub_flag,omitempty"`
+	SubFlags        *[]string                                      `json:"sub_flags,omitempty"`
 	Flags           *[]string                                      `json:"flags,omitempty"`
 	ProductCategory *productCategoryDTO.ProductCategoryRelationDTO `json:"product_category,omitempty"`
 	Suppliers       []ProductSupplierDTO                           `json:"suppliers"`
@@ -31,6 +35,9 @@ type ProductListDTO struct {
 	SellingPrice    *float64                                       `json:"selling_price,omitempty"`
 	Tax             *float64                                       `json:"tax,omitempty"`
 	ExpiryPeriod    *int                                           `json:"expiry_period,omitempty"`
+	Flag            *string                                        `json:"flag,omitempty"`
+	SubFlag         *string                                        `json:"sub_flag,omitempty"`
+	SubFlags        []string                                       `json:"sub_flags,omitempty"`
 	Flags           []string                                       `json:"flags"`
 	Uom             *uomDTO.UomRelationDTO                         `json:"uom,omitempty"`
 	ProductCategory *productCategoryDTO.ProductCategoryRelationDTO `json:"product_category,omitempty"`
@@ -59,6 +66,13 @@ func ToProductRelationDTO(e entity.Product) ProductRelationDTO {
 	for i, f := range e.Flags {
 		flags[i] = f.Name
 	}
+	flag, subFlag, subFlags := resolveProductFlagAndSubFlags(flags)
+	var subFlagsRef *[]string
+	if len(subFlags) > 0 {
+		values := make([]string, len(subFlags))
+		copy(values, subFlags)
+		subFlagsRef = &values
+	}
 
 	var uomRef *uomDTO.UomRelationDTO
 	if e.Uom.Id != 0 {
@@ -77,6 +91,9 @@ func ToProductRelationDTO(e entity.Product) ProductRelationDTO {
 		Name:            e.Name,
 		ProductPrice:    e.ProductPrice,
 		SellingPrice:    e.SellingPrice,
+		Flag:            flag,
+		SubFlag:         subFlag,
+		SubFlags:        subFlagsRef,
 		Flags:           &flags,
 		Uom:             uomRef,
 		ProductCategory: categoryRef,
@@ -101,6 +118,7 @@ func ToProductListDTO(e entity.Product) ProductListDTO {
 	for i, f := range e.Flags {
 		flags[i] = f.Name
 	}
+	flag, subFlag, subFlags := resolveProductFlagAndSubFlags(flags)
 
 	var uomRef *uomDTO.UomRelationDTO
 	if e.Uom.Id != 0 {
@@ -111,6 +129,9 @@ func ToProductListDTO(e entity.Product) ProductListDTO {
 	return ProductListDTO{
 		Id:              e.Id,
 		Name:            e.Name,
+		Flag:            flag,
+		SubFlag:         subFlag,
+		SubFlags:        subFlags,
 		Flags:           flags,
 		Uom:             uomRef,
 		Brand:           e.Brand,
@@ -141,6 +162,58 @@ func ToProductDetailDTO(e entity.Product) ProductDetailDTO {
 	}
 }
 
+func resolveProductFlagAndSubFlags(flags []string) (*string, *string, []string) {
+	normalized := utils.NormalizeFlagTypes(flags)
+	if len(normalized) == 0 {
+		return nil, nil, nil
+	}
+
+	available := make(map[utils.FlagType]struct{}, len(normalized))
+	for _, flag := range normalized {
+		available[flag] = struct{}{}
+	}
+
+	var selectedFlag utils.FlagType
+	for _, mainFlag := range utils.ProductMainFlags() {
+		if _, ok := available[mainFlag]; ok {
+			selectedFlag = mainFlag
+			break
+		}
+	}
+
+	if selectedFlag == "" {
+		subToMain := utils.ProductSubFlagToFlag()
+		for _, flag := range normalized {
+			if parent, ok := subToMain[flag]; ok {
+				selectedFlag = parent
+				break
+			}
+		}
+	}
+
+	if selectedFlag == "" {
+		return nil, nil, nil
+	}
+
+	flag := string(selectedFlag)
+
+	var subFlag *string
+	subFlagValues := make([]string, 0)
+	subFlagsByMain := utils.ProductSubFlagsByFlag()
+	for _, sub := range subFlagsByMain[selectedFlag] {
+		if _, ok := available[sub]; ok {
+			subFlagValues = append(subFlagValues, string(sub))
+		}
+	}
+
+	if len(subFlagValues) > 0 {
+		first := subFlagValues[0]
+		subFlag = &first
+	}
+
+	return &flag, subFlag, subFlagValues
+}
+
 func toProductSupplierDTOs(relations []entity.ProductSupplier) []ProductSupplierDTO {
 	if len(relations) == 0 {
 		return make([]ProductSupplierDTO, 0)

internal/modules/master/products/services/product.service.go

@@ -31,6 +31,12 @@ type productService struct {
 	Repository repository.ProductRepository
 }
 
+var depletionProductFlags = []string{
+	string(utils.FlagAyamAfkir),
+	string(utils.FlagAyamCulling),
+	string(utils.FlagAyamMati),
+}
+
 func normalizeProductFlags(raw []string) ([]string, error) {
 	normalized, invalid := utils.NormalizeFlagsForGroup(raw, utils.FlagGroupProduct)
 	if len(invalid) > 0 {
@@ -41,6 +47,159 @@ func normalizeProductFlags(raw []string) ([]string, error) {
 	return utils.FlagTypesToStrings(normalized), nil
 }
 
+func productMainFlagOptionsString() []string {
+	mainFlags := utils.ProductMainFlags()
+	result := make([]string, len(mainFlags))
+	for i, flag := range mainFlags {
+		result[i] = string(flag)
+	}
+	return result
+}
+
+func productSubFlagOptionsString(flag utils.FlagType) []string {
+	subFlagsByFlag := utils.ProductSubFlagsByFlag()
+	subFlags := subFlagsByFlag[flag]
+	result := make([]string, len(subFlags))
+	for i, subFlag := range subFlags {
+		result[i] = string(subFlag)
+	}
+	return result
+}
+
+func normalizeStructuredSubFlagsInput(subFlagRaw *string, subFlagsRaw []string, hasSubFlagsField bool) ([]utils.FlagType, error) {
+	values := make([]string, 0, len(subFlagsRaw)+1)
+
+	if subFlagRaw != nil {
+		single := strings.TrimSpace(*subFlagRaw)
+		if single == "" {
+			return nil, fiber.NewError(fiber.StatusBadRequest, "sub_flag cannot be empty")
+		}
+		values = append(values, single)
+	}
+
+	if hasSubFlagsField {
+		for _, raw := range subFlagsRaw {
+			item := strings.TrimSpace(raw)
+			if item == "" {
+				return nil, fiber.NewError(fiber.StatusBadRequest, "sub_flags cannot contain empty value")
+			}
+			values = append(values, item)
+		}
+	}
+
+	if len(values) == 0 {
+		return nil, nil
+	}
+
+	return utils.NormalizeFlagTypes(values), nil
+}
+
+func resolveProductFlagsFromFlagInput(flagRaw *string, subFlagRaw *string, subFlagsRaw []string, hasSubFlagsField bool) ([]string, bool, error) {
+	if flagRaw == nil && subFlagRaw == nil && !hasSubFlagsField {
+		return nil, false, nil
+	}
+
+	if flagRaw == nil && (subFlagRaw != nil || hasSubFlagsField) {
+		return nil, false, fiber.NewError(fiber.StatusBadRequest, "flag is required when sub_flag/sub_flags is provided")
+	}
+
+	flagText := strings.TrimSpace(*flagRaw)
+	if flagText == "" {
+		return nil, false, fiber.NewError(fiber.StatusBadRequest, "flag cannot be empty")
+	}
+
+	flag := utils.CanonicalFlagType(flagText)
+	if !utils.IsProductMainFlag(flag) {
+		return nil, false, fiber.NewError(
+			fiber.StatusBadRequest,
+			fmt.Sprintf("Invalid product flag: %s. Allowed flags: %s", flagText, strings.Join(productMainFlagOptionsString(), ", ")),
+		)
+	}
+
+	out := []string{string(flag)}
+
+	normalizedSubFlags, err := normalizeStructuredSubFlagsInput(subFlagRaw, subFlagsRaw, hasSubFlagsField)
+	if err != nil {
+		return nil, false, err
+	}
+
+	if len(normalizedSubFlags) == 0 {
+		if !utils.ProductFlagAllowWithoutSubFlag(flag) {
+			return nil, false, fiber.NewError(
+				fiber.StatusBadRequest,
+				fmt.Sprintf("sub_flag/sub_flags is required for flag %s", string(flag)),
+			)
+		}
+		normalizedOut, normalizeErr := normalizeProductFlags(out)
+		if normalizeErr != nil {
+			return nil, false, normalizeErr
+		}
+		return normalizedOut, true, nil
+	}
+
+	invalidSubFlags := make([]string, 0)
+	for _, subFlag := range normalizedSubFlags {
+		if !utils.IsValidProductSubFlag(flag, subFlag) {
+			invalidSubFlags = append(invalidSubFlags, string(subFlag))
+		}
+	}
+	if len(invalidSubFlags) > 0 {
+		return nil, false, fiber.NewError(
+			fiber.StatusBadRequest,
+			fmt.Sprintf("Invalid sub_flags %s for flag %s. Allowed sub_flags: %s", strings.Join(invalidSubFlags, ", "), string(flag), strings.Join(productSubFlagOptionsString(flag), ", ")),
+		)
+	}
+
+	out = append(out, utils.FlagTypesToStrings(normalizedSubFlags)...)
+	normalizedOut, normalizeErr := normalizeProductFlags(out)
+	if normalizeErr != nil {
+		return nil, false, normalizeErr
+	}
+	return normalizedOut, true, nil
+}
+
+func resolveCreateProductFlags(req *validation.Create) ([]string, error) {
+	hasStructuredInput := req.Flag != nil || req.SubFlag != nil || req.SubFlags != nil
+	if len(req.Flags) > 0 && hasStructuredInput {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Use either flags or flag/sub_flag/sub_flags, not both")
+	}
+
+	if len(req.Flags) > 0 {
+		return normalizeProductFlags(req.Flags)
+	}
+
+	flags, _, err := resolveProductFlagsFromFlagInput(req.Flag, req.SubFlag, req.SubFlags, req.SubFlags != nil)
+	return flags, err
+}
+
+func resolveUpdateProductFlags(req *validation.Update) (bool, []string, error) {
+	hasStructuredInput := req.Flag != nil || req.SubFlag != nil || req.SubFlags != nil
+
+	if req.Flags != nil {
+		if hasStructuredInput {
+			if len(*req.Flags) > 0 {
+				return false, nil, fiber.NewError(fiber.StatusBadRequest, "Use either flags or flag/sub_flag/sub_flags, not both")
+			}
+		} else {
+			flags, err := normalizeProductFlags(*req.Flags)
+			if err != nil {
+				return false, nil, err
+			}
+			return true, flags, nil
+		}
+	}
+
+	subFlagsRaw := make([]string, 0)
+	if req.SubFlags != nil {
+		subFlagsRaw = *req.SubFlags
+	}
+	flags, provided, err := resolveProductFlagsFromFlagInput(req.Flag, req.SubFlag, subFlagsRaw, req.SubFlags != nil)
+	if err != nil {
+		return false, nil, err
+	}
+	return provided, flags, nil
+}
+
 func NewProductService(repo repository.ProductRepository, validate *validator.Validate) ProductService {
 	return &productService{
 		Log:        utils.Log,
@@ -70,12 +229,32 @@ func (s productService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity
 
 	products, total, err := s.Repository.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
 		db = s.withRelations(db)
-		db = db.Where("is_visible = ?", true)
+		// Depletion master products are system products and often stored with is_visible = false.
+		// When requested explicitly via is_depletion=true, include hidden records.
+		if params.IsDepletion == nil || !*params.IsDepletion {
+			db = db.Where("is_visible = ?", true)
+		}
 		if params.Search != "" {
-			return db.Where("name ILIKE ?", "%"+params.Search+"%")
+			db = db.Where("name ILIKE ?", "%"+params.Search+"%")
 		}
 		if params.ProductCategoryID != 0 {
-			return db.Where("product_category_id = ?", params.ProductCategoryID)
+			db = db.Where("product_category_id = ?", params.ProductCategoryID)
+		}
+		if params.IsDepletion != nil {
+			existsQuery := `
+				EXISTS (
+					SELECT 1
+					FROM flags f
+					WHERE f.flagable_type = ?
+					  AND f.flagable_id = products.id
+					  AND UPPER(f.name) IN ?
+				)
+			`
+			if *params.IsDepletion {
+				db = db.Where(existsQuery, entity.FlagableTypeProduct, depletionProductFlags)
+			} else {
+				db = db.Where("NOT "+existsQuery, entity.FlagableTypeProduct, depletionProductFlags)
+			}
 		}
 		return db.Order("created_at DESC").Order("updated_at DESC")
 	})
@@ -177,7 +356,7 @@ func (s *productService) CreateOne(c *fiber.Ctx, req *validation.Create) (*entit
 		}
 	}
 
-	productFlags, flagErr := normalizeProductFlags(req.Flags)
+	productFlags, flagErr := resolveCreateProductFlags(req)
 	if flagErr != nil {
 		return nil, flagErr
 	}
@@ -337,13 +516,10 @@ func (s productService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
 		flagUpdate bool
 		flagValues []string
 	)
-	if req.Flags != nil {
-		flagUpdate = true
-		var flagErr error
-		flagValues, flagErr = normalizeProductFlags(*req.Flags)
-		if flagErr != nil {
-			return nil, flagErr
-		}
+	var flagErr error
+	flagUpdate, flagValues, flagErr = resolveUpdateProductFlags(req)
+	if flagErr != nil {
+		return nil, flagErr
 	}
 
 	if len(updateBody) == 0 && !supplierUpdate && !flagUpdate {

internal/modules/master/products/validations/product.validation.go

@@ -6,31 +6,37 @@ type SupplierPrice struct {
 }
 
 type Create struct {
-	Name              string   `json:"name" validate:"required_strict,min=3,max=50"`
-	Brand             string   `json:"brand" validate:"required_strict,min=2,max=50"`
-	Sku               *string  `json:"sku,omitempty" validate:"omitempty,max=100"`
-	UomID             uint     `json:"uom_id" validate:"required,gt=0"`
-	ProductCategoryID uint     `json:"product_category_id" validate:"required,gt=0"`
-	ProductPrice      float64  `json:"product_price" validate:"required"`
-	SellingPrice      *float64 `json:"selling_price,omitempty" validate:"omitempty"`
-	Tax               *float64 `json:"tax,omitempty" validate:"omitempty"`
-	ExpiryPeriod      *int     `json:"expiry_period,omitempty" validate:"omitempty,gt=0"`
+	Name              string          `json:"name" validate:"required_strict,min=3,max=50"`
+	Brand             string          `json:"brand" validate:"required_strict,min=2,max=50"`
+	Sku               *string         `json:"sku,omitempty" validate:"omitempty,max=100"`
+	UomID             uint            `json:"uom_id" validate:"required,gt=0"`
+	ProductCategoryID uint            `json:"product_category_id" validate:"required,gt=0"`
+	ProductPrice      float64         `json:"product_price" validate:"required"`
+	SellingPrice      *float64        `json:"selling_price,omitempty" validate:"omitempty"`
+	Tax               *float64        `json:"tax,omitempty" validate:"omitempty"`
+	ExpiryPeriod      *int            `json:"expiry_period,omitempty" validate:"omitempty,gt=0"`
 	Suppliers         []SupplierPrice `json:"suppliers,omitempty" validate:"omitempty,dive"`
-	Flags             []string `json:"flags,omitempty" validate:"omitempty,dive"`
+	Flag              *string         `json:"flag,omitempty" validate:"omitempty,max=50"`
+	SubFlag           *string         `json:"sub_flag,omitempty" validate:"omitempty,max=50"`
+	SubFlags          []string        `json:"sub_flags,omitempty" validate:"omitempty,dive,max=50"`
+	Flags             []string        `json:"flags,omitempty" validate:"omitempty,dive"`
 }
 
 type Update struct {
-	Name              *string   `json:"name,omitempty" validate:"omitempty,min=3"`
-	Brand             *string   `json:"brand,omitempty" validate:"omitempty,min=2"`
-	Sku               *string   `json:"sku,omitempty" validate:"omitempty"`
-	UomID             *uint     `json:"uom_id,omitempty" validate:"omitempty,gt=0"`
-	ProductCategoryID *uint     `json:"product_category_id,omitempty" validate:"omitempty,gt=0"`
-	ProductPrice      *float64  `json:"product_price,omitempty" validate:"omitempty"`
-	SellingPrice      *float64  `json:"selling_price,omitempty" validate:"omitempty"`
-	Tax               *float64  `json:"tax,omitempty" validate:"omitempty"`
-	ExpiryPeriod      *int      `json:"expiry_period,omitempty" validate:"omitempty,gt=0"`
+	Name              *string          `json:"name,omitempty" validate:"omitempty,min=3"`
+	Brand             *string          `json:"brand,omitempty" validate:"omitempty,min=2"`
+	Sku               *string          `json:"sku,omitempty" validate:"omitempty"`
+	UomID             *uint            `json:"uom_id,omitempty" validate:"omitempty,gt=0"`
+	ProductCategoryID *uint            `json:"product_category_id,omitempty" validate:"omitempty,gt=0"`
+	ProductPrice      *float64         `json:"product_price,omitempty" validate:"omitempty"`
+	SellingPrice      *float64         `json:"selling_price,omitempty" validate:"omitempty"`
+	Tax               *float64         `json:"tax,omitempty" validate:"omitempty"`
+	ExpiryPeriod      *int             `json:"expiry_period,omitempty" validate:"omitempty,gt=0"`
 	Suppliers         *[]SupplierPrice `json:"suppliers,omitempty" validate:"omitempty,dive"`
-	Flags             *[]string `json:"flags,omitempty" validate:"omitempty,dive"`
+	Flag              *string          `json:"flag,omitempty" validate:"omitempty,max=50"`
+	SubFlag           *string          `json:"sub_flag,omitempty" validate:"omitempty,max=50"`
+	SubFlags          *[]string        `json:"sub_flags,omitempty" validate:"omitempty,dive,max=50"`
+	Flags             *[]string        `json:"flags,omitempty" validate:"omitempty,dive"`
 }
 
 type Query struct {
@@ -38,4 +44,5 @@ type Query struct {
 	Limit             int    `query:"limit" validate:"omitempty,number,min=1"`
 	Search            string `query:"search" validate:"omitempty,max=50"`
 	ProductCategoryID int    `query:"product_category_id" validate:"omitempty,number,min=1"`
+	IsDepletion       *bool  `query:"is_depletion" validate:"omitempty"`
 }

internal/modules/production/chickins/module.go

@@ -2,7 +2,6 @@ package chickins
 
 import (
 	"fmt"
-	"strings"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
@@ -10,7 +9,6 @@ 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"
@@ -20,6 +18,7 @@ import (
 	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"
+	rTransferLaying "gitlab.com/mbugroup/lti-api.git/internal/modules/production/transfer_layings/repositories"
 
 	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
 	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
@@ -38,47 +37,12 @@ func (ChickinModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 	projectflockkandangrepo := rProjectFlock.NewProjectFlockKandangRepository(db)
 	projectflockpopulationrepo := rProjectFlock.NewProjectFlockPopulationRepository(db)
 	projectFlockRepo := rProjectFlock.NewProjectflockRepository(db)
+	transferLayingRepo := rTransferLaying.NewTransferLayingRepository(db)
 	productWarehouseRepo := rProductWarehouse.NewProductWarehouseRepository(db)
 	productRepo := rProduct.NewProductRepository(db)
-	stockAllocationRepo := commonRepo.NewStockAllocationRepository(db)
-	fifoService := commonSvc.NewFifoService(db, stockAllocationRepo, productWarehouseRepo, utils.Log)
+	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, 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 {
@@ -95,8 +59,9 @@ func (ChickinModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 		projectflockkandangrepo,
 		projectflockpopulationrepo,
 		chickinDetailRepo,
+		transferLayingRepo,
 		validate,
-		fifoService)
+		fifoStockV2Service)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	ChickinRoutes(router, userService, chickinService)

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

@@ -4,7 +4,9 @@ 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"
@@ -17,6 +19,7 @@ import (
 	repository "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins/repositories"
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins/validations"
 	rProjectFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
+	rTransferLaying "gitlab.com/mbugroup/lti-api.git/internal/modules/production/transfer_layings/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"
@@ -25,10 +28,9 @@ import (
 	"github.com/gofiber/fiber/v2"
 	"github.com/sirupsen/logrus"
 	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
 )
 
-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)
@@ -51,11 +53,12 @@ type chickinService struct {
 	ProjectflockKandangRepo    rProjectFlock.ProjectFlockKandangRepository
 	ProjectflockPopulationRepo rProjectFlock.ProjectFlockPopulationRepository
 	ProjectChickinDetailRepo   repository.ProjectChickinDetailRepository
-	FifoSvc                    commonSvc.FifoService
+	TransferLayingRepo         rTransferLaying.TransferLayingRepository
+	FifoStockV2Svc             commonSvc.FifoStockV2Service
 	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, fifoSvc commonSvc.FifoService) 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, transferLayingRepo rTransferLaying.TransferLayingRepository, validate *validator.Validate, fifoStockV2Svc commonSvc.FifoStockV2Service) ChickinService {
 	return &chickinService{
 		Log:                        utils.Log,
 		Validate:                   validate,
@@ -68,7 +71,8 @@ func NewChickinService(repo repository.ProjectChickinRepository, kandangRepo Kan
 		ProjectflockKandangRepo:    projectflockkandangRepo,
 		ProjectflockPopulationRepo: projectflockpopulationRepo,
 		ProjectChickinDetailRepo:   projectChickinDetailRepo,
-		FifoSvc:                    fifoSvc,
+		TransferLayingRepo:         transferLayingRepo,
+		FifoStockV2Svc:             fifoStockV2Svc,
 		StockLogRepo:               rStockLogs.NewStockLogRepository(repo.DB()),
 	}
 }
@@ -120,11 +124,36 @@ func (s chickinService) GetOne(c *fiber.Ctx, id uint) (*entity.ProjectChickin, e
 	return chickin, nil
 }
 
+func (s chickinService) ensureNotTransferred(ctx context.Context, projectFlockKandangID uint) error {
+	if projectFlockKandangID == 0 || s.TransferLayingRepo == nil {
+		return nil
+	}
+
+	transfer, err := s.TransferLayingRepo.GetLatestApprovedBySourceKandang(ctx, projectFlockKandangID)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil
+		}
+		s.Log.Errorf("Failed to resolve transfer laying by source kandang %d: %+v", projectFlockKandangID, err)
+		return fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi transfer laying")
+	}
+
+	if transfer != nil && transfer.ExecutedAt != nil && !transfer.ExecutedAt.IsZero() {
+		return fiber.NewError(fiber.StatusBadRequest, "Project flock kandang sudah dipindahkan ke laying")
+	}
+
+	return nil
+}
+
 func (s *chickinService) CreateOne(c *fiber.Ctx, req *validation.Create) ([]entity.ProjectChickin, error) {
 	if err := s.Validate.Struct(req); err != nil {
 		return nil, err
 	}
 
+	if err := s.ensureNotTransferred(c.Context(), req.ProjectFlockKandangId); err != nil {
+		return nil, err
+	}
+
 	projectFlockKandang, err := s.ProjectflockKandangRepo.GetByID(c.Context(), req.ProjectFlockKandangId)
 	if err != nil {
 		return nil, fiber.NewError(fiber.StatusNotFound, "Project Flock Kandang not found")
@@ -160,30 +189,31 @@ func (s *chickinService) CreateOne(c *fiber.Ctx, req *validation.Create) ([]enti
 			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Product warehouse %d belongs to different flock. Only product warehouses with project_flock_kandang_id = NULL or = %d can be used", chickinReq.ProductWarehouseId, req.ProjectFlockKandangId))
 		}
 
-		if productWarehouse.Product.Id != 0 {
+			if productWarehouse.Product.Id != 0 {
+				category := strings.ToUpper(strings.TrimSpace(projectFlockKandang.ProjectFlock.Category))
+				if category != string(utils.ProjectFlockCategoryGrowing) && category != string(utils.ProjectFlockCategoryLaying) {
+					return nil, fmt.Errorf("invalid flock category for chickin")
+				}
 
-			var requiredFlag utils.FlagType
-			if projectFlockKandang.ProjectFlock.Category == string(utils.ProjectFlockCategoryGrowing) {
-				requiredFlag = utils.FlagDOC
-			} else if projectFlockKandang.ProjectFlock.Category == string(utils.ProjectFlockCategoryLaying) {
-				requiredFlag = utils.FlagPullet
-			} else {
-				return nil, fmt.Errorf("invalid flock category for chickin")
-			}
+				hasAyamFlag := false
+				for _, flag := range productWarehouse.Product.Flags {
+					if utils.CanonicalFlagType(flag.Name) == utils.FlagAyam {
+						hasAyamFlag = true
+						break
+					}
+				}
 
-			hasRequiredFlag := false
-			for _, flag := range productWarehouse.Product.Flags {
-				if utils.FlagType(flag.Name) == requiredFlag {
-					hasRequiredFlag = true
-					break
+				if !hasAyamFlag {
+					return nil, fmt.Errorf(
+						"product warehouse %d cannot be used for %s chickin. Product must have AYAM flag (or legacy alias DOC/PULLET/LAYER) (product ID: %d, warehouse ID: %d)",
+						chickinReq.ProductWarehouseId,
+						projectFlockKandang.ProjectFlock.Category,
+						productWarehouse.Product.Id,
+						productWarehouse.Id,
+					)
 				}
 			}
 
-			if !hasRequiredFlag {
-				return nil, fmt.Errorf("product warehouse %d cannot be used for %s chickin. Product must have %s flag (product ID: %d, warehouse ID: %d)", chickinReq.ProductWarehouseId, projectFlockKandang.ProjectFlock.Category, requiredFlag, productWarehouse.Product.Id, productWarehouse.Id)
-			}
-		}
-
 		chickinDate, err := utils.ParseDateString(chickinReq.ChickInDate)
 		if err != nil {
 			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Invalid ChickInDate format for product warehouse %d", chickinReq.ProductWarehouseId))
@@ -260,7 +290,7 @@ func (s *chickinService) CreateOne(c *fiber.Ctx, req *validation.Create) ([]enti
 
 		for idx, chickin := range newChikins {
 			desiredQty := chickinQtyMap[uint(idx)]
-			if err := s.ConsumeChickinStocks(c.Context(), dbTransaction, chickin, desiredQty, actorID); err != nil {
+			if err := s.StageChickinStocks(c.Context(), dbTransaction, chickin, desiredQty, actorID); err != nil {
 				return err
 			}
 		}
@@ -334,6 +364,17 @@ func (s chickinService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
 		return nil, err
 	}
 
+	chickin, err := s.Repository.GetByID(c.Context(), id, nil)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, fiber.NewError(fiber.StatusNotFound, "Chickin not found")
+		}
+		return nil, err
+	}
+	if err := s.ensureNotTransferred(c.Context(), chickin.ProjectFlockKandangId); err != nil {
+		return nil, err
+	}
+
 	updateBody := make(map[string]any)
 
 	if req.ChickInDate != "" {
@@ -353,7 +394,18 @@ func (s chickinService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
 		return nil, err
 	}
 
-	return s.GetOne(c, id)
+	updated, err := 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 {
@@ -366,29 +418,40 @@ func (s chickinService) DeleteOne(c *fiber.Ctx, id uint) error {
 		return err
 	}
 
+	if err := s.ensureNotTransferred(c.Context(), chickin.ProjectFlockKandangId); err != nil {
+		return err
+	}
+
 	actorID, err := m.ActorIDFromContext(c)
 	if err != nil {
 		return err
 	}
 
-	if chickin.UsageQty > 0 {
+	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
+		chickinRepoTx := repository.NewChickinRepository(tx)
 
-		currentUsageQty := chickin.UsageQty
+		if chickin.UsageQty > 0 || chickin.PendingUsageQty > 0 {
+			if err := s.ReleaseChickinStocks(c.Context(), tx, chickin, actorID); err != nil {
+				return err
+			}
+		}
 
-		if err := s.ReleaseChickinStocks(c.Context(), s.Repository.DB(), chickin, actorID); err != nil {
+		if err := chickinRepoTx.DeleteOne(c.Context(), id); err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return fiber.NewError(fiber.StatusNotFound, "Chickin not found")
+			}
 			return err
 		}
 
-		warehouseDeltas := make(map[uint]float64)
-		warehouseDeltas[chickin.ProductWarehouseId] += currentUsageQty
-		if err := s.adjustProductWarehouseQuantities(c.Context(), s.Repository.DB(), warehouseDeltas); err != nil {
+		if err := s.syncChickinTraceForProductWarehouse(c.Context(), tx, chickin.ProductWarehouseId); err != nil {
 			return err
 		}
-	}
 
-	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 nil
+	})
+	if err != nil {
+		if fiberErr, ok := err.(*fiber.Error); ok {
+			return fiberErr
 		}
 		return err
 	}
@@ -428,6 +491,9 @@ func (s chickinService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entit
 		if err := commonSvc.EnsureRelations(c.Context(), commonSvc.RelationCheck{Name: "ProjectFlockKandang", ID: &id, Exists: s.ProjectflockKandangRepo.IdExists}); err != nil {
 			return nil, err
 		}
+		if err := s.ensureNotTransferred(c.Context(), id); err != nil {
+			return nil, err
+		}
 		latestApproval, err := approvalSvc.LatestByTarget(c.Context(), utils.ApprovalWorkflowChickin, id, nil)
 
 		if err != nil {
@@ -451,8 +517,24 @@ 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 {
+			// Re-check latest approval inside transaction to prevent double-approve races.
+			var latest entity.Approval
+			if err := dbTransaction.WithContext(c.Context()).
+				Table("approvals").
+				Where("approvable_type = ? AND approvable_id = ?", utils.ApprovalWorkflowChickin.String(), approvableID).
+				Order("id DESC").
+				Limit(1).
+				Clauses(clause.Locking{Strength: "UPDATE"}).
+				Take(&latest).Error; err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+				return fiber.NewError(fiber.StatusInternalServerError, "Failed to recheck approval status")
+			}
+			if latest.Id != 0 && latest.StepNumber != uint16(utils.ChickinStepPengajuan) {
+				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("ProjectFlockKandang %d sudah tidak berada di tahap PENGAJUAN", approvableID))
+			}
+
 			if _, err := approvalSvc.CreateApproval(
 				c.Context(),
 				utils.ApprovalWorkflowChickin,
@@ -491,6 +573,21 @@ 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))
@@ -522,19 +619,13 @@ 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.GetPendingByProjectFlockKandangID(c.Context(), approvableID)
+				chickins, err := chickinRepoTx.GetByProjectFlockKandangID(c.Context(), approvableID)
 				if err != nil {
 					return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to get pending chickins for rejection %d", approvableID))
 				}
@@ -544,16 +635,22 @@ 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))
 					}
-
-					warehouseDeltas := make(map[uint]float64)
-					warehouseDeltas[chickin.ProductWarehouseId] += chickin.UsageQty
-					if err := s.adjustProductWarehouseQuantities(c.Context(), dbTransaction, warehouseDeltas); err != nil {
-						return err
-					}
+					touchedProductWarehouseIDs[chickin.ProductWarehouseId] = struct{}{}
 
 					if err := chickinRepoTx.DeleteOne(c.Context(), chickin.Id); err != nil {
 						if !errors.Is(err, gorm.ErrRecordNotFound) {
@@ -563,6 +660,13 @@ 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
 	})
 
@@ -617,121 +721,245 @@ 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 || s.FifoSvc == nil {
+	if chickin == nil {
 		return nil
 	}
-
-	result, err := s.FifoSvc.Consume(ctx, commonSvc.StockConsumeRequest{
-		UsableKey:          chickinUsableKey,
-		UsableID:           chickin.Id,
-		ProductWarehouseID: chickin.ProductWarehouseId,
-		Quantity:           desiredQty,
-		AllowPending:       true,
-		Tx:                 tx,
-	})
-	if err != nil {
-		return err
+	if tx == nil {
+		return errors.New("transaction is required")
+	}
+	if desiredQty < 0 {
+		return errors.New("desired quantity must be zero or greater")
 	}
 
-	if err := s.Repository.UpdateUsageFields(ctx, tx, chickin.Id, result.UsageQuantity, result.PendingQuantity); err != nil {
-		return err
+	return s.Repository.UpdateUsageFields(ctx, tx, chickin.Id, desiredQty, 0)
+}
+
+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")
 	}
 
-	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)
-	}
-
-	return nil
+	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 || s.FifoSvc == nil {
+	if chickin == nil || targetPW == nil || population == nil {
 		return nil
 	}
+	if tx == nil {
+		return errors.New("transaction is required")
+	}
+	if s.FifoStockV2Svc == nil {
+		return errors.New("fifo v2 service is not available")
+	}
 
-	_, err := s.FifoSvc.Replenish(ctx, commonSvc.StockReplenishRequest{
-		StockableKey:       fifo.StockableKeyProjectFlockPopulation,
-		StockableID:        population.Id,
-		ProductWarehouseID: targetPW.Id,
-		Quantity:           chickin.UsageQty,
-		Tx:                 tx,
-	})
-	if err != nil {
+	if err := tx.WithContext(ctx).
+		Model(&entity.ProjectFlockPopulation{}).
+		Where("id = ?", population.Id).
+		Update("total_qty", chickin.UsageQty).Error; err != nil {
 		return err
 	}
 
-	return nil
+	asOf := chickin.ChickInDate
+	if asOf.IsZero() {
+		asOf = chickin.CreatedAt
+	}
+	return reflowChickinScope(ctx, s.FifoStockV2Svc, tx, targetPW.Id, &asOf)
 }
 
 func (s *chickinService) ReleaseChickinStocks(ctx context.Context, tx *gorm.DB, chickin *entity.ProjectChickin, actorID uint) error {
-	if chickin == nil || s.FifoSvc == nil {
+	if chickin == nil {
 		return nil
 	}
-
-	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 tx == nil {
+		return errors.New("transaction is required")
 	}
 
 	if err := s.Repository.UpdateUsageFields(ctx, tx, chickin.Id, 0, 0); err != nil {
 		return err
 	}
 
-	if currentUsage > 0 {
-		increaseLog := &entity.StockLog{
-			Increase:           currentUsage,
-			LoggableType:       string(utils.StockLogTypeChikin),
-			LoggableId:         chickin.Id,
-			ProductWarehouseId: chickin.ProductWarehouseId,
-			CreatedBy:          actorID,
-			Notes:              fmt.Sprintf("Chickin #%d - Stock released", 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]
-			increaseLog.Stock = latestStockLog.Stock
-			increaseLog.Stock += increaseLog.Increase
-		} else {
-			increaseLog.Stock += increaseLog.Increase
+	return nil
+}
+
+func (s *chickinService) syncChickinTraceForProductWarehouse(ctx context.Context, tx *gorm.DB, productWarehouseID uint) error {
+	if productWarehouseID == 0 {
+		return nil
+	}
+	if s.FifoStockV2Svc == nil {
+		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
+	}
+	if strings.TrimSpace(flagGroupCode) == "" {
+		return nil
+	}
+
+	now := time.Now()
+	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",
+		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
 		}
 
-		s.StockLogRepo.CreateOne(ctx, increaseLog, nil)
+		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) {
+	type row struct {
+		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")
@@ -755,10 +983,3 @@ func (s chickinService) EnsureChickInExists(ctx context.Context, projectFlockKan
 
 	return fiber.NewError(fiber.StatusBadRequest, "Chick in project flock belum disetujui sehingga belum dapat membuat recording")
 }
-
-func (s *chickinService) adjustProductWarehouseQuantities(ctx context.Context, tx *gorm.DB, deltas map[uint]float64) error {
-	if len(deltas) == 0 {
-		return nil
-	}
-	return s.ProductWarehouseRepo.AdjustQuantities(ctx, deltas, func(*gorm.DB) *gorm.DB { return tx })
-}

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

@@ -0,0 +1,82 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"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"
+)
+
+func reflowChickinScope(
+	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 := resolveChickinFlagGroupByProductWarehouse(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 resolveChickinFlagGroupByProductWarehouse(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(`
+			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 strings.TrimSpace(selected.FlagGroupCode), nil
+}

internal/modules/production/recordings/module.go

@@ -2,7 +2,6 @@ package recordings
 
 import (
 	"fmt"
-	"strings"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
@@ -24,9 +23,9 @@ import (
 	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"
+	rTransferLaying "gitlab.com/mbugroup/lti-api.git/internal/modules/production/transfer_layings/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"
 
 	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
 	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
@@ -48,7 +47,7 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	productRepo := rProduct.NewProductRepository(db)
 	chickinRepo := rChickin.NewChickinRepository(db)
 	chickinDetailRepo := rChickin.NewChickinDetailRepository(db)
-	stockAllocationRepo := commonRepo.NewStockAllocationRepository(db)
+	transferLayingRepo := rTransferLaying.NewTransferLayingRepository(db)
 	stockLogRepo := rStockLogs.NewStockLogRepository(db)
 	productionStandardRepo := rProductionStandard.NewProductionStandardRepository(db)
 	productionStandardDetailRepo := rProductionStandard.NewProductionStandardDetailRepository(db)
@@ -61,76 +60,7 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		validate,
 	)
 
-	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:          "(SELECT r.record_datetime FROM recordings r WHERE r.id = recording_eggs.recording_id)",
-		},
-		OrderBy: []string{"(SELECT r.record_datetime FROM recordings r WHERE r.id = recording_eggs.recording_id) 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.RegisterStockable(fifo.StockableConfig{
-		Key:   fifo.StockableKeyRecordingDepletion,
-		Table: "recording_depletions",
-		Columns: fifo.StockableColumns{
-			ID:                 "id",
-			ProductWarehouseID: "product_warehouse_id",
-			TotalQuantity:      "qty",
-			TotalUsedQuantity:  "total_used_qty",
-			CreatedAt:          "(SELECT r.record_datetime FROM recordings r WHERE r.id = recording_depletions.recording_id)",
-		},
-		OrderBy: []string{"(SELECT r.record_datetime FROM recordings r WHERE r.id = recording_depletions.recording_id) ASC", "id ASC"},
-	}); err != nil {
-		if !strings.Contains(strings.ToLower(err.Error()), "already registered") {
-			panic(fmt.Sprintf("failed to register recording depletion 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:          "(SELECT r.record_datetime FROM recordings r WHERE r.id = recording_stocks.recording_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:      "usage_qty",
-			PendingQuantity:    "pending_qty",
-			CreatedAt:          "(SELECT r.record_datetime FROM recordings r WHERE r.id = recording_depletions.recording_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))
-		}
-	}
+	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
 
 	approvalRepo := commonRepo.NewApprovalRepository(db)
 	approvalService := commonSvc.NewApprovalService(approvalRepo)
@@ -168,8 +98,9 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		projectFlockKandangRepo,
 		projectFlockPopulationRepo,
 		chickinDetailRepo,
+		transferLayingRepo,
 		validate,
-		fifoService,
+		fifoStockV2Service,
 	)
 
 	recordingService := sRecording.NewRecordingService(
@@ -179,11 +110,12 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		projectFlockPopulationRepo,
 		approvalRepo,
 		approvalService,
-		fifoService,
+		fifoStockV2Service,
 		stockLogRepo,
 		productionStandardService,
 		projectFlockService,
 		chickinService,
+		transferLayingRepo,
 		validate,
 	)
 	userService := sUser.NewUserService(userRepo, validate)

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

@@ -25,20 +25,27 @@ type RecordingRepository interface {
 	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)
@@ -272,6 +279,18 @@ 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
@@ -279,10 +298,24 @@ 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 {
@@ -291,6 +324,18 @@ 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).
@@ -306,6 +351,16 @@ 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
@@ -325,6 +380,18 @@ 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
@@ -344,6 +411,12 @@ 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,
@@ -821,6 +894,7 @@ func (r *RecordingRepositoryImpl) ResyncProjectFlockPopulationUsage(ctx context.
 			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
@@ -831,14 +905,15 @@ func (r *RecordingRepositoryImpl) ResyncProjectFlockPopulationUsage(ctx context.
 		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.stockable_id = p.id
-		  )
-	`
+			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 {

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

@@ -0,0 +1,137 @@
+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/transfer_layings/controllers/transfer_laying.controller.go

@@ -186,6 +186,28 @@ func (u *TransferLayingController) Approval(c *fiber.Ctx) error {
 		})
 }
 
+func (u *TransferLayingController) Execute(c *fiber.Ctx) error {
+	param := c.Params("id")
+
+	id, err := strconv.Atoi(param)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid Id")
+	}
+
+	result, err := u.TransferLayingService.Execute(c, uint(id))
+	if err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).
+		JSON(response.Success{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Execute transfer laying successfully",
+			Data:    dto.ToTransferLayingDetailDTOWithSingleApproval(*result, result.LatestApproval),
+		})
+}
+
 func (u *TransferLayingController) GetAvailableQtyPerKandang(c *fiber.Ctx) error {
 	projectFlockID, err := strconv.ParseUint(c.Params("project_flock_id"), 10, 32)
 	if err != nil {

internal/modules/production/transfer_layings/dto/transfer_laying.dto.go

@@ -14,10 +14,12 @@ import (
 // === DTO Structs ===
 
 type TransferLayingRelationDTO struct {
-	Id             uint      `json:"id"`
-	TransferNumber string    `json:"transfer_number"`
-	TransferDate   time.Time `json:"transfer_date"`
-	Notes          string    `json:"notes"`
+	Id                uint       `json:"id"`
+	TransferNumber    string     `json:"transfer_number"`
+	TransferDate      time.Time  `json:"transfer_date"`
+	EffectiveMoveDate *time.Time `json:"effective_move_date,omitempty"`
+	ExecutedAt        *time.Time `json:"executed_at,omitempty"`
+	Notes             string     `json:"notes"`
 }
 
 type ProjectFlockKandangWithKandangDTO struct {
@@ -47,6 +49,8 @@ type TransferLayingListDTO struct {
 	ToProjectFlock   *projectFlockDTO.ProjectFlockRelationDTO `json:"to_project_flock,omitempty"`
 	CreatedBy        uint                                     `json:"created_by"`
 	CreatedUser      *userDTO.UserRelationDTO                 `json:"created_user,omitempty"`
+	ExecutedBy       *uint                                    `json:"executed_by,omitempty"`
+	ExecutedUser     *userDTO.UserRelationDTO                 `json:"executed_user,omitempty"`
 	CreatedAt        time.Time                                `json:"created_at"`
 	Approval         *approvalDTO.ApprovalRelationDTO         `json:"approval,omitempty"`
 }
@@ -88,10 +92,12 @@ type MaxTargetQtyForTransferDTO struct {
 
 func ToTransferLayingRelationDTO(e entity.LayingTransfer) TransferLayingRelationDTO {
 	return TransferLayingRelationDTO{
-		Id:             e.Id,
-		TransferNumber: e.TransferNumber,
-		TransferDate:   e.TransferDate,
-		Notes:          e.Notes,
+		Id:                e.Id,
+		TransferNumber:    e.TransferNumber,
+		TransferDate:      e.TransferDate,
+		EffectiveMoveDate: e.EffectiveMoveDate,
+		ExecutedAt:        e.ExecutedAt,
+		Notes:             e.Notes,
 	}
 }
 
@@ -190,6 +196,12 @@ func ToTransferLayingListDTO(e entity.LayingTransfer) TransferLayingListDTO {
 		createdUser = &mapped
 	}
 
+	var executedUser *userDTO.UserRelationDTO
+	if e.ExecutedUser != nil && e.ExecutedUser.Id != 0 {
+		mapped := userDTO.ToUserRelationDTO(*e.ExecutedUser)
+		executedUser = &mapped
+	}
+
 	var approval *approvalDTO.ApprovalRelationDTO
 	if e.LatestApproval != nil {
 		mapped := approvalDTO.ToApprovalDTO(*e.LatestApproval)
@@ -219,6 +231,8 @@ func ToTransferLayingListDTO(e entity.LayingTransfer) TransferLayingListDTO {
 		ToProjectFlock:            toProjectFlock,
 		CreatedBy:                 e.CreatedBy,
 		CreatedUser:               createdUser,
+		ExecutedBy:                e.ExecutedBy,
+		ExecutedUser:              executedUser,
 		CreatedAt:                 e.CreatedAt,
 		Approval:                  approval,
 	}

internal/modules/production/transfer_layings/module.go

@@ -10,11 +10,11 @@ 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"
 	rProjectFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
 	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"
@@ -37,6 +37,7 @@ func (TransferLayingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, val
 
 	stockAllocationRepo := commonRepo.NewStockAllocationRepository(db)
 	fifoService := commonSvc.NewFifoService(db, stockAllocationRepo, productWarehouseRepo, utils.Log)
+	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
 
 	// daftarin jadi stockable
 	if err := fifoService.RegisterStockable(fifo.StockableConfig{
@@ -91,6 +92,7 @@ func (TransferLayingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, val
 		warehouseRepo,
 		approvalService,
 		fifoService,
+		fifoStockV2Service,
 		validate,
 	)
 	userService := sUser.NewUserService(userRepo, validate)

internal/modules/production/transfer_layings/repositories/laying_transfer.repository.go

@@ -7,6 +7,7 @@ import (
 
 	"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 	"gorm.io/gorm"
 )
 
@@ -14,6 +15,8 @@ type TransferLayingRepository interface {
 	repository.BaseRepository[entity.LayingTransfer]
 	GetByTransferNumber(ctx context.Context, transferNumber string) (*entity.LayingTransfer, error)
 	IdExists(ctx context.Context, id uint) (bool, error)
+	GetLatestApprovedBySourceKandang(ctx context.Context, sourceProjectFlockKandangID uint) (*entity.LayingTransfer, error)
+	GetLatestApprovedByTargetKandang(ctx context.Context, targetProjectFlockKandangID uint) (*entity.LayingTransfer, error)
 
 	// Tambah method baru untuk query dengan filter lengkap
 	GetAllWithFilters(ctx context.Context, offset int, limit int, params *GetAllFilterParams) ([]entity.LayingTransfer, int64, error)
@@ -164,6 +167,7 @@ func (r *TransferLayingRepositoryImpl) GetAllWithFilters(ctx context.Context, of
 		Preload("FromProjectFlock").
 		Preload("ToProjectFlock").
 		Preload("CreatedUser").
+		Preload("ExecutedUser").
 		Preload("Sources").
 		Preload("Sources.SourceProjectFlockKandang").
 		Preload("Sources.SourceProjectFlockKandang.Kandang").
@@ -180,3 +184,57 @@ func (r *TransferLayingRepositoryImpl) GetAllWithFilters(ctx context.Context, of
 
 	return records, total, nil
 }
+
+func (r *TransferLayingRepositoryImpl) GetLatestApprovedBySourceKandang(ctx context.Context, sourceProjectFlockKandangID uint) (*entity.LayingTransfer, error) {
+	if sourceProjectFlockKandangID == 0 {
+		return nil, gorm.ErrRecordNotFound
+	}
+
+	var transfer entity.LayingTransfer
+	err := r.db.WithContext(ctx).
+		Model(&entity.LayingTransfer{}).
+		Joins("JOIN laying_transfer_sources lts ON lts.laying_transfer_id = laying_transfers.id AND lts.deleted_at IS NULL").
+		Where("lts.source_project_flock_kandang_id = ?", sourceProjectFlockKandangID).
+		Where("laying_transfers.deleted_at IS NULL").
+		Where(`(
+			SELECT a.action
+			FROM approvals a
+			WHERE a.approvable_type = ?
+			  AND a.approvable_id = laying_transfers.id
+			ORDER BY a.id DESC
+			LIMIT 1
+		) = ?`, string(utils.ApprovalWorkflowTransferToLaying), entity.ApprovalActionApproved).
+		Order("laying_transfers.id DESC").
+		First(&transfer).Error
+	if err != nil {
+		return nil, err
+	}
+	return &transfer, nil
+}
+
+func (r *TransferLayingRepositoryImpl) GetLatestApprovedByTargetKandang(ctx context.Context, targetProjectFlockKandangID uint) (*entity.LayingTransfer, error) {
+	if targetProjectFlockKandangID == 0 {
+		return nil, gorm.ErrRecordNotFound
+	}
+
+	var transfer entity.LayingTransfer
+	err := r.db.WithContext(ctx).
+		Model(&entity.LayingTransfer{}).
+		Joins("JOIN laying_transfer_targets ltt ON ltt.laying_transfer_id = laying_transfers.id AND ltt.deleted_at IS NULL").
+		Where("ltt.target_project_flock_kandang_id = ?", targetProjectFlockKandangID).
+		Where("laying_transfers.deleted_at IS NULL").
+		Where(`(
+			SELECT a.action
+			FROM approvals a
+			WHERE a.approvable_type = ?
+			  AND a.approvable_id = laying_transfers.id
+			ORDER BY a.id DESC
+			LIMIT 1
+		) = ?`, string(utils.ApprovalWorkflowTransferToLaying), entity.ApprovalActionApproved).
+		Order("laying_transfers.id DESC").
+		First(&transfer).Error
+	if err != nil {
+		return nil, err
+	}
+	return &transfer, nil
+}

internal/modules/production/transfer_layings/route.go

@@ -27,6 +27,7 @@ func TransferLayingRoutes(v1 fiber.Router, u user.UserService, s transferLaying.
 	route.Patch("/:id", m.RequirePermissions(m.P_TransferToLaying_UpdateOne), ctrl.UpdateOne)
 	route.Delete("/:id", m.RequirePermissions(m.P_TransferToLaying_DeleteOne), ctrl.DeleteOne)
 	route.Post("/approvals", m.RequirePermissions(m.P_TransferToLaying_Approval), ctrl.Approval)
+	route.Post("/:id/execute", m.RequirePermissions(m.P_TransferToLaying_Approval), ctrl.Execute)
 	route.Get("/project-flocks/:project_flock_id/available-qty", m.RequirePermissions(m.P_TransferToLaying_GetAvailableQty), ctrl.GetAvailableQtyPerKandang)
 	route.Get("/project-flocks/:project_flock_id/max-target-qty", m.RequirePermissions(m.P_TransferToLaying_CreateOne), ctrl.GetMaxTargetQtyPerKandang)
 }

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

@@ -0,0 +1,87 @@
+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

@@ -10,6 +10,8 @@ import (
 
 	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+	fifoV2 "gitlab.com/mbugroup/lti-api.git/internal/common/service/fifo_stock_v2"
+	"gitlab.com/mbugroup/lti-api.git/internal/config"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
 	rInventory "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
@@ -34,6 +36,7 @@ type TransferLayingService interface {
 	UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.LayingTransfer, error)
 	DeleteOne(ctx *fiber.Ctx, id uint) error
 	Approval(ctx *fiber.Ctx, req *validation.Approve) ([]entity.LayingTransfer, error)
+	Execute(ctx *fiber.Ctx, id uint) (*entity.LayingTransfer, error)
 	GetAvailableQtyPerKandang(ctx *fiber.Ctx, projectFlockID uint) (*entity.ProjectFlock, map[uint]float64, error)
 	GetMaxTargetQtyPerKandang(ctx *fiber.Ctx, projectFlockID uint) (map[uint]float64, error)
 }
@@ -52,8 +55,13 @@ type transferLayingService struct {
 	StockLogRepo               rStockLogs.StockLogRepository
 	ApprovalService            commonSvc.ApprovalService
 	FifoSvc                    commonSvc.FifoService
+	FifoStockV2Svc             commonSvc.FifoStockV2Service
 }
 
+const (
+	transferToLayingFlagGroupCode = "AYAM"
+)
+
 func NewTransferLayingService(
 	repo repository.TransferLayingRepository,
 	layingTransferSourceRepo repository.LayingTransferSourceRepository,
@@ -65,6 +73,7 @@ func NewTransferLayingService(
 	warehouseRepo rWarehouse.WarehouseRepository,
 	approvalService commonSvc.ApprovalService,
 	fifoSvc commonSvc.FifoService,
+	fifoStockV2Svc commonSvc.FifoStockV2Service,
 	validate *validator.Validate,
 ) TransferLayingService {
 	return &transferLayingService{
@@ -81,12 +90,14 @@ func NewTransferLayingService(
 		StockLogRepo:               rStockLogs.NewStockLogRepository(repo.DB()),
 		ApprovalService:            approvalService,
 		FifoSvc:                    fifoSvc,
+		FifoStockV2Svc:             fifoStockV2Svc,
 	}
 }
 
 func (s transferLayingService) withRelations(db *gorm.DB) *gorm.DB {
 	return db.
 		Preload("CreatedUser").
+		Preload("ExecutedUser").
 		Preload("FromProjectFlock").
 		Preload("ToProjectFlock").
 		Preload("Sources").
@@ -744,13 +755,10 @@ 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)
 
 		for _, approvableID := range approvableIDs {
-			transfer, err := repoTx.GetByID(c.Context(), approvableID, nil)
+			_, err := repoTx.GetByID(c.Context(), approvableID, nil)
 			if err != nil {
 				if errors.Is(err, gorm.ErrRecordNotFound) {
 					return fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("TransferLaying %d not found", approvableID))
@@ -771,148 +779,21 @@ func (s transferLayingService) Approval(c *fiber.Ctx, req *validation.Approve) (
 			}
 
 			if action == entity.ApprovalActionApproved {
-
 				sources, err := sourceRepoTx.GetByLayingTransferId(c.Context(), approvableID)
 				if err != nil {
 					return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil sources transfer")
 				}
-
-				targets, err := targetRepoTx.GetByLayingTransferId(c.Context(), approvableID)
+				effectiveMoveDate, err := s.calculateEffectiveMoveDate(c.Context(), sources)
 				if err != nil {
-					return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil targets transfer")
+					return err
 				}
 
-				totalTargetQty := 0.0
-				for _, target := range targets {
-					totalTargetQty += target.TotalQty
-				}
-
-				totalSourceRequested := 0.0
-				for _, source := range sources {
-					totalSourceRequested += source.RequestedQty
-				}
-
-				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 := (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))
-					}
-
-					if err := sourceRepoTx.PatchOne(c.Context(), source.Id, map[string]interface{}{
-						"usage_qty":         source.UsageQty + consumeResult.UsageQuantity,
-						"pending_usage_qty": consumeResult.PendingQuantity,
-					}, nil); err != nil {
-						return fiber.NewError(fiber.StatusInternalServerError, "Gagal update source usage qty")
-					}
-
-					targetShares := distributeProportionalWithRounding(targets, totalTargetQty, sourceShare)
-
-					for i, target := range targets {
-						roundedQty := math.Round(targetShares[i])
-						if roundedQty <= 0 {
-							continue
-						}
-						mappingAllocation := &entity.StockAllocation{
-							StockableType:      fifo.UsableKeyTransferToLayingOut.String(),
-							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")
-						}
-					}
-
-					stockLogDecrease := &entity.StockLog{
-						ProductWarehouseId: *source.ProductWarehouseId,
-						CreatedBy:          actorID,
-						Increase:           0,
-						Decrease:           sourceShare,
-						LoggableType:       string(utils.StockLogTypeTransferLaying),
-						LoggableId:         approvableID,
-						Notes:              fmt.Sprintf("TL #%s", transfer.TransferNumber),
-					}
-					stockLogs, err := stockLogRepoTx.GetByProductWarehouse(c.Context(), *source.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")
-					}
-					if len(stockLogs) > 0 {
-						latestStockLog := stockLogs[0]
-						stockLogDecrease.Stock = latestStockLog.Stock - stockLogDecrease.Decrease
-					} else {
-						stockLogDecrease.Stock -= stockLogDecrease.Decrease
-					}
-
-					if err := stockLogRepoTx.CreateOne(c.Context(), stockLogDecrease, nil); err != nil {
-						return fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok keluar")
-					}
-				}
-
-				for _, target := range targets {
-					if target.ProductWarehouseId == nil {
-						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{
-						ProductWarehouseId: *target.ProductWarehouseId,
-						CreatedBy:          actorID,
-						Increase:           target.TotalQty,
-						Decrease:           0,
-						LoggableType:       string(utils.StockLogTypeTransferLaying),
-						LoggableId:         approvableID,
-						Notes:              fmt.Sprintf("TL #%s", transfer.TransferNumber),
-					}
-					stockLogs, err := stockLogRepoTx.GetByProductWarehouse(c.Context(), *target.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")
-					}
-					if len(stockLogs) > 0 {
-						latestStockLog := stockLogs[0]
-						stockLogIncrease.Stock = latestStockLog.Stock + stockLogIncrease.Increase
-					} else {
-						stockLogIncrease.Stock += stockLogIncrease.Increase
-					}
-
-					if err := stockLogRepoTx.CreateOne(c.Context(), stockLogIncrease, nil); err != nil {
-						return fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok masuk")
-					}
+				if err := repoTx.PatchOne(c.Context(), approvableID, map[string]any{
+					"effective_move_date": effectiveMoveDate,
+					"executed_at":         nil,
+					"executed_by":         nil,
+				}, nil); err != nil {
+					return fiber.NewError(fiber.StatusInternalServerError, "Gagal menyimpan tanggal efektif transfer laying")
 				}
 			}
 		}
@@ -939,6 +820,393 @@ func (s transferLayingService) Approval(c *fiber.Ctx, req *validation.Approve) (
 	return updated, nil
 }
 
+func (s transferLayingService) Execute(c *fiber.Ctx, id uint) (*entity.LayingTransfer, error) {
+	if err := m.EnsureLayingTransferAccess(c, s.Repository.DB(), id); err != nil {
+		return nil, err
+	}
+
+	actorID, err := m.ActorIDFromContext(c)
+	if err != nil {
+		return nil, err
+	}
+
+	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
+		repoTx := s.Repository.WithTx(dbTransaction)
+		sourceRepoTx := repository.NewLayingTransferSourceRepository(dbTransaction)
+		targetRepoTx := repository.NewLayingTransferTargetRepository(dbTransaction)
+		approvalRepoTx := commonRepo.NewApprovalRepository(dbTransaction)
+
+		transfer, err := repoTx.GetByID(c.Context(), id, nil)
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return fiber.NewError(fiber.StatusNotFound, "Transfer laying tidak ditemukan")
+			}
+			return err
+		}
+
+		if transfer.ExecutedAt != nil {
+			return nil
+		}
+
+		latestApproval, err := approvalRepoTx.LatestByTarget(c.Context(), string(utils.ApprovalWorkflowTransferToLaying), transfer.Id, nil)
+		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+			return err
+		}
+		if latestApproval == nil || latestApproval.Action == nil || *latestApproval.Action != entity.ApprovalActionApproved {
+			return fiber.NewError(fiber.StatusBadRequest, "Transfer laying harus disetujui sebelum dieksekusi")
+		}
+
+		sources, err := sourceRepoTx.GetByLayingTransferId(c.Context(), transfer.Id)
+		if err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil sumber transfer laying")
+		}
+
+		targets, err := targetRepoTx.GetByLayingTransferId(c.Context(), transfer.Id)
+		if err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil target transfer laying")
+		}
+
+		if transfer.EffectiveMoveDate == nil || transfer.EffectiveMoveDate.IsZero() {
+			effectiveMoveDate, calcErr := s.calculateEffectiveMoveDate(c.Context(), sources)
+			if calcErr != nil {
+				return calcErr
+			}
+			if patchErr := repoTx.PatchOne(c.Context(), transfer.Id, map[string]any{
+				"effective_move_date": effectiveMoveDate,
+			}, nil); patchErr != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Gagal menyimpan tanggal efektif transfer laying")
+			}
+			transfer.EffectiveMoveDate = &effectiveMoveDate
+		}
+
+		effectiveMoveDate := normalizeDateOnlyUTC(*transfer.EffectiveMoveDate)
+		today := normalizeDateOnlyUTC(time.Now().UTC())
+		if today.Before(effectiveMoveDate) {
+			return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Transfer laying baru bisa dieksekusi mulai tanggal %s", effectiveMoveDate.Format("2006-01-02")))
+		}
+
+		if err := s.executeApprovedTransferMovement(c.Context(), dbTransaction, transfer, actorID, sources, targets); err != nil {
+			return err
+		}
+
+		executedAt := time.Now().UTC()
+		if err := repoTx.PatchOne(c.Context(), transfer.Id, map[string]any{
+			"executed_at": executedAt,
+			"executed_by": actorID,
+		}, nil); err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal menyimpan status eksekusi transfer laying")
+		}
+
+		return nil
+	})
+	if err != nil {
+		if fiberErr, ok := err.(*fiber.Error); ok {
+			return nil, fiberErr
+		}
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengeksekusi transfer laying")
+	}
+
+	transfer, _, err := s.GetOne(c, id)
+	if err != nil {
+		return nil, err
+	}
+	return transfer, nil
+}
+
+func (s *transferLayingService) executeApprovedTransferMovement(
+	ctx context.Context,
+	tx *gorm.DB,
+	transfer *entity.LayingTransfer,
+	actorID uint,
+	sources []entity.LayingTransferSource,
+	targets []entity.LayingTransferTarget,
+) error {
+	if transfer == nil || transfer.Id == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Transfer laying tidak valid")
+	}
+	if len(sources) == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Transfer laying belum memiliki sumber")
+	}
+	if len(targets) == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Transfer laying belum memiliki target")
+	}
+	if s.FifoStockV2Svc == nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "FIFO v2 service is not available")
+	}
+	if s.FifoSvc == nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "FIFO service is not available")
+	}
+
+	stockAllocationRepo := commonRepo.NewStockAllocationRepository(tx)
+	sourceRepoTx := repository.NewLayingTransferSourceRepository(tx)
+	targetRepoTx := repository.NewLayingTransferTargetRepository(tx)
+	stockLogRepoTx := rStockLogs.NewStockLogRepository(tx)
+
+	totalTargetQty := 0.0
+	for _, target := range targets {
+		totalTargetQty += target.TotalQty
+	}
+	if totalTargetQty <= 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Total kuantitas target transfer laying harus lebih dari 0")
+	}
+
+	totalSourceRequested := 0.0
+	for _, source := range sources {
+		totalSourceRequested += source.RequestedQty
+	}
+	if totalSourceRequested <= 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Total kuantitas sumber transfer laying harus lebih dari 0")
+	}
+
+	for _, source := range sources {
+		if source.ProductWarehouseId == nil {
+			return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Source product warehouse tidak ditemukan untuk transfer %d", transfer.Id))
+		}
+		if source.RequestedQty <= 0 {
+			continue
+		}
+
+		sourceShare := (source.RequestedQty / totalSourceRequested) * totalTargetQty
+		if sourceShare <= 0 {
+			continue
+		}
+
+		if err := sourceRepoTx.PatchOne(ctx, source.Id, map[string]any{
+			"usage_qty":         source.UsageQty + sourceShare,
+			"pending_usage_qty": 0,
+		}, nil); err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal update source usage qty")
+		}
+
+		asOf := transfer.TransferDate
+		if transfer.EffectiveMoveDate != nil && !transfer.EffectiveMoveDate.IsZero() {
+			asOf = *transfer.EffectiveMoveDate
+		}
+		if _, err := s.FifoStockV2Svc.Reflow(ctx, commonSvc.FifoStockV2ReflowRequest{
+			FlagGroupCode:      transferToLayingFlagGroupCode,
+			ProductWarehouseID: *source.ProductWarehouseId,
+			AsOf:               &asOf,
+			Tx:                 tx,
+		}); err != nil {
+			return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Gagal consume FIFO v2 stock: %v", err))
+		}
+
+		refreshedSource, err := sourceRepoTx.GetByID(ctx, source.Id, nil)
+		if err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal refresh source transfer setelah reflow")
+		}
+
+		usageDelta := refreshedSource.UsageQty - source.UsageQty
+		pendingQty := refreshedSource.PendingUsageQty
+		if pendingQty > 1e-6 || usageDelta < sourceShare-1e-6 {
+			return fiber.NewError(
+				fiber.StatusBadRequest,
+				fmt.Sprintf("Stok sumber tidak mencukupi untuk mengeksekusi transfer laying %s", transfer.TransferNumber),
+			)
+		}
+
+		movedQty := usageDelta
+		if err := s.allocatePopulationForTransfer(ctx, tx, source, movedQty); err != nil {
+			return err
+		}
+		targetShares := distributeProportionalWithRounding(targets, totalTargetQty, movedQty)
+		for i, target := range targets {
+			roundedQty := math.Round(targetShares[i])
+			if roundedQty <= 0 {
+				continue
+			}
+			mappingAllocation := &entity.StockAllocation{
+				StockableType:      fifo.UsableKeyTransferToLayingOut.String(),
+				StockableId:        source.Id,
+				UsableType:         fifo.StockableKeyTransferToLayingIn.String(),
+				UsableId:           target.Id,
+				ProductWarehouseId: *source.ProductWarehouseId,
+				Qty:                roundedQty,
+				Status:             entity.StockAllocationStatusActive,
+			}
+			if err := stockAllocationRepo.CreateOne(ctx, mappingAllocation, nil); err != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Gagal create mapping allocation source→target")
+			}
+		}
+
+		stockLogDecrease := &entity.StockLog{
+			ProductWarehouseId: *source.ProductWarehouseId,
+			CreatedBy:          actorID,
+			Increase:           0,
+			Decrease:           movedQty,
+			LoggableType:       string(utils.StockLogTypeTransferLaying),
+			LoggableId:         transfer.Id,
+			Notes:              fmt.Sprintf("TL #%s", transfer.TransferNumber),
+		}
+		stockLogs, err := stockLogRepoTx.GetByProductWarehouse(ctx, *source.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")
+		}
+		if len(stockLogs) > 0 {
+			latestStockLog := stockLogs[0]
+			stockLogDecrease.Stock = latestStockLog.Stock - stockLogDecrease.Decrease
+		} else {
+			stockLogDecrease.Stock -= stockLogDecrease.Decrease
+		}
+
+		if err := stockLogRepoTx.CreateOne(ctx, stockLogDecrease, nil); err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok keluar")
+		}
+	}
+
+	for _, target := range targets {
+		if target.ProductWarehouseId == nil {
+			return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Target product warehouse tidak ditemukan untuk transfer %d", transfer.Id))
+		}
+
+		note := fmt.Sprintf("Transfer to Laying #%s", transfer.TransferNumber)
+		_, err := s.FifoSvc.Replenish(ctx, commonSvc.StockReplenishRequest{
+			StockableKey:       fifo.StockableKeyTransferToLayingIn,
+			StockableID:        target.Id,
+			ProductWarehouseID: *target.ProductWarehouseId,
+			Quantity:           target.TotalQty,
+			Note:               &note,
+			Tx:                 tx,
+		})
+		if err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Gagal replenish stock ke target warehouse: %v", err))
+		}
+
+		if err := targetRepoTx.PatchOne(ctx, target.Id, map[string]any{
+			"total_qty": target.TotalQty,
+		}, nil); err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal update target total qty")
+		}
+
+		stockLogIncrease := &entity.StockLog{
+			ProductWarehouseId: *target.ProductWarehouseId,
+			CreatedBy:          actorID,
+			Increase:           target.TotalQty,
+			Decrease:           0,
+			LoggableType:       string(utils.StockLogTypeTransferLaying),
+			LoggableId:         transfer.Id,
+			Notes:              fmt.Sprintf("TL #%s", transfer.TransferNumber),
+		}
+		stockLogs, err := stockLogRepoTx.GetByProductWarehouse(ctx, *target.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")
+		}
+		if len(stockLogs) > 0 {
+			latestStockLog := stockLogs[0]
+			stockLogIncrease.Stock = latestStockLog.Stock + stockLogIncrease.Increase
+		} else {
+			stockLogIncrease.Stock += stockLogIncrease.Increase
+		}
+
+		if err := stockLogRepoTx.CreateOne(ctx, stockLogIncrease, nil); err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat log stok masuk")
+		}
+	}
+
+	return nil
+}
+
+func (s *transferLayingService) allocatePopulationForTransfer(
+	ctx context.Context,
+	tx *gorm.DB,
+	source entity.LayingTransferSource,
+	consumeQty float64,
+) error {
+	if consumeQty <= 0 {
+		return nil
+	}
+	if tx == nil {
+		return errors.New("transaction is required")
+	}
+	if source.SourceProjectFlockKandangId == 0 || source.ProductWarehouseId == nil || *source.ProductWarehouseId == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Project flock kandang sumber atau product warehouse tidak valid")
+	}
+
+	populations, err := s.ProjectFlockPopulationRepo.GetByProjectFlockKandangIDAndProductWarehouseID(
+		ctx,
+		source.SourceProjectFlockKandangId,
+		*source.ProductWarehouseId,
+	)
+	if err != nil {
+		return err
+	}
+	if len(populations) == 0 {
+		return fiber.NewError(fiber.StatusBadRequest, "Populasi tidak ditemukan untuk transfer laying")
+	}
+
+	return fifoV2.AllocatePopulationConsumption(
+		ctx,
+		tx,
+		populations,
+		*source.ProductWarehouseId,
+		fifo.UsableKeyTransferToLayingOut.String(),
+		source.Id,
+		consumeQty,
+	)
+}
+
+func (s *transferLayingService) calculateEffectiveMoveDate(ctx context.Context, sources []entity.LayingTransferSource) (time.Time, error) {
+	if len(sources) == 0 {
+		return time.Time{}, fiber.NewError(fiber.StatusBadRequest, "Sumber transfer laying tidak ditemukan")
+	}
+
+	maxGrowingWeek := config.TransferToLayingGrowingMaxWeek
+	if maxGrowingWeek <= 0 {
+		maxGrowingWeek = 19
+	}
+
+	var baselineChickInDate time.Time
+	for _, source := range sources {
+		chickInDate, err := s.resolveSourceChickInDate(ctx, source.SourceProjectFlockKandangId)
+		if err != nil {
+			return time.Time{}, err
+		}
+		if baselineChickInDate.IsZero() || chickInDate.Before(baselineChickInDate) {
+			baselineChickInDate = chickInDate
+		}
+	}
+
+	if baselineChickInDate.IsZero() {
+		return time.Time{}, fiber.NewError(fiber.StatusBadRequest, "Tanggal chick in sumber transfer laying tidak ditemukan")
+	}
+
+	effectiveMoveDate := baselineChickInDate.AddDate(0, 0, maxGrowingWeek*7)
+	return normalizeDateOnlyUTC(effectiveMoveDate), nil
+}
+
+func (s *transferLayingService) resolveSourceChickInDate(ctx context.Context, sourceProjectFlockKandangID uint) (time.Time, error) {
+	if sourceProjectFlockKandangID == 0 {
+		return time.Time{}, fiber.NewError(fiber.StatusBadRequest, "Project flock kandang sumber tidak valid")
+	}
+
+	populations, err := s.ProjectFlockPopulationRepo.GetByProjectFlockKandangID(ctx, sourceProjectFlockKandangID)
+	if err != nil {
+		return time.Time{}, err
+	}
+
+	var earliestChickInDate time.Time
+	for _, population := range populations {
+		if population.ProjectChickin == nil || population.ProjectChickin.ChickInDate.IsZero() {
+			continue
+		}
+		chickInDate := normalizeDateOnlyUTC(population.ProjectChickin.ChickInDate)
+		if earliestChickInDate.IsZero() || chickInDate.Before(earliestChickInDate) {
+			earliestChickInDate = chickInDate
+		}
+	}
+
+	if earliestChickInDate.IsZero() {
+		return time.Time{}, fiber.NewError(
+			fiber.StatusBadRequest,
+			fmt.Sprintf("Tanggal chick in untuk kandang sumber %d tidak ditemukan", sourceProjectFlockKandangID),
+		)
+	}
+
+	return earliestChickInDate, nil
+}
+
 func createApprovalTransferLaying(ctx context.Context, tx *gorm.DB, transferLayingID uint, actorID uint) error {
 	if transferLayingID == 0 || actorID == 0 {
 		return nil
@@ -1053,6 +1321,10 @@ func (s transferLayingService) GetMaxTargetQtyPerKandang(c *fiber.Ctx, projectFl
 	return kandangMaxTargetQty, nil
 }
 
+func normalizeDateOnlyUTC(value time.Time) time.Time {
+	return time.Date(value.UTC().Year(), value.UTC().Month(), value.UTC().Day(), 0, 0, 0, 0, time.UTC)
+}
+
 func distributeProportionalWithRounding(targets []entity.LayingTransferTarget, totalTargetQty, sourceShare float64) []float64 {
 	if len(targets) == 0 {
 		return []float64{}

internal/modules/purchases/module.go

@@ -23,7 +23,6 @@ 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"
 )
 
@@ -40,7 +39,6 @@ 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)
@@ -73,19 +71,7 @@ func (PurchaseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		expenseServiceInstance,
 	)
 
-	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"},
-	})
+	fifoStockV2Service := commonSvc.NewFifoStockV2Service(db, utils.Log)
 
 	purchaseService := service.NewPurchaseService(
 		validate,
@@ -97,7 +83,7 @@ func (PurchaseModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		projectFlockKandangRepository,
 		approvalService,
 		expenseBridge,
-		fifoService,
+		fifoStockV2Service,
 		documentSvc,
 	)
 

internal/modules/purchases/services/fifo_stock_v2_helper.go

@@ -0,0 +1,93 @@
+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
-	FifoSvc                 commonSvc.FifoService
+	FifoStockV2Svc          commonSvc.FifoStockV2Service
 	DocumentSvc             commonSvc.DocumentService
 	approvalWorkflow        approvalutils.ApprovalWorkflowKey
 }
@@ -77,7 +77,7 @@ func NewPurchaseService(
 	projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository,
 	approvalSvc commonSvc.ApprovalService,
 	expenseBridge PurchaseExpenseBridge,
-	fifoSvc commonSvc.FifoService,
+	fifoStockV2Svc commonSvc.FifoStockV2Service,
 	documentSvc commonSvc.DocumentService,
 ) PurchaseService {
 	return &purchaseService{
@@ -91,7 +91,7 @@ func NewPurchaseService(
 		ProjectFlockKandangRepo: projectFlockKandangRepo,
 		ApprovalSvc:             approvalSvc,
 		ExpenseBridge:           expenseBridge,
-		FifoSvc:                 fifoSvc,
+		FifoStockV2Svc:          fifoStockV2Svc,
 		DocumentSvc:             documentSvc,
 		approvalWorkflow:        utils.ApprovalWorkflowPurchase,
 	}
@@ -256,35 +256,13 @@ func (s *purchaseService) GetOne(c *fiber.Ctx, id uint) (*entity.Purchase, error
 		s.Log.Warnf("Unable to attach latest approval for purchase %d: %+v", id, err)
 	}
 	if len(purchase.Items) > 0 {
-		itemIDs := make([]uint, 0, len(purchase.Items))
-		for i := range purchase.Items {
-			if purchase.Items[i].Id == 0 {
-				continue
-			}
-			itemIDs = append(itemIDs, purchase.Items[i].Id)
+		lockedIDs, err := s.resolveChickinLockedItemIDs(c.Context(), s.PurchaseRepo.DB(), purchase.Items)
+		if err != nil {
+			return nil, err
 		}
-		if len(itemIDs) > 0 {
-			var usedIDs []uint
-			if err := s.PurchaseRepo.DB().WithContext(c.Context()).
-				Model(&entity.StockAllocation{}).
-				Distinct("stockable_id").
-				Where("stockable_type = ? AND stockable_id IN ? AND usable_type = ? AND status IN ?",
-					fifo.StockableKeyPurchaseItems.String(),
-					itemIDs,
-					fifo.UsableKeyProjectChickin.String(),
-					[]string{entity.StockAllocationStatusActive, entity.StockAllocationStatusPending},
-				).
-				Pluck("stockable_id", &usedIDs).Error; err != nil {
-				return nil, err
-			}
-			usedSet := make(map[uint]struct{}, len(usedIDs))
-			for _, id := range usedIDs {
-				usedSet[id] = struct{}{}
-			}
-			for i := range purchase.Items {
-				if _, ok := usedSet[purchase.Items[i].Id]; ok {
-					purchase.Items[i].HasChickin = true
-				}
+		for i := range purchase.Items {
+			if _, ok := lockedIDs[purchase.Items[i].Id]; ok {
+				purchase.Items[i].HasChickin = true
 			}
 		}
 	}
@@ -532,48 +510,31 @@ func (s *purchaseService) ApproveStaffPurchase(c *fiber.Ctx, id uint, req *valid
 	}
 
 	if action == entity.ApprovalActionApproved {
-		itemIDs := make([]uint, 0, len(purchase.Items))
 		itemByID := make(map[uint]entity.PurchaseItem, len(purchase.Items))
 		for i := range purchase.Items {
 			if purchase.Items[i].Id == 0 {
 				continue
 			}
-			itemIDs = append(itemIDs, purchase.Items[i].Id)
 			itemByID[purchase.Items[i].Id] = purchase.Items[i]
 		}
-		if len(itemIDs) > 0 {
-			var usedIDs []uint
-			if err := s.PurchaseRepo.DB().WithContext(ctx).
-				Model(&entity.StockAllocation{}).
-				Distinct("stockable_id").
-				Where("stockable_type = ? AND stockable_id IN ? AND usable_type = ? AND status IN ?",
-					fifo.StockableKeyPurchaseItems.String(),
-					itemIDs,
-					fifo.UsableKeyProjectChickin.String(),
-					[]string{entity.StockAllocationStatusActive, entity.StockAllocationStatusPending},
-				).
-				Pluck("stockable_id", &usedIDs).Error; err != nil {
-				return nil, err
-			}
-			if len(usedIDs) > 0 {
-				usedSet := make(map[uint]struct{}, len(usedIDs))
-				for _, id := range usedIDs {
-					usedSet[id] = struct{}{}
+		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
 				}
-				for _, payload := range req.Items {
-					if payload.PurchaseItemID == 0 || payload.Qty == nil {
-						continue
-					}
-					if _, used := usedSet[payload.PurchaseItemID]; !used {
-						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")
-					}
+				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")
 				}
 			}
 		}
@@ -826,50 +787,37 @@ func (s *purchaseService) ReceiveProducts(c *fiber.Ctx, id uint, req *validation
 			req.Items[idx].TravelDocumentPath = &uploadedURL
 		}
 	}
+	lockedIDs := map[uint]struct{}{}
 	if action == entity.ApprovalActionApproved {
-		itemIDs := make([]uint, 0, len(purchase.Items))
 		itemByID := make(map[uint]entity.PurchaseItem, len(purchase.Items))
 		for i := range purchase.Items {
 			if purchase.Items[i].Id == 0 {
 				continue
 			}
-			itemIDs = append(itemIDs, purchase.Items[i].Id)
 			itemByID[purchase.Items[i].Id] = purchase.Items[i]
 		}
-		if len(itemIDs) > 0 {
-			var usedIDs []uint
-			if err := s.PurchaseRepo.DB().WithContext(ctx).
-				Model(&entity.StockAllocation{}).
-				Distinct("stockable_id").
-				Where("stockable_type = ? AND stockable_id IN ? AND usable_type = ? AND status IN ?",
-					fifo.StockableKeyPurchaseItems.String(),
-					itemIDs,
-					fifo.UsableKeyProjectChickin.String(),
-					[]string{entity.StockAllocationStatusActive, entity.StockAllocationStatusPending},
-				).
-				Pluck("stockable_id", &usedIDs).Error; err != nil {
-				return nil, err
+		locked, err := s.resolveChickinLockedItemIDs(ctx, s.PurchaseRepo.DB(), purchase.Items)
+		if err != nil {
+			return nil, err
+		}
+		if len(locked) > 0 {
+			for id := range locked {
+				lockedIDs[id] = struct{}{}
 			}
-			if len(usedIDs) > 0 {
-				usedSet := make(map[uint]struct{}, len(usedIDs))
-				for _, id := range usedIDs {
-					usedSet[id] = struct{}{}
+			for _, payload := range req.Items {
+				if _, used := lockedIDs[payload.PurchaseItemID]; !used {
+					continue
 				}
-				for _, payload := range req.Items {
-					if _, used := usedSet[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")
-					}
+				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")
 				}
 			}
 		}
@@ -936,7 +884,7 @@ func (s *purchaseService) ReceiveProducts(c *fiber.Ctx, id uint, req *validation
 		if receivedQty > item.SubQty {
 			return nil, utils.BadRequest(fmt.Sprintf("Received quantity for item %d cannot exceed ordered quantity (%.3f)", payload.PurchaseItemID, item.SubQty))
 		}
-		if receivedQty < item.TotalUsed {
+		if receivedQty < item.TotalUsed && isReceivingBelowUsedBlocked(item, lockedIDs) {
 			return nil, utils.BadRequest(fmt.Sprintf("Received quantity for item %d cannot be lower than used amount (%.3f)", payload.PurchaseItemID, item.TotalUsed))
 		}
 
@@ -1026,22 +974,11 @@ 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)
-		fifoAdds := make([]struct {
-			itemID uint
-			pwID   uint
-			qty    float64
-		}, 0, len(prepared))
-		fifoSubs := make([]struct {
-			itemID uint
-			pwID   uint
-			qty    float64
-		}, 0, len(prepared))
-		resolvePendingIDs := make(map[uint]struct{})
+		reflowAsOfByPW := make(map[uint]time.Time)
 		logEntries := make([]struct {
 			itemID uint
 			pwID   uint
@@ -1083,35 +1020,14 @@ func (s *purchaseService) ReceiveProducts(c *fiber.Ctx, id uint, req *validation
 					delta  float64
 				}{itemID: item.Id, pwID: *newPWID, delta: deltaQty})
 			}
-			switch {
-			case deltaQty > 0 && newPWID != nil:
-				if s.FifoSvc != nil {
-					fifoAdds = append(fifoAdds, struct {
-						itemID uint
-						pwID   uint
-						qty    float64
-					}{itemID: item.Id, pwID: *newPWID, qty: deltaQty})
-					resolvePendingIDs[*newPWID] = struct{}{}
-				} else {
-					deltas[*newPWID] += deltaQty
-					totalQtyDeltas[item.Id] += deltaQty
-				}
-			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{}{}
-					resolvePendingIDs[*newPWID] = struct{}{}
-				} else {
-					deltas[*newPWID] += deltaQty // negative
-					affected[*newPWID] = struct{}{}
-					totalQtyDeltas[item.Id] += deltaQty
-				}
-			case newPWID != nil:
-				resolvePendingIDs[*newPWID] = struct{}{}
+			if newPWID != nil {
+				assignEarliestAsOf(reflowAsOfByPW, *newPWID, prep.receivedDate.UTC())
+			}
+			if deltaQty != 0 {
+				totalQtyDeltas[item.Id] += deltaQty
+			}
+			if deltaQty < 0 && newPWID != nil {
+				affected[*newPWID] = struct{}{}
 			}
 
 			dateCopy := prep.receivedDate
@@ -1147,10 +1063,6 @@ 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
@@ -1180,48 +1092,16 @@ func (s *purchaseService) ReceiveProducts(c *fiber.Ctx, id uint, req *validation
 			}
 		}
 
-		if s.FifoSvc != nil {
-			for _, adj := range fifoAdds {
-				if adj.pwID == 0 || adj.qty <= 0 {
-					continue
-				}
-				if _, err := s.FifoSvc.Replenish(c.Context(), commonSvc.StockReplenishRequest{
-					StockableKey:       fifo.StockableKeyPurchaseItems,
-					StockableID:        adj.itemID,
-					ProductWarehouseID: adj.pwID,
-					Quantity:           adj.qty,
-					Tx:                 tx,
-				}); err != nil {
-					return err
-				}
+		if len(reflowAsOfByPW) > 0 {
+			if s.FifoStockV2Svc == nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "FIFO v2 service is not available")
 			}
-			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 {
+			for pwID, asOf := range reflowAsOfByPW {
+				asOfCopy := asOf
+				if err := reflowPurchaseScope(c.Context(), s.FifoStockV2Svc, tx, pwID, &asOfCopy); err != nil {
 					return err
 				}
 			}
-			for pwID := range resolvePendingIDs {
-				if pwID == 0 {
-					continue
-				}
-				resolved, err := s.FifoSvc.ResolvePending(c.Context(), commonSvc.PendingResolveRequest{
-					ProductWarehouseID: pwID,
-					Tx:                 tx,
-				})
-				if err != nil {
-					return err
-				}
-				s.Log.Infof("ResolvePending purchase=%d pw=%d resolved=%d", purchase.Id, pwID, len(resolved))
-			}
 		}
 
 		if len(logEntries) > 0 {
@@ -1505,28 +1385,12 @@ func (s *purchaseService) DeletePurchase(c *fiber.Ctx, id uint) error {
 	}
 
 	transactionErr := s.PurchaseRepo.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		itemIDs := make([]uint, 0, len(itemsToDelete))
-		for _, item := range itemsToDelete {
-			if item.Id == 0 {
-				continue
-			}
-			itemIDs = append(itemIDs, item.Id)
+		lockedIDs, err := s.resolveChickinLockedItemIDs(ctx, tx, itemsToDelete)
+		if err != nil {
+			return err
 		}
-		if len(itemIDs) > 0 {
-			var count int64
-			if err := tx.Model(&entity.StockAllocation{}).
-				Where("stockable_type = ? AND stockable_id IN ? AND usable_type = ? AND status IN ?",
-					fifo.StockableKeyPurchaseItems.String(),
-					itemIDs,
-					fifo.UsableKeyProjectChickin.String(),
-					[]string{entity.StockAllocationStatusActive, entity.StockAllocationStatusPending},
-				).
-				Count(&count).Error; err != nil {
-				return err
-			}
-			if count > 0 {
-				return utils.BadRequest("Purchase already chickin, failed to delete purchase")
-			}
+		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 {
@@ -1577,10 +1441,9 @@ 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
@@ -1596,42 +1459,43 @@ func (s *purchaseService) rollbackPurchaseStock(ctx context.Context, tx *gorm.DB
 		pwID := *item.ProductWarehouseId
 		qty := item.TotalQty
 
-		if s.FifoSvc != nil {
-			if err := s.FifoSvc.AdjustStockableQuantity(ctx, commonSvc.StockAdjustRequest{
-				StockableKey:       fifo.StockableKeyPurchaseItems,
-				StockableID:        item.Id,
-				ProductWarehouseID: pwID,
-				Quantity:           -qty,
-				Tx:                 tx,
-			}); err != nil {
-				return err
-			}
-			logEntries = append(logEntries, struct {
-				pwID uint
-				qty  float64
-			}{pwID: pwID, qty: qty})
-			continue
+		if err := tx.WithContext(ctx).
+			Model(&entity.PurchaseItem{}).
+			Where("id = ?", item.Id).
+			Update("total_qty", 0).Error; err != nil {
+			return err
 		}
 
-		deltas[pwID] -= qty
 		affected[pwID] = struct{}{}
+		if item.ReceivedDate != nil {
+			assignEarliestAsOf(reflowAsOfByPW, pwID, item.ReceivedDate.UTC())
+		} else {
+			assignEarliestAsOf(reflowAsOfByPW, pwID, time.Now().UTC())
+		}
 		logEntries = append(logEntries, struct {
 			pwID uint
 			qty  float64
 		}{pwID: pwID, qty: qty})
 	}
 
-	if s.FifoSvc == nil && len(deltas) > 0 {
-		if err := pwRepoTx.AdjustQuantities(ctx, deltas, nil); err != nil {
-			return err
+	if len(reflowAsOfByPW) > 0 {
+		if s.FifoStockV2Svc == nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "FIFO v2 service is not available")
 		}
-		if len(affected) > 0 {
-			if err := pwRepoTx.CleanupEmpty(ctx, affected); err != nil {
+		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 {
+			return err
+		}
+	}
+
 	if strings.TrimSpace(note) != "" && actorID != 0 && len(logEntries) > 0 {
 		logs := make([]*entity.StockLog, 0, len(logEntries))
 		for _, entry := range logEntries {
@@ -1799,7 +1663,7 @@ func (s *purchaseService) buildStaffAdjustmentPayload(
 			if *data.Qty <= 0 {
 				return nil, utils.BadRequest(fmt.Sprintf("Quantity for item %d must be greater than 0", item.Id))
 			}
-			if item.TotalUsed > 0 && *data.Qty < item.TotalUsed {
+			if item.TotalUsed > 0 && *data.Qty < item.TotalUsed && isReceivingBelowUsedBlocked(&item, nil) {
 				return nil, utils.BadRequest(fmt.Sprintf("Quantity for item %d cannot be lower than used amount (%.3f)", item.Id, item.TotalUsed))
 			}
 			if (item.TotalQty > 0 || item.TotalUsed > 0) && !syncReceiving {
@@ -1918,6 +1782,51 @@ func calculateTotalPrice(quantity float64, price float64, provided *float64, ref
 	return *provided, nil
 }
 
+func purchaseItemHasFlag(item *entity.PurchaseItem, flag utils.FlagType) bool {
+	if item == nil || item.Product == nil {
+		return false
+	}
+	target := utils.NormalizeFlag(string(flag))
+	for _, f := range item.Product.Flags {
+		if utils.NormalizeFlag(f.Name) == target {
+			return true
+		}
+	}
+	return false
+}
+
+func isReceivingBelowUsedBlocked(item *entity.PurchaseItem, lockedIDs map[uint]struct{}) bool {
+	if item == nil {
+		return false
+	}
+	if !purchaseItemHasAnyFlag(item, []utils.FlagType{
+		utils.FlagPullet,
+		utils.FlagLayer,
+		utils.FlagAyamAfkir,
+		utils.FlagAyamCulling,
+		utils.FlagAyamMati,
+	}) {
+		return false
+	}
+	if lockedIDs == nil {
+		return true
+	}
+	_, locked := lockedIDs[item.Id]
+	return locked
+}
+
+func purchaseItemHasAnyFlag(item *entity.PurchaseItem, flags []utils.FlagType) bool {
+	if item == nil || item.Product == nil || len(flags) == 0 {
+		return false
+	}
+	for _, flag := range flags {
+		if purchaseItemHasFlag(item, flag) {
+			return true
+		}
+	}
+	return false
+}
+
 func (s *purchaseService) attachLatestApproval(ctx context.Context, item *entity.Purchase) error {
 	if item == nil || item.Id == 0 || s.ApprovalSvc == nil {
 		return nil
@@ -2025,6 +1934,68 @@ 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,15 +147,16 @@ func (r *hppPerKandangRepository) GetFeedOvkDocCostByPeriod(ctx context.Context,
 		Table("project_chickins AS pc").
 		Select(`
 			pfk.id AS project_flock_kandang_id,
-			COALESCE(SUM(pc.usage_qty * COALESCE(pi.price, 0)), 0) AS doc_cost,
-			COALESCE(SUM(pc.usage_qty), 0) AS doc_qty,
+			COALESCE(SUM(sa.qty * COALESCE(pi.price, 0)), 0) AS doc_cost,
+			COALESCE(SUM(sa.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 purchase_items AS pi ON pi.product_warehouse_id = pc.product_warehouse_id").
+		Joins("LEFT JOIN stock_allocations AS sa ON sa.usable_type = ? AND sa.usable_id = pc.id AND sa.stockable_type = ? AND sa.status = ? AND sa.allocation_purpose = ?", fifo.UsableKeyProjectChickin.String(), fifo.StockableKeyPurchaseItems.String(), entity.StockAllocationStatusActive, entity.StockAllocationPurposeTraceChickin).
+		Joins("LEFT JOIN purchase_items AS pi ON pi.id = sa.stockable_id").
 		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).
@@ -221,13 +222,14 @@ 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 = ?", fifo.UsableKeyRecordingStock.String(), fifo.StockableKeyPurchaseItems.String()).
+		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 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").