mirror of
https://gitlab.com/mbugroup/lti-api.git
synced 2026-05-20 13:31:56 +00:00
Hafizh A. Y
521 lines
18 KiB
Go
521 lines
18 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"
|
|
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
|
|
AdjustmentStockRepository adjustmentStockRepo.AdjustmentStockRepository
|
|
FifoSvc common.FifoService
|
|
FifoStockV2Svc common.FifoStockV2Service
|
|
}
|
|
|
|
const (
|
|
adjustmentLaneStockable = "STOCKABLE"
|
|
adjustmentLaneUsable = "USABLE"
|
|
)
|
|
|
|
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 {
|
|
return &adjustmentService{
|
|
Log: utils.Log,
|
|
Validate: validate,
|
|
StockLogsRepository: stockLogsRepo,
|
|
WarehouseRepo: warehouseRepo,
|
|
ProductWarehouseRepo: productWarehouseRepo,
|
|
ProductRepo: productRepo,
|
|
ProjectFlockKandangRepo: projectFlockKandangRepo,
|
|
AdjustmentStockRepository: adjustmentStockRepo,
|
|
FifoSvc: fifoSvc,
|
|
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.AdjustmentTransactionSubtypeRecordingDepletionIn) {
|
|
functionCode = string(utils.AdjustmentTransactionSubtypeRecordingDepletionOut)
|
|
}
|
|
|
|
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)
|
|
|
|
allowPending := false
|
|
if routeMeta.Lane == adjustmentLaneUsable {
|
|
allowPending, err = s.resolveOverconsumePolicy(ctx, routeMeta)
|
|
if err != nil {
|
|
s.Log.Errorf("Failed to resolve overconsume rule: %+v", err)
|
|
return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to resolve FIFO policy")
|
|
}
|
|
}
|
|
|
|
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")
|
|
}
|
|
|
|
adjustmentStock := &entity.AdjustmentStock{
|
|
ProductWarehouseId: productWarehouse.Id,
|
|
TransactionType: transactionType,
|
|
FunctionCode: routeMeta.FunctionCode,
|
|
Price: req.Price,
|
|
GrandTotal: grandTotal,
|
|
}
|
|
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
|
|
|
|
switch routeMeta.Lane {
|
|
case adjustmentLaneStockable:
|
|
fifoNote := fmt.Sprintf("Stock Adjustment %s #%s", routeMeta.FunctionCode, adjustmentStock.AdjNumber)
|
|
result, err := s.FifoSvc.Replenish(ctx, common.StockReplenishRequest{
|
|
StockableKey: fifo.StockableKeyAdjustmentIn,
|
|
StockableID: adjustmentStock.Id,
|
|
ProductWarehouseID: productWarehouse.Id,
|
|
Quantity: qty,
|
|
Note: &fifoNote,
|
|
Tx: tx,
|
|
})
|
|
if err != nil {
|
|
return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to replenish stock via FIFO: %v", err))
|
|
}
|
|
increaseQty = result.AddedQuantity
|
|
case adjustmentLaneUsable:
|
|
if s.FifoStockV2Svc != nil {
|
|
usableLegacyTypeKey := fifo.UsableKeyAdjustmentOut.String()
|
|
if routeMeta.SourceTable == "adjustment_stocks" && strings.TrimSpace(routeMeta.LegacyTypeKey) != "" {
|
|
usableLegacyTypeKey = strings.TrimSpace(routeMeta.LegacyTypeKey)
|
|
}
|
|
|
|
reflowResult, err := s.FifoStockV2Svc.Reflow(ctx, common.FifoStockV2ReflowRequest{
|
|
FlagGroupCode: routeMeta.FlagGroupCode,
|
|
ProductWarehouseID: productWarehouse.Id,
|
|
Usable: common.FifoStockV2Ref{
|
|
ID: adjustmentStock.Id,
|
|
LegacyTypeKey: usableLegacyTypeKey,
|
|
FunctionCode: routeMeta.FunctionCode,
|
|
},
|
|
DesiredQty: qty,
|
|
AllowOverConsume: &allowPending,
|
|
Tx: tx,
|
|
})
|
|
if err != nil {
|
|
return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to consume stock via FIFO v2: %v", err))
|
|
}
|
|
decreaseQty = reflowResult.Allocate.AllocatedQty
|
|
} else {
|
|
result, err := s.FifoSvc.Consume(ctx, common.StockConsumeRequest{
|
|
UsableKey: fifo.UsableKeyAdjustmentOut,
|
|
UsableID: adjustmentStock.Id,
|
|
ProductWarehouseID: productWarehouse.Id,
|
|
Quantity: qty,
|
|
AllowPending: allowPending,
|
|
Tx: tx,
|
|
})
|
|
if err != nil {
|
|
return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Failed to consume stock via FIFO: %v", err))
|
|
}
|
|
decreaseQty = result.UsageQuantity
|
|
}
|
|
default:
|
|
return fiber.NewError(fiber.StatusBadRequest, "Unsupported transaction subtype lane")
|
|
}
|
|
|
|
stockLogs, err := stockLogRepoTX.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")
|
|
}
|
|
|
|
currentStock := 0.0
|
|
if len(stockLogs) > 0 {
|
|
currentStock = stockLogs[0].Stock
|
|
}
|
|
|
|
newLog := &entity.StockLog{
|
|
LoggableType: string(utils.StockLogTypeAdjustment),
|
|
LoggableId: adjustmentStock.Id,
|
|
Notes: note,
|
|
ProductWarehouseId: productWarehouse.Id,
|
|
CreatedBy: actorID,
|
|
Increase: increaseQty,
|
|
Decrease: decreaseQty,
|
|
Stock: currentStock + increaseQty - decreaseQty,
|
|
}
|
|
|
|
if err := stockLogRepoTX.CreateOne(ctx, newLog, nil); 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) 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
|
|
}
|