mirror of
https://gitlab.com/mbugroup/lti-api.git
synced 2026-05-20 13:31:56 +00:00
ragilap
799 lines
26 KiB
Go
799 lines
26 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
"strings"
|
|
|
|
"github.com/go-playground/validator/v10"
|
|
"github.com/gofiber/fiber/v2"
|
|
"github.com/sirupsen/logrus"
|
|
common "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"
|
|
adjustmentStockRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/adjustments/repositories"
|
|
validation "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/adjustments/validations"
|
|
ProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
|
|
productRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/master/products/repositories"
|
|
warehouseRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/master/warehouses/repositories"
|
|
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"
|
|
)
|
|
|
|
type AdjustmentService interface {
|
|
Adjustment(ctx *fiber.Ctx, req *validation.Create) (*entity.AdjustmentStock, error)
|
|
GetOne(ctx *fiber.Ctx, id uint) (*entity.AdjustmentStock, error)
|
|
AdjustmentHistory(ctx *fiber.Ctx, query *validation.Query) ([]*entity.AdjustmentStock, int64, error)
|
|
}
|
|
|
|
type adjustmentService struct {
|
|
Log *logrus.Logger
|
|
Validate *validator.Validate
|
|
StockLogsRepository stockLogsRepo.StockLogRepository
|
|
WarehouseRepo warehouseRepo.WarehouseRepository
|
|
ProductWarehouseRepo ProductWarehouse.ProductWarehouseRepository
|
|
ProductRepo productRepo.ProductRepository
|
|
ProjectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository
|
|
ProjectFlockPopulationRepo projectFlockKandangRepo.ProjectFlockPopulationRepository
|
|
AdjustmentStockRepository adjustmentStockRepo.AdjustmentStockRepository
|
|
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,
|
|
fifoStockV2Svc common.FifoStockV2Service,
|
|
validate *validator.Validate,
|
|
projectFlockKandangRepo projectFlockKandangRepo.ProjectFlockKandangRepository,
|
|
projectFlockPopulationRepo projectFlockKandangRepo.ProjectFlockPopulationRepository,
|
|
) AdjustmentService {
|
|
return &adjustmentService{
|
|
Log: utils.Log,
|
|
Validate: validate,
|
|
StockLogsRepository: stockLogsRepo,
|
|
WarehouseRepo: warehouseRepo,
|
|
ProductWarehouseRepo: productWarehouseRepo,
|
|
ProductRepo: productRepo,
|
|
ProjectFlockKandangRepo: projectFlockKandangRepo,
|
|
ProjectFlockPopulationRepo: projectFlockPopulationRepo,
|
|
AdjustmentStockRepository: adjustmentStockRepo,
|
|
FifoStockV2Svc: fifoStockV2Svc,
|
|
}
|
|
}
|
|
|
|
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)
|
|
if err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, fiber.NewError(fiber.StatusNotFound, "Adjustment not found")
|
|
}
|
|
s.Log.Errorf("Failed to get adjustment by id: %+v", err)
|
|
return nil, err
|
|
}
|
|
|
|
return adjustmentStock, 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
|
|
}
|
|
|
|
productID := req.ProductID
|
|
if productID == 0 {
|
|
return nil, fiber.NewError(fiber.StatusBadRequest, "Product is required")
|
|
}
|
|
|
|
qty := req.Qty
|
|
if qty <= 0 {
|
|
qty = req.Quantity
|
|
}
|
|
if qty <= 0 {
|
|
return nil, fiber.NewError(fiber.StatusBadRequest, "Quantity must be greater than zero")
|
|
}
|
|
|
|
functionCode := strings.ToUpper(strings.TrimSpace(req.TransactionSubtype))
|
|
if functionCode == "" {
|
|
functionCode = strings.ToUpper(strings.TrimSpace(req.TransactionSubType))
|
|
}
|
|
if functionCode == "" {
|
|
functionCode = strings.ToUpper(strings.TrimSpace(req.FunctionCode))
|
|
}
|
|
if functionCode == "" {
|
|
return nil, fiber.NewError(fiber.StatusBadRequest, "Transaction subtype is required")
|
|
}
|
|
if functionCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionOut) {
|
|
return nil, fiber.NewError(
|
|
fiber.StatusBadRequest,
|
|
"RECORDING_DEPLETION_OUT tidak boleh diinput manual. Gunakan RECORDING_DEPLETION_IN, sistem akan otomatis membuat depletion-out AYAM",
|
|
)
|
|
}
|
|
|
|
warehouseID, err := s.resolveWarehouseID(c.Context(), req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
note := strings.TrimSpace(req.Notes)
|
|
if note == "" {
|
|
note = strings.TrimSpace(req.Note)
|
|
}
|
|
grandTotal := math.Round((qty*req.Price)*1000) / 1000
|
|
|
|
ctx := c.Context()
|
|
actorID, err := m.ActorIDFromContext(c)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := m.EnsureWarehouseAccess(c, s.WarehouseRepo.DB(), warehouseID); err != nil {
|
|
return nil, err
|
|
}
|
|
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
|
|
}
|
|
|
|
routeMeta, err := s.resolveRouteByFunctionCode(ctx, productID, functionCode)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
transactionType := utils.ResolveAdjustmentTransactionType(routeMeta.FunctionCode)
|
|
|
|
var createdAdjustmentStockId uint
|
|
|
|
var projectFlockKandangID *uint
|
|
pfkID, err := s.getActiveProjectFlockKandangID(ctx, warehouseID)
|
|
if err == nil && pfkID > 0 {
|
|
projectFlockKandangID = &pfkID
|
|
}
|
|
|
|
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: productID,
|
|
WarehouseId: warehouseID,
|
|
Quantity: 0,
|
|
ProjectFlockKandangId: projectFlockKandangID,
|
|
}
|
|
|
|
if err := s.ProductWarehouseRepo.CreateOne(ctx, newPW, nil); err != nil {
|
|
return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to create product warehouse")
|
|
}
|
|
pw = newPW
|
|
}
|
|
|
|
if err := common.EnsureProjectFlockNotClosedForProductWarehouses(
|
|
ctx,
|
|
s.StockLogsRepository.DB(),
|
|
[]uint{pw.Id},
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
err = s.StockLogsRepository.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
productWarehouseRepoTX := ProductWarehouse.NewProductWarehouseRepository(tx)
|
|
stockLogRepoTX := stockLogsRepo.NewStockLogRepository(tx)
|
|
adjustmentStockRepoTX := s.AdjustmentStockRepository.WithTx(tx)
|
|
|
|
productWarehouse, err := productWarehouseRepoTX.FindByProductWarehouseAndPfk(ctx, productID, warehouseID, projectFlockKandangID)
|
|
if err != nil {
|
|
s.Log.Errorf("Failed to get product warehouse: %+v", err)
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get product warehouse")
|
|
}
|
|
|
|
if functionCode == string(utils.AdjustmentTransactionSubtypeRecordingDepletionIn) {
|
|
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")
|
|
}
|
|
|
|
sourcePW, err := s.resolveAyamSourceProductWarehouse(ctx, tx, warehouseID, *projectFlockKandangID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := common.EnsureProjectFlockNotClosedForProductWarehouses(
|
|
ctx,
|
|
tx,
|
|
[]uint{productWarehouse.Id, sourcePW.Id},
|
|
); err != nil {
|
|
return err
|
|
}
|
|
|
|
sourceRoute, err := s.resolveRouteByFunctionCode(
|
|
ctx,
|
|
sourcePW.ProductId,
|
|
string(utils.AdjustmentTransactionSubtypeRecordingDepletionOut),
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if sourceRoute.Lane != adjustmentLaneUsable {
|
|
return fiber.NewError(fiber.StatusBadRequest, "Route depletion out untuk produk AYAM tidak valid")
|
|
}
|
|
|
|
sourceCode, err := adjustmentStockRepoTX.GenerateSequentialNumber(ctx, utils.AdjustmentStockNumberPrefix)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
sourceAdjustment := &entity.AdjustmentStock{
|
|
ProductWarehouseId: sourcePW.Id,
|
|
TransactionType: transactionType,
|
|
FunctionCode: sourceRoute.FunctionCode,
|
|
UsageQty: qty,
|
|
Price: req.Price,
|
|
GrandTotal: grandTotal,
|
|
AdjNumber: sourceCode,
|
|
}
|
|
if err := adjustmentStockRepoTX.CreateOne(ctx, sourceAdjustment, nil); err != nil {
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to create depletion source adjustment stock record")
|
|
}
|
|
|
|
destCode, err := adjustmentStockRepoTX.GenerateSequentialNumber(ctx, utils.AdjustmentStockNumberPrefix)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
destinationAdjustment := &entity.AdjustmentStock{
|
|
ProductWarehouseId: productWarehouse.Id,
|
|
TransactionType: transactionType,
|
|
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")
|
|
}
|
|
consumedPopulationQty := refreshedSource.UsageQty + refreshedSource.PendingQty
|
|
if consumedPopulationQty > 0 {
|
|
if err := s.allocatePopulationForDepletionAdjustment(
|
|
ctx,
|
|
tx,
|
|
*projectFlockKandangID,
|
|
sourcePW.Id,
|
|
refreshedSource.Id,
|
|
consumedPopulationQty,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
if err := s.resyncProjectFlockPopulationUsage(ctx, tx, *projectFlockKandangID); err != nil {
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to resync project flock population usage")
|
|
}
|
|
}
|
|
|
|
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,
|
|
}
|
|
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 := adjustmentStockRepoTX.CreateOne(ctx, adjustmentStock, nil); err != nil {
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Failed to create adjustment stock record")
|
|
}
|
|
|
|
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")
|
|
}
|
|
|
|
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))
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
if err := s.createAdjustmentStockLog(
|
|
ctx,
|
|
stockLogRepoTX,
|
|
adjustmentStock.Id,
|
|
productWarehouse.Id,
|
|
note,
|
|
actorID,
|
|
increaseQty,
|
|
decreaseQty,
|
|
); err != nil {
|
|
return err
|
|
}
|
|
|
|
createdAdjustmentStockId = adjustmentStock.Id
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
s.Log.Errorf("Transaction failed in CreateOne: %+v", err)
|
|
var fiberErr *fiber.Error
|
|
if errors.As(err, &fiberErr) {
|
|
return nil, err
|
|
}
|
|
return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to process adjustment transaction")
|
|
}
|
|
|
|
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 {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return 0, fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Gudang dengan ID %d tidak ditemukan", warehouseID))
|
|
}
|
|
s.Log.Errorf("Failed to get warehouse %d: %+v", warehouseID, err)
|
|
return 0, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data gudang")
|
|
}
|
|
|
|
if warehouse.KandangId == nil || *warehouse.KandangId == 0 {
|
|
return 0, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Gudang %d belum terhubung ke kandang", warehouseID))
|
|
}
|
|
|
|
projectFlockKandang, err := s.ProjectFlockKandangRepo.GetActiveByKandangID(ctx, uint(*warehouse.KandangId))
|
|
if err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return 0, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Kandang %d belum memiliki project flock aktif", *warehouse.KandangId))
|
|
}
|
|
s.Log.Errorf("Failed to get active project flock for kandang %d: %+v", *warehouse.KandangId, err)
|
|
return 0, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil project flock kandang")
|
|
}
|
|
|
|
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) allocatePopulationForDepletionAdjustment(
|
|
ctx context.Context,
|
|
tx *gorm.DB,
|
|
projectFlockKandangID uint,
|
|
sourceProductWarehouseID uint,
|
|
adjustmentID uint,
|
|
consumeQty float64,
|
|
) error {
|
|
if consumeQty <= 0 {
|
|
return nil
|
|
}
|
|
if tx == nil {
|
|
return errors.New("transaction is required")
|
|
}
|
|
if projectFlockKandangID == 0 || sourceProductWarehouseID == 0 || adjustmentID == 0 {
|
|
return fiber.NewError(fiber.StatusBadRequest, "Invalid depletion adjustment population context")
|
|
}
|
|
if s.ProjectFlockPopulationRepo == nil {
|
|
return fiber.NewError(fiber.StatusInternalServerError, "Project flock population repository is not available")
|
|
}
|
|
|
|
popRepoTx := s.ProjectFlockPopulationRepo.WithTx(tx)
|
|
populations, err := popRepoTx.GetByProjectFlockKandangIDAndProductWarehouseID(ctx, projectFlockKandangID, sourceProductWarehouseID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(populations) == 0 {
|
|
return fiber.NewError(fiber.StatusBadRequest, "Populasi tidak ditemukan untuk depletion adjustment")
|
|
}
|
|
|
|
return fifoV2.AllocatePopulationConsumption(
|
|
ctx,
|
|
tx,
|
|
populations,
|
|
sourceProductWarehouseID,
|
|
fifo.UsableKeyAdjustmentOut.String(),
|
|
adjustmentID,
|
|
consumeQty,
|
|
)
|
|
}
|
|
|
|
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
|
|
}
|
|
if query.Page <= 0 {
|
|
query.Page = 1
|
|
}
|
|
if query.Limit <= 0 {
|
|
query.Limit = 10
|
|
}
|
|
offset := (query.Page - 1) * query.Limit
|
|
|
|
var isProductsExist bool
|
|
isWarehousesExist, err := s.WarehouseRepo.IdExists(c.Context(), uint(query.WarehouseID))
|
|
|
|
if err != nil {
|
|
return nil, 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to validate warehouse")
|
|
}
|
|
if query.WarehouseID > 0 && !isWarehousesExist {
|
|
return nil, 0, fiber.NewError(fiber.StatusNotFound, "Warehouse not found")
|
|
}
|
|
|
|
isProductsExist, err = s.ProductRepo.IdExists(c.Context(), uint(query.ProductID))
|
|
|
|
if err != nil {
|
|
s.Log.Errorf("Failed to check product existence: %+v", err)
|
|
return nil, 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to validate product")
|
|
}
|
|
if query.ProductID > 0 && !isProductsExist {
|
|
return nil, 0, fiber.NewError(fiber.StatusNotFound, "Product not found")
|
|
}
|
|
|
|
scope, scopeErr := m.ResolveLocationScope(c, s.AdjustmentStockRepository.DB())
|
|
if scopeErr != nil {
|
|
return nil, 0, scopeErr
|
|
}
|
|
if scope.Restrict {
|
|
if len(scope.IDs) == 0 {
|
|
return []*entity.AdjustmentStock{}, 0, nil
|
|
}
|
|
}
|
|
|
|
functionCode := strings.ToUpper(strings.TrimSpace(query.TransactionSubtype))
|
|
if functionCode == "" {
|
|
functionCode = strings.ToUpper(strings.TrimSpace(query.FunctionCode))
|
|
}
|
|
transactionType := strings.ToUpper(strings.TrimSpace(query.TransactionType))
|
|
|
|
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")
|
|
}
|
|
|
|
return adjustmentStocks, total, nil
|
|
}
|