add paired adjustment triger depletion adjustment

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

@@ -25,7 +25,6 @@ import (
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
 )
 
 type AdjustmentService interface {
@@ -51,16 +50,8 @@ type adjustmentService struct {
 const (
 	adjustmentLaneStockable = "STOCKABLE"
 	adjustmentLaneUsable    = "USABLE"
-	flagGroupAyam           = "AYAM"
 )
 
-type adjustmentDownstreamDependency struct {
-	UsableType    string `gorm:"column:usable_type"`
-	UsableID      uint64 `gorm:"column:usable_id"`
-	FunctionCode  string `gorm:"column:function_code"`
-	FlagGroupCode string `gorm:"column:flag_group_code"`
-}
-
 func NewAdjustmentService(
 	productRepo productRepo.ProductRepository,
 	stockLogsRepo stockLogsRepo.StockLogRepository,
@@ -86,23 +77,21 @@ func NewAdjustmentService(
 	}
 }
 
-func (s *adjustmentService) withRelations(db *gorm.DB) *gorm.DB {
-	return db.
-		Preload("ProductWarehouse").
-		Preload("ProductWarehouse.Product").
-		Preload("ProductWarehouse.Warehouse").
-		Preload("ProductWarehouse.Warehouse.Location").
-		Preload("ProductWarehouse.ProjectFlockKandang").
-		Preload("ProductWarehouse.ProjectFlockKandang.ProjectFlock").
-		Preload("StockLog.CreatedUser")
-}
-
 func (s *adjustmentService) GetOne(c *fiber.Ctx, id uint) (*entity.AdjustmentStock, error) {
 	if err := m.EnsureStockLogAccess(c, s.StockLogsRepository.DB(), id); err != nil {
 		return nil, err
 	}
 
-	adjustmentStock, err := s.AdjustmentStockRepository.GetByID(c.Context(), id, s.withRelations)
+	adjustmentStock, err := s.AdjustmentStockRepository.GetByID(c.Context(), id, func(db *gorm.DB) *gorm.DB {
+		return db.
+			Preload("ProductWarehouse").
+			Preload("ProductWarehouse.Product").
+			Preload("ProductWarehouse.Warehouse").
+			Preload("ProductWarehouse.Warehouse.Location").
+			Preload("ProductWarehouse.ProjectFlockKandang").
+			Preload("ProductWarehouse.ProjectFlockKandang.ProjectFlock").
+			Preload("StockLog.CreatedUser")
+	})
 	if err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, fiber.NewError(fiber.StatusNotFound, "Adjustment not found")
@@ -132,154 +121,232 @@ func (s *adjustmentService) DeleteOne(c *fiber.Ctx, id uint) error {
 	}
 
 	return s.StockLogsRepository.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		var adjustment entity.AdjustmentStock
-		if err := tx.WithContext(ctx).
-			Clauses(clause.Locking{Strength: "UPDATE"}).
-			Where("id = ?", id).
-			Take(&adjustment).Error; err != nil {
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				return fiber.NewError(fiber.StatusNotFound, "Adjustment not found")
-			}
-			return fiber.NewError(fiber.StatusInternalServerError, "Failed to load adjustment")
-		}
-
-		type productRow struct {
-			ProductID uint `gorm:"column:product_id"`
-		}
-		var prod productRow
-		if err := tx.WithContext(ctx).
-			Table("product_warehouses").
-			Select("product_id").
-			Where("id = ?", adjustment.ProductWarehouseId).
-			Take(&prod).Error; err != nil {
-			return fiber.NewError(fiber.StatusInternalServerError, "Failed to load product warehouse context")
-		}
-
-		routeMeta, err := s.resolveRouteByFunctionCode(ctx, prod.ProductID, adjustment.FunctionCode)
+		adjustments, err := s.collectAdjustmentsForDelete(ctx, tx, id)
 		if err != nil {
 			return err
 		}
-		isAyamProduct, err := s.isAyamProduct(ctx, tx, prod.ProductID)
-		if err != nil {
-			s.Log.Errorf("Failed to resolve AYAM flag for product %d: %+v", prod.ProductID, err)
-			return fiber.NewError(fiber.StatusInternalServerError, "Failed to validate product flag")
-		}
-
-		stockLogRepoTx := stockLogsRepo.NewStockLogRepository(tx)
-		notes := fmt.Sprintf("ADJUSTMENT DELETE#%s", strings.TrimSpace(adjustment.AdjNumber))
-
-		switch routeMeta.Lane {
-		case adjustmentLaneStockable:
-			deps, allowPending, err := s.resolveAdjustmentDependenciesAndPolicy(
-				ctx,
-				tx,
-				fifo.StockableKeyAdjustmentIn.String(),
-				[]uint{adjustment.Id},
-			)
-			if err != nil {
+		for _, item := range adjustments {
+			if err := s.deleteSingleAdjustmentInTx(ctx, tx, item, actorID); err != nil {
 				return err
 			}
-			if len(deps) > 0 && isAyamProduct {
-				return fiber.NewError(
-					fiber.StatusBadRequest,
-					fmt.Sprintf(
-						"Adjustment tidak dapat dihapus karena produk AYAM sudah dipakai transaksi turunan. Dependensi aktif: %s. Alasan block: produk AYAM yang sudah terpakai tidak dapat dihapus.",
-						formatAdjustmentDependencySummary(deps),
-					),
-				)
-			}
-			if len(deps) > 0 && !allowPending {
-				return fiber.NewError(
-					fiber.StatusBadRequest,
-					fmt.Sprintf(
-						"Adjustment tidak dapat dihapus karena stok adjustment sudah dipakai transaksi turunan. Dependensi aktif: %s. Alasan block: pending disabled by config.",
-						formatAdjustmentDependencySummary(deps),
-					),
-				)
-			}
-
-			oldQty := adjustment.TotalQty
-			if oldQty > 0 {
-				if err := tx.WithContext(ctx).
-					Model(&entity.AdjustmentStock{}).
-					Where("id = ?", adjustment.Id).
-					Update("total_qty", 0).Error; err != nil {
-					return err
-				}
-				asOf := adjustment.CreatedAt
-				if _, err := s.FifoStockV2Svc.Reflow(ctx, common.FifoStockV2ReflowRequest{
-					FlagGroupCode:      routeMeta.FlagGroupCode,
-					ProductWarehouseID: adjustment.ProductWarehouseId,
-					AsOf:               &asOf,
-					Tx:                 tx,
-				}); err != nil {
-					return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to reflow stock via FIFO v2: %v", err))
-				}
-				if err := s.createAdjustmentStockLog(
-					ctx,
-					stockLogRepoTx,
-					adjustment.Id,
-					adjustment.ProductWarehouseId,
-					notes,
-					actorID,
-					0,
-					oldQty,
-				); err != nil {
-					return err
-				}
-			}
-		case adjustmentLaneUsable:
-			rollbackRes, err := s.FifoStockV2Svc.Rollback(ctx, common.FifoStockV2RollbackRequest{
-				ProductWarehouseID: adjustment.ProductWarehouseId,
-				Usable: common.FifoStockV2Ref{
-					ID:            adjustment.Id,
-					LegacyTypeKey: routeMeta.LegacyTypeKey,
-					FunctionCode:  routeMeta.FunctionCode,
-				},
-				Reason: notes,
-				Tx:     tx,
-			})
-			if err != nil {
-				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to rollback FIFO v2 adjustment: %v", err))
-			}
-
-			releasedQty := 0.0
-			if rollbackRes != nil {
-				releasedQty = rollbackRes.ReleasedQty
-			}
-			if releasedQty > 0 {
-				if err := s.createAdjustmentStockLog(
-					ctx,
-					stockLogRepoTx,
-					adjustment.Id,
-					adjustment.ProductWarehouseId,
-					notes,
-					actorID,
-					releasedQty,
-					0,
-				); err != nil {
-					return err
-				}
-			}
-		default:
-			return fiber.NewError(fiber.StatusBadRequest, "Unsupported adjustment lane")
 		}
-
-		if err := tx.WithContext(ctx).
-			Where("loggable_type = ? AND loggable_id = ?", string(utils.StockLogTypeAdjustment), adjustment.Id).
-			Delete(&entity.StockLog{}).Error; err != nil {
-			return fiber.NewError(fiber.StatusInternalServerError, "Failed to delete adjustment stock logs")
-		}
-		if err := tx.WithContext(ctx).
-			Where("id = ?", adjustment.Id).
-			Delete(&entity.AdjustmentStock{}).Error; err != nil {
-			return fiber.NewError(fiber.StatusInternalServerError, "Failed to delete adjustment")
-		}
-
 		return nil
 	})
 }
 
+func (s *adjustmentService) collectAdjustmentsForDelete(ctx context.Context, tx *gorm.DB, id uint) ([]entity.AdjustmentStock, error) {
+	repoTx := s.AdjustmentStockRepository.WithTx(tx)
+	adjustment, err := repoTx.GetByIDForUpdate(ctx, id)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, fiber.NewError(fiber.StatusNotFound, "Adjustment not found")
+		}
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to load adjustment")
+	}
+
+	adjustments := []entity.AdjustmentStock{*adjustment}
+	leftPairCode := utils.NormalizeUpper(adjustment.FunctionCode)
+	isDepletionCode := leftPairCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionIn) ||
+		leftPairCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionOut)
+	if !isDepletionCode {
+		return adjustments, nil
+	}
+	if adjustment.PairedAdjustmentId == nil || *adjustment.PairedAdjustmentId == 0 {
+		return nil, fiber.NewError(
+			fiber.StatusBadRequest,
+			"Adjustment depletion tidak memiliki pasangan valid. Data harus diperbaiki terlebih dahulu untuk mencegah orphan.",
+		)
+	}
+
+	pair, err := repoTx.GetByIDForUpdate(ctx, *adjustment.PairedAdjustmentId)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, fiber.NewError(
+				fiber.StatusBadRequest,
+				fmt.Sprintf("Pasangan adjustment depletion (%d) tidak ditemukan. Data harus diperbaiki terlebih dahulu untuk mencegah orphan.", *adjustment.PairedAdjustmentId),
+			)
+		}
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to load paired adjustment")
+	}
+	rightPairCode := utils.NormalizeUpper(pair.FunctionCode)
+	isPairDepletionCode := rightPairCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionIn) ||
+		rightPairCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionOut)
+	if !isPairDepletionCode {
+		return nil, fiber.NewError(
+			fiber.StatusBadRequest,
+			fmt.Sprintf("Pasangan adjustment %d bukan depletion pair yang valid", pair.Id),
+		)
+	}
+	if pair.PairedAdjustmentId == nil || *pair.PairedAdjustmentId != adjustment.Id {
+		return nil, fiber.NewError(
+			fiber.StatusBadRequest,
+			fmt.Sprintf("Pasangan adjustment depletion tidak konsisten (%d <-> %d). Perbaiki pairing terlebih dahulu.", adjustment.Id, pair.Id),
+		)
+	}
+	isValidPair := (leftPairCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionIn) &&
+		rightPairCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionOut)) ||
+		(leftPairCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionOut) &&
+			rightPairCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionIn))
+	if !isValidPair {
+		return nil, fiber.NewError(
+			fiber.StatusBadRequest,
+			fmt.Sprintf("Pasangan function_code depletion tidak valid (%s <-> %s)", adjustment.FunctionCode, pair.FunctionCode),
+		)
+	}
+
+	adjustments = append(adjustments, *pair)
+	sort.Slice(adjustments, func(i, j int) bool {
+		return adjustments[i].Id < adjustments[j].Id
+	})
+	return adjustments, nil
+}
+
+func (s *adjustmentService) deleteSingleAdjustmentInTx(
+	ctx context.Context,
+	tx *gorm.DB,
+	adjustment entity.AdjustmentStock,
+	actorID uint,
+) error {
+	repoTx := s.AdjustmentStockRepository.WithTx(tx)
+	productID, err := repoTx.FindProductIDByProductWarehouseID(ctx, adjustment.ProductWarehouseId)
+	if err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "Failed to load product warehouse context")
+	}
+
+	routeMeta, err := s.resolveRouteByFunctionCode(ctx, productID, adjustment.FunctionCode)
+	if err != nil {
+		return err
+	}
+	isAyamProduct, err := repoTx.IsAyamProduct(ctx, productID)
+	if err != nil {
+		s.Log.Errorf("Failed to resolve AYAM flag for product %d: %+v", productID, err)
+		return fiber.NewError(fiber.StatusInternalServerError, "Failed to validate product flag")
+	}
+
+	stockLogRepoTx := stockLogsRepo.NewStockLogRepository(tx)
+	notes := fmt.Sprintf("ADJUSTMENT DELETE#%s", utils.NormalizeTrim(adjustment.AdjNumber))
+
+	switch routeMeta.Lane {
+	case adjustmentLaneStockable:
+		deps, allowPending, err := s.resolveAdjustmentDependenciesAndPolicy(
+			ctx,
+			tx,
+			fifo.StockableKeyAdjustmentIn.String(),
+			[]uint{adjustment.Id},
+		)
+		if err != nil {
+			return err
+		}
+		if len(deps) > 0 && isAyamProduct {
+			return fiber.NewError(
+				fiber.StatusBadRequest,
+				fmt.Sprintf(
+					"Adjustment tidak dapat dihapus karena produk AYAM sudah dipakai transaksi turunan. Dependensi aktif: %s. Alasan block: produk AYAM yang sudah terpakai tidak dapat dihapus.",
+					formatAdjustmentDependencySummary(deps),
+				),
+			)
+		}
+		if len(deps) > 0 && !allowPending {
+			return fiber.NewError(
+				fiber.StatusBadRequest,
+				fmt.Sprintf(
+					"Adjustment tidak dapat dihapus karena stok adjustment sudah dipakai transaksi turunan. Dependensi aktif: %s. Alasan block: pending disabled by config.",
+					formatAdjustmentDependencySummary(deps),
+				),
+			)
+		}
+
+		oldQty := adjustment.TotalQty
+		if oldQty > 0 {
+			if err := repoTx.UpdateTotalQty(ctx, adjustment.Id, 0); err != nil {
+				return err
+			}
+			asOf := adjustment.CreatedAt
+			if _, err := s.FifoStockV2Svc.Reflow(ctx, common.FifoStockV2ReflowRequest{
+				FlagGroupCode:      routeMeta.FlagGroupCode,
+				ProductWarehouseID: adjustment.ProductWarehouseId,
+				AsOf:               &asOf,
+				Tx:                 tx,
+			}); err != nil {
+				return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to reflow stock via FIFO v2: %v", err))
+			}
+			if err := s.createAdjustmentStockLog(
+				ctx,
+				stockLogRepoTx,
+				adjustment.Id,
+				adjustment.ProductWarehouseId,
+				notes,
+				actorID,
+				0,
+				oldQty,
+			); err != nil {
+				return err
+			}
+		}
+	case adjustmentLaneUsable:
+		activeBeforeRollback, err := repoTx.CountActiveConsumeAllocationsByUsable(ctx, fifo.UsableKeyAdjustmentOut.String(), adjustment.Id)
+		if err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Failed to validate adjustment allocations before rollback")
+		}
+		rollbackRes, err := s.FifoStockV2Svc.Rollback(ctx, common.FifoStockV2RollbackRequest{
+			ProductWarehouseID: adjustment.ProductWarehouseId,
+			Usable: common.FifoStockV2Ref{
+				ID:            adjustment.Id,
+				LegacyTypeKey: fifo.UsableKeyAdjustmentOut.String(),
+			},
+			Reason: notes,
+			Tx:     tx,
+		})
+		if err != nil {
+			return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to rollback FIFO v2 adjustment: %v", err))
+		}
+		activeAfterRollback, err := repoTx.CountActiveConsumeAllocationsByUsable(ctx, fifo.UsableKeyAdjustmentOut.String(), adjustment.Id)
+		if err != nil {
+			return fiber.NewError(fiber.StatusInternalServerError, "Failed to validate adjustment allocations after rollback")
+		}
+		if activeAfterRollback > 0 {
+			return fiber.NewError(
+				fiber.StatusBadRequest,
+				fmt.Sprintf(
+					"Adjustment tidak dapat dihapus karena masih ada alokasi aktif ADJUSTMENT_OUT=%d (sebelum rollback=%d, sesudah rollback=%d).",
+					adjustment.Id,
+					activeBeforeRollback,
+					activeAfterRollback,
+				),
+			)
+		}
+
+		releasedQty := 0.0
+		if rollbackRes != nil {
+			releasedQty = rollbackRes.ReleasedQty
+		}
+		if releasedQty > 0 {
+			if err := s.createAdjustmentStockLog(
+				ctx,
+				stockLogRepoTx,
+				adjustment.Id,
+				adjustment.ProductWarehouseId,
+				notes,
+				actorID,
+				releasedQty,
+				0,
+			); err != nil {
+				return err
+			}
+		}
+	default:
+		return fiber.NewError(fiber.StatusBadRequest, "Unsupported adjustment lane")
+	}
+
+	if err := repoTx.DeleteStockLogsByAdjustmentID(ctx, adjustment.Id); err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "Failed to delete adjustment stock logs")
+	}
+	if err := repoTx.DeleteAdjustmentByID(ctx, adjustment.Id); err != nil {
+		return fiber.NewError(fiber.StatusInternalServerError, "Failed to delete adjustment")
+	}
+	return nil
+}
+
 func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*entity.AdjustmentStock, error) {
 	if err := s.Validate.Struct(req); err != nil {
 		return nil, err
@@ -298,12 +365,12 @@ func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*e
 		return nil, fiber.NewError(fiber.StatusBadRequest, "Quantity must be greater than zero")
 	}
 
-	functionCode := strings.ToUpper(strings.TrimSpace(req.TransactionSubtype))
+	functionCode := utils.NormalizeUpper(req.TransactionSubtype)
 	if functionCode == "" {
-		functionCode = strings.ToUpper(strings.TrimSpace(req.TransactionSubType))
+		functionCode = utils.NormalizeUpper(req.TransactionSubType)
 	}
 	if functionCode == "" {
-		functionCode = strings.ToUpper(strings.TrimSpace(req.FunctionCode))
+		functionCode = utils.NormalizeUpper(req.FunctionCode)
 	}
 	if functionCode == "" {
 		return nil, fiber.NewError(fiber.StatusBadRequest, "Transaction subtype is required")
@@ -320,9 +387,9 @@ func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*e
 		return nil, err
 	}
 
-	note := strings.TrimSpace(req.Notes)
+	note := utils.NormalizeTrim(req.Notes)
 	if note == "" {
-		note = strings.TrimSpace(req.Note)
+		note = utils.NormalizeTrim(req.Note)
 	}
 	grandTotal := math.Round((qty*req.Price)*1000) / 1000
 
@@ -404,8 +471,11 @@ func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*e
 				return fiber.NewError(fiber.StatusInternalServerError, "FIFO v2 service is not available")
 			}
 
-			sourcePW, err := s.resolveAyamSourceProductWarehouse(ctx, tx, warehouseID, *projectFlockKandangID)
+			sourcePW, err := adjustmentStockRepoTX.FindAyamSourceProductWarehouse(ctx, warehouseID, *projectFlockKandangID)
 			if err != nil {
+				if errors.Is(err, gorm.ErrRecordNotFound) {
+					return fiber.NewError(fiber.StatusBadRequest, "Produk sumber AYAM pada project flock kandang yang sama tidak ditemukan")
+				}
 				return err
 			}
 			if err := common.EnsureProjectFlockNotClosedForProductWarehouses(
@@ -461,6 +531,14 @@ func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*e
 			if err := adjustmentStockRepoTX.CreateOne(ctx, destinationAdjustment, nil); err != nil {
 				return fiber.NewError(fiber.StatusInternalServerError, "Failed to create depletion destination adjustment stock record")
 			}
+			if err := adjustmentStockRepoTX.UpdatePairedAdjustmentID(ctx, sourceAdjustment.Id, destinationAdjustment.Id); err != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Failed to link depletion source adjustment pair")
+			}
+			if err := adjustmentStockRepoTX.UpdatePairedAdjustmentID(ctx, destinationAdjustment.Id, sourceAdjustment.Id); err != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Failed to link depletion destination adjustment pair")
+			}
+			sourceAdjustment.PairedAdjustmentId = &destinationAdjustment.Id
+			destinationAdjustment.PairedAdjustmentId = &sourceAdjustment.Id
 
 			sourceAsOf := sourceAdjustment.CreatedAt
 			if _, err := s.FifoStockV2Svc.Reflow(ctx, common.FifoStockV2ReflowRequest{
@@ -502,7 +580,7 @@ func (s *adjustmentService) Adjustment(c *fiber.Ctx, req *validation.Create) (*e
 				); err != nil {
 					return err
 				}
-				if err := s.resyncProjectFlockPopulationUsage(ctx, tx, *projectFlockKandangID); err != nil {
+				if err := adjustmentStockRepoTX.ResyncProjectFlockPopulationUsage(ctx, *projectFlockKandangID); err != nil {
 					return fiber.NewError(fiber.StatusInternalServerError, "Failed to resync project flock population usage")
 				}
 			}
@@ -678,38 +756,13 @@ func (s *adjustmentService) resolveRouteByFunctionCode(
 	}
 }
 
-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) resolveAdjustmentDependenciesAndPolicy(
 	ctx context.Context,
 	tx *gorm.DB,
 	stockableType string,
 	stockableIDs []uint,
-) ([]adjustmentDownstreamDependency, bool, error) {
-	deps, err := s.loadAdjustmentDownstreamDependencies(ctx, tx, stockableType, stockableIDs)
+) ([]adjustmentStockRepo.AdjustmentDownstreamDependency, bool, error) {
+	deps, err := s.AdjustmentStockRepository.WithTx(tx).LoadDownstreamDependencies(ctx, stockableType, stockableIDs)
 	if err != nil {
 		s.Log.Errorf("Failed to load downstream adjustment dependencies: %+v", err)
 		return nil, false, fiber.NewError(fiber.StatusInternalServerError, "Failed to validate downstream adjustment dependencies")
@@ -739,50 +792,14 @@ func (s *adjustmentService) resolveAdjustmentDependenciesAndPolicy(
 	return deps, allowPending, nil
 }
 
-func (s *adjustmentService) loadAdjustmentDownstreamDependencies(
-	ctx context.Context,
-	tx *gorm.DB,
-	stockableType string,
-	stockableIDs []uint,
-) ([]adjustmentDownstreamDependency, error) {
-	if strings.TrimSpace(stockableType) == "" || len(stockableIDs) == 0 {
-		return nil, nil
-	}
-
-	db := s.AdjustmentStockRepository.DB().WithContext(ctx)
-	if tx != nil {
-		db = tx.WithContext(ctx)
-	}
-
-	var rows []adjustmentDownstreamDependency
-	err := db.Table("stock_allocations").
-		Select("usable_type, usable_id, COALESCE(function_code,'') AS function_code, COALESCE(flag_group_code,'') AS flag_group_code").
-		Where("stockable_type = ?", strings.ToUpper(strings.TrimSpace(stockableType))).
-		Where("stockable_id IN ?", stockableIDs).
-		Where("status = ?", entity.StockAllocationStatusActive).
-		Where("allocation_purpose = ?", entity.StockAllocationPurposeConsume).
-		Where("deleted_at IS NULL").
-		Where(
-			"(usable_type <> ? OR EXISTS (SELECT 1 FROM project_chickins pc WHERE pc.id = stock_allocations.usable_id AND pc.deleted_at IS NULL))",
-			fifo.UsableKeyProjectChickin.String(),
-		).
-		Group("usable_type, usable_id, function_code, flag_group_code").
-		Scan(&rows).Error
-	if err != nil {
-		return nil, err
-	}
-
-	return rows, nil
-}
-
-func formatAdjustmentDependencySummary(rows []adjustmentDownstreamDependency) string {
+func formatAdjustmentDependencySummary(rows []adjustmentStockRepo.AdjustmentDownstreamDependency) string {
 	if len(rows) == 0 {
 		return "-"
 	}
 
 	grouped := make(map[string]map[uint64]struct{})
 	for _, row := range rows {
-		label := strings.ToUpper(strings.TrimSpace(row.UsableType))
+		label := utils.NormalizeUpper(row.UsableType)
 		if label == "" {
 			label = "UNKNOWN"
 		}
@@ -841,68 +858,6 @@ 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) isAyamProduct(ctx context.Context, tx *gorm.DB, productID uint) (bool, error) {
-	if productID == 0 {
-		return false, nil
-	}
-
-	db := s.AdjustmentStockRepository.DB().WithContext(ctx)
-	if tx != nil {
-		db = tx.WithContext(ctx)
-	}
-
-	var count int64
-	if err := db.Table("flags f").
-		Joins("JOIN fifo_stock_v2_flag_members fm ON fm.flag_name = f.name AND fm.flag_group_code = ? AND fm.is_active = TRUE", flagGroupAyam).
-		Where("f.flagable_type = ?", entity.FlagableTypeProduct).
-		Where("f.flagable_id = ?", productID).
-		Count(&count).Error; err != nil {
-		return false, err
-	}
-
-	return count > 0, nil
-}
-
 func (s *adjustmentService) createAdjustmentStockLog(
 	ctx context.Context,
 	stockLogRepo stockLogsRepo.StockLogRepository,
@@ -986,57 +941,6 @@ func (s *adjustmentService) allocatePopulationForDepletionAdjustment(
 	)
 }
 
-func (s *adjustmentService) resyncProjectFlockPopulationUsage(ctx context.Context, tx *gorm.DB, projectFlockKandangID uint) error {
-	if tx == nil || projectFlockKandangID == 0 {
-		return nil
-	}
-
-	idsSubquery := `
-		SELECT pfp.id
-		FROM project_flock_populations pfp
-		JOIN project_chickins pc ON pc.id = pfp.project_chickin_id
-		WHERE pc.project_flock_kandang_id = ?
-	`
-
-	updateWithAlloc := `
-		UPDATE project_flock_populations p
-		SET total_used_qty = COALESCE(a.used, 0)
-		FROM (
-			SELECT stockable_id, SUM(qty) AS used
-			FROM stock_allocations
-			WHERE stockable_type = 'PROJECT_FLOCK_POPULATION'
-			  AND status = 'ACTIVE'
-			  AND allocation_purpose = 'CONSUME'
-			GROUP BY stockable_id
-		) a
-		WHERE p.id = a.stockable_id
-		  AND p.id IN (` + idsSubquery + `)
-	`
-
-	resetMissing := `
-		UPDATE project_flock_populations p
-		SET total_used_qty = 0
-		WHERE p.id IN (` + idsSubquery + `)
-			AND NOT EXISTS (
-				SELECT 1
-				FROM stock_allocations sa
-				WHERE sa.stockable_type = 'PROJECT_FLOCK_POPULATION'
-				  AND sa.status = 'ACTIVE'
-				  AND sa.allocation_purpose = 'CONSUME'
-				  AND sa.stockable_id = p.id
-			)
-	`
-
-	db := tx.WithContext(ctx)
-	if err := db.Exec(updateWithAlloc, projectFlockKandangID).Error; err != nil {
-		return err
-	}
-	if err := db.Exec(resetMissing, projectFlockKandangID).Error; err != nil {
-		return err
-	}
-	return nil
-}
-
 func (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
@@ -1079,11 +983,11 @@ func (s *adjustmentService) AdjustmentHistory(c *fiber.Ctx, query *validation.Qu
 		}
 	}
 
-	functionCode := strings.ToUpper(strings.TrimSpace(query.TransactionSubtype))
+	functionCode := utils.NormalizeUpper(query.TransactionSubtype)
 	if functionCode == "" {
-		functionCode = strings.ToUpper(strings.TrimSpace(query.FunctionCode))
+		functionCode = utils.NormalizeUpper(query.FunctionCode)
 	}
-	transactionType := strings.ToUpper(strings.TrimSpace(query.TransactionType))
+	transactionType := utils.NormalizeUpper(query.TransactionType)
 
 	adjustmentStocks, total, err := s.AdjustmentStockRepository.FindHistory(
 		c.Context(),