mirror of
https://gitlab.com/mbugroup/lti-api.git
synced 2026-05-23 14:55:42 +00:00
Merge branch 'fix/BE/US-281-adjustment-recording-egg-mass' into 'development'
[FEAT/BE] fix bug recording and closing counting sapronak See merge request mbugroup/lti-api!296
This commit is contained in:
Hafizh A. Y.
@@ -21,7 +21,6 @@ import (
|
||||
rStockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/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"
|
||||
recordingutil "gitlab.com/mbugroup/lti-api.git/internal/utils/recording"
|
||||
|
||||
"github.com/go-playground/validator/v10"
|
||||
@@ -40,14 +39,6 @@ type RecordingService interface {
|
||||
Approval(ctx *fiber.Ctx, req *validation.Approve) ([]entity.Recording, error)
|
||||
}
|
||||
|
||||
type RecordingFIFOIntegrationService interface {
|
||||
ConsumeRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock, note string, actorID uint) error
|
||||
ReleaseRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock, note string, actorID uint) error
|
||||
}
|
||||
|
||||
var recordingStockUsableKey = fifo.UsableKeyRecordingStock
|
||||
var recordingDepletionUsableKey = fifo.UsableKeyRecordingDepletion
|
||||
|
||||
type recordingService struct {
|
||||
Log *logrus.Logger
|
||||
Validate *validator.Validate
|
||||
@@ -89,21 +80,6 @@ func NewRecordingService(
|
||||
}
|
||||
}
|
||||
|
||||
func NewRecordingFIFOIntegrationService(
|
||||
repo repository.RecordingRepository,
|
||||
productWarehouseRepo rProductWarehouse.ProductWarehouseRepository,
|
||||
fifoSvc commonSvc.FifoService,
|
||||
stockLogRepo rStockLogs.StockLogRepository,
|
||||
) RecordingFIFOIntegrationService {
|
||||
return &recordingService{
|
||||
Log: utils.Log,
|
||||
Repository: repo,
|
||||
ProductWarehouseRepo: productWarehouseRepo,
|
||||
FifoSvc: fifoSvc,
|
||||
StockLogRepo: stockLogRepo,
|
||||
}
|
||||
}
|
||||
|
||||
func (s recordingService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.Recording, int64, error) {
|
||||
if err := s.Validate.Struct(params); err != nil {
|
||||
return nil, 0, err
|
||||
@@ -347,7 +323,12 @@ func (s *recordingService) CreateOne(c *fiber.Ctx, req *validation.Create) (*ent
|
||||
}
|
||||
|
||||
var warehouseDeltas map[uint]float64
|
||||
warehouseDeltas = buildWarehouseDeltas(nil, mappedDepletions, nil, mappedEggs)
|
||||
if s.FifoSvc != nil {
|
||||
// FIFO replenish already adjusts egg warehouse quantities.
|
||||
warehouseDeltas = buildWarehouseDeltas(nil, mappedDepletions, nil, nil)
|
||||
} else {
|
||||
warehouseDeltas = buildWarehouseDeltas(nil, mappedDepletions, nil, mappedEggs)
|
||||
}
|
||||
if err := s.adjustProductWarehouseQuantities(ctx, tx, warehouseDeltas); err != nil {
|
||||
s.Log.Errorf("Failed to adjust product warehouses: %+v", err)
|
||||
return err
|
||||
@@ -529,39 +510,9 @@ func (s recordingService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uin
|
||||
if err := ensureRecordingEggsUnused(existingEggs); err != nil {
|
||||
return err
|
||||
}
|
||||
if s.StockLogRepo != nil {
|
||||
note := fmt.Sprintf("Recording-Edit#%d", recordingEntity.Id)
|
||||
logs := make([]*entity.StockLog, 0, len(existingEggs))
|
||||
for _, egg := range existingEggs {
|
||||
if egg.ProductWarehouseId == 0 || egg.Qty <= 0 {
|
||||
continue
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, egg.ProductWarehouseId, 1)
|
||||
if err != nil {
|
||||
s.Log.Errorf("Failed to get stock logs: %+v", err)
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
latestStockLog := &entity.StockLog{}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog = stockLogs[0]
|
||||
} else {
|
||||
latestStockLog.Stock = 0
|
||||
}
|
||||
logs = append(logs, &entity.StockLog{
|
||||
ProductWarehouseId: egg.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Decrease: float64(egg.Qty),
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: recordingEntity.Id,
|
||||
Notes: note,
|
||||
Stock: latestStockLog.Stock - float64(egg.Qty),
|
||||
})
|
||||
}
|
||||
if len(logs) > 0 {
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateMany(ctx, logs, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
note := fmt.Sprintf("Recording-Edit#%d", recordingEntity.Id)
|
||||
if err := s.logRecordingEggUsage(ctx, tx, existingEggs, note, actorID); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := s.adjustProductWarehouseQuantities(ctx, tx, buildWarehouseDeltas(nil, nil, existingEggs, nil)); err != nil {
|
||||
s.Log.Errorf("Failed to adjust product warehouses for eggs: %+v", err)
|
||||
@@ -818,40 +769,6 @@ func (s recordingService) DeleteOne(c *fiber.Ctx, id uint) error {
|
||||
})
|
||||
}
|
||||
|
||||
func (s *recordingService) logRecordingEggRollback(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
eggs []entity.RecordingEgg,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if len(eggs) == 0 || s.StockLogRepo == nil {
|
||||
return nil
|
||||
}
|
||||
if strings.TrimSpace(note) == "" || actorID == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
for _, egg := range eggs {
|
||||
if egg.ProductWarehouseId == 0 || egg.Qty <= 0 {
|
||||
continue
|
||||
}
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: egg.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Decrease: float64(egg.Qty),
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: egg.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// === Persistence Helpers ===
|
||||
|
||||
func (s *recordingService) ensureProductWarehousesExist(c *fiber.Ctx, stocks []validation.Stock, depletions []validation.Depletion, eggs []validation.Egg) error {
|
||||
@@ -891,381 +808,6 @@ func (s *recordingService) ensureProductWarehousesExist(c *fiber.Ctx, stocks []v
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *recordingService) consumeRecordingStocks(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
stocks []entity.RecordingStock,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if len(stocks) == 0 || s.FifoSvc == nil {
|
||||
return nil
|
||||
}
|
||||
if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
|
||||
return errors.New("stock log repository is not available")
|
||||
}
|
||||
|
||||
for _, stock := range stocks {
|
||||
if stock.Id == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
var desired float64
|
||||
if stock.UsageQty != nil {
|
||||
desired = *stock.UsageQty
|
||||
}
|
||||
var pending float64
|
||||
if stock.PendingQty != nil {
|
||||
pending = *stock.PendingQty
|
||||
}
|
||||
desiredTotal := desired + pending
|
||||
|
||||
result, err := s.FifoSvc.Consume(ctx, commonSvc.StockConsumeRequest{
|
||||
UsableKey: recordingStockUsableKey,
|
||||
UsableID: stock.Id,
|
||||
ProductWarehouseID: stock.ProductWarehouseId,
|
||||
Quantity: desiredTotal,
|
||||
AllowPending: true,
|
||||
Tx: tx,
|
||||
})
|
||||
if err != nil {
|
||||
s.Log.Errorf("Failed to consume FIFO stock for recording stock %d: %+v", stock.Id, err)
|
||||
return err
|
||||
}
|
||||
|
||||
if err := s.Repository.UpdateStockUsage(tx, stock.Id, result.UsageQuantity, result.PendingQuantity); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
logDecrease := result.UsageQuantity
|
||||
if result.PendingQuantity > 0 {
|
||||
logDecrease += result.PendingQuantity
|
||||
}
|
||||
if logDecrease > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: stock.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Decrease: logDecrease,
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: stock.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, stock.ProductWarehouseId, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock -= log.Decrease
|
||||
} else {
|
||||
log.Stock -= log.Decrease
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *recordingService) consumeRecordingDepletions(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
depletions []entity.RecordingDepletion,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if len(depletions) == 0 || s.FifoSvc == nil {
|
||||
return nil
|
||||
}
|
||||
if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
|
||||
return errors.New("stock log repository is not available")
|
||||
}
|
||||
|
||||
for _, depletion := range depletions {
|
||||
if depletion.Id == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
sourceWarehouseID := uint(0)
|
||||
if depletion.SourceProductWarehouseId != nil {
|
||||
sourceWarehouseID = *depletion.SourceProductWarehouseId
|
||||
}
|
||||
if sourceWarehouseID == 0 {
|
||||
return fiber.NewError(fiber.StatusBadRequest, "Source product warehouse tidak ditemukan untuk depletion")
|
||||
}
|
||||
|
||||
desired := depletion.Qty + depletion.PendingQty
|
||||
result, err := s.FifoSvc.Consume(ctx, commonSvc.StockConsumeRequest{
|
||||
UsableKey: recordingDepletionUsableKey,
|
||||
UsableID: depletion.Id,
|
||||
ProductWarehouseID: sourceWarehouseID,
|
||||
Quantity: desired,
|
||||
AllowPending: false,
|
||||
Tx: tx,
|
||||
})
|
||||
if err != nil {
|
||||
s.Log.Errorf("Failed to consume FIFO stock for recording depletion %d: %+v", depletion.Id, err)
|
||||
return err
|
||||
}
|
||||
|
||||
if err := s.Repository.UpdateDepletionPending(tx, depletion.Id, result.PendingQuantity); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
logDecrease := result.UsageQuantity
|
||||
if result.PendingQuantity > 0 {
|
||||
logDecrease += result.PendingQuantity
|
||||
}
|
||||
if logDecrease > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: sourceWarehouseID,
|
||||
CreatedBy: actorID,
|
||||
Decrease: logDecrease,
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: depletion.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, sourceWarehouseID, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock -= log.Decrease
|
||||
} else {
|
||||
log.Stock -= log.Decrease
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
destDelta := depletion.Qty + depletion.PendingQty
|
||||
if depletion.ProductWarehouseId != 0 && destDelta > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
if depletion.ProductWarehouseId == sourceWarehouseID {
|
||||
continue
|
||||
}
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: depletion.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Increase: destDelta,
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: depletion.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, depletion.ProductWarehouseId, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock += log.Increase
|
||||
} else {
|
||||
log.Stock += log.Increase
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *recordingService) ConsumeRecordingStocks(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
stocks []entity.RecordingStock,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
return s.consumeRecordingStocks(ctx, tx, stocks, note, actorID)
|
||||
}
|
||||
|
||||
func (s *recordingService) releaseRecordingStocks(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
stocks []entity.RecordingStock,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if len(stocks) == 0 || s.FifoSvc == nil {
|
||||
return nil
|
||||
}
|
||||
if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
|
||||
return errors.New("stock log repository is not available")
|
||||
}
|
||||
|
||||
for _, stock := range stocks {
|
||||
if stock.Id == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
if err := s.FifoSvc.ReleaseUsage(ctx, commonSvc.StockReleaseRequest{
|
||||
UsableKey: recordingStockUsableKey,
|
||||
UsableID: stock.Id,
|
||||
Tx: tx,
|
||||
}); err != nil {
|
||||
s.Log.Errorf("Failed to release FIFO stock for recording stock %d: %+v", stock.Id, err)
|
||||
return err
|
||||
}
|
||||
|
||||
if err := s.Repository.UpdateStockUsage(tx, stock.Id, 0, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if stock.UsageQty != nil && *stock.UsageQty > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: stock.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Increase: *stock.UsageQty,
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: stock.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, stock.ProductWarehouseId, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock += log.Increase
|
||||
} else {
|
||||
log.Stock += log.Increase
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *recordingService) releaseRecordingDepletions(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
depletions []entity.RecordingDepletion,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if len(depletions) == 0 || s.FifoSvc == nil {
|
||||
return nil
|
||||
}
|
||||
if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
|
||||
return errors.New("stock log repository is not available")
|
||||
}
|
||||
|
||||
for _, depletion := range depletions {
|
||||
if depletion.Id == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
sourceWarehouseID := uint(0)
|
||||
if depletion.SourceProductWarehouseId != nil {
|
||||
sourceWarehouseID = *depletion.SourceProductWarehouseId
|
||||
}
|
||||
if sourceWarehouseID == 0 {
|
||||
return fiber.NewError(fiber.StatusBadRequest, "Source product warehouse tidak ditemukan untuk depletion")
|
||||
}
|
||||
|
||||
if err := s.FifoSvc.ReleaseUsage(ctx, commonSvc.StockReleaseRequest{
|
||||
UsableKey: recordingDepletionUsableKey,
|
||||
UsableID: depletion.Id,
|
||||
Tx: tx,
|
||||
}); err != nil {
|
||||
s.Log.Errorf("Failed to release FIFO stock for recording depletion %d: %+v", depletion.Id, err)
|
||||
return err
|
||||
}
|
||||
|
||||
if err := s.Repository.UpdateDepletionPending(tx, depletion.Id, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
logIncrease := depletion.Qty
|
||||
if depletion.PendingQty > 0 {
|
||||
logIncrease += depletion.PendingQty
|
||||
}
|
||||
if logIncrease > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: sourceWarehouseID,
|
||||
CreatedBy: actorID,
|
||||
Increase: logIncrease,
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: depletion.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, sourceWarehouseID, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock += log.Increase
|
||||
} else {
|
||||
log.Stock += log.Increase
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
destDelta := depletion.Qty + depletion.PendingQty
|
||||
if depletion.ProductWarehouseId != 0 && destDelta > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
if depletion.ProductWarehouseId == sourceWarehouseID {
|
||||
continue
|
||||
}
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: depletion.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Decrease: destDelta,
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: depletion.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, depletion.ProductWarehouseId, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock -= log.Decrease
|
||||
} else {
|
||||
log.Stock -= log.Decrease
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *recordingService) ReleaseRecordingStocks(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
stocks []entity.RecordingStock,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
return s.releaseRecordingStocks(ctx, tx, stocks, note, actorID)
|
||||
}
|
||||
|
||||
func (s *recordingService) resolvePopulationWarehouseID(ctx context.Context, projectFlockKandangID uint) (uint, error) {
|
||||
if projectFlockKandangID == 0 {
|
||||
return 0, fiber.NewError(fiber.StatusBadRequest, "Project flock kandang tidak valid")
|
||||
@@ -1356,212 +898,6 @@ func (s *recordingService) adjustProductWarehouseQuantities(ctx context.Context,
|
||||
return s.ProductWarehouseRepo.AdjustQuantities(ctx, deltas, func(*gorm.DB) *gorm.DB { return tx })
|
||||
}
|
||||
|
||||
func (s *recordingService) replenishRecordingEggs(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
eggs []entity.RecordingEgg,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if len(eggs) == 0 || s.FifoSvc == nil {
|
||||
return nil
|
||||
}
|
||||
if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
|
||||
return errors.New("stock log repository is not available")
|
||||
}
|
||||
|
||||
for _, egg := range eggs {
|
||||
if egg.Id == 0 || egg.ProductWarehouseId == 0 || egg.Qty <= 0 {
|
||||
continue
|
||||
}
|
||||
if _, err := s.FifoSvc.Replenish(ctx, commonSvc.StockReplenishRequest{
|
||||
StockableKey: fifo.StockableKeyRecordingEgg,
|
||||
StockableID: egg.Id,
|
||||
ProductWarehouseID: egg.ProductWarehouseId,
|
||||
Quantity: float64(egg.Qty),
|
||||
Tx: tx,
|
||||
}); err != nil {
|
||||
s.Log.Errorf("Failed to replenish FIFO stock for recording egg %d: %+v", egg.Id, err)
|
||||
return err
|
||||
}
|
||||
|
||||
if strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: egg.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Increase: float64(egg.Qty),
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: egg.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, egg.ProductWarehouseId, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock += log.Increase
|
||||
} else {
|
||||
log.Stock += log.Increase
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
type desiredStock struct {
|
||||
Usage float64
|
||||
Pending float64
|
||||
}
|
||||
|
||||
type desiredDepletion struct {
|
||||
Qty float64
|
||||
Pending float64
|
||||
}
|
||||
|
||||
func resetStockQuantitiesForFIFO(stocks []entity.RecordingStock, enabled bool) []desiredStock {
|
||||
desired := make([]desiredStock, len(stocks))
|
||||
for i := range stocks {
|
||||
if stocks[i].UsageQty != nil {
|
||||
desired[i].Usage = *stocks[i].UsageQty
|
||||
}
|
||||
if stocks[i].PendingQty != nil {
|
||||
desired[i].Pending = *stocks[i].PendingQty
|
||||
}
|
||||
if !enabled {
|
||||
continue
|
||||
}
|
||||
zero := 0.0
|
||||
stocks[i].UsageQty = &zero
|
||||
stocks[i].PendingQty = &zero
|
||||
}
|
||||
return desired
|
||||
}
|
||||
|
||||
func applyStockDesiredQuantities(stocks []entity.RecordingStock, desired []desiredStock, enabled bool) {
|
||||
if !enabled {
|
||||
return
|
||||
}
|
||||
for i := range stocks {
|
||||
if i >= len(desired) {
|
||||
break
|
||||
}
|
||||
usage := desired[i].Usage
|
||||
pending := desired[i].Pending
|
||||
stocks[i].UsageQty = &usage
|
||||
stocks[i].PendingQty = &pending
|
||||
}
|
||||
}
|
||||
|
||||
func resetDepletionQuantitiesForFIFO(depletions []entity.RecordingDepletion, enabled bool) []desiredDepletion {
|
||||
desired := make([]desiredDepletion, len(depletions))
|
||||
for i := range depletions {
|
||||
desired[i].Qty = depletions[i].Qty
|
||||
desired[i].Pending = depletions[i].PendingQty
|
||||
if !enabled {
|
||||
continue
|
||||
}
|
||||
depletions[i].Qty = 0
|
||||
depletions[i].PendingQty = 0
|
||||
}
|
||||
return desired
|
||||
}
|
||||
|
||||
func applyDepletionDesiredQuantities(depletions []entity.RecordingDepletion, desired []desiredDepletion, enabled bool) {
|
||||
if !enabled {
|
||||
return
|
||||
}
|
||||
for i := range depletions {
|
||||
if i >= len(desired) {
|
||||
break
|
||||
}
|
||||
depletions[i].Qty = desired[i].Qty
|
||||
depletions[i].PendingQty = desired[i].Pending
|
||||
}
|
||||
}
|
||||
|
||||
func (s *recordingService) syncRecordingStocks(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
recordingID uint,
|
||||
existing []entity.RecordingStock,
|
||||
incoming []validation.Stock,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if s.FifoSvc == nil {
|
||||
if err := s.Repository.DeleteStocks(tx, recordingID); err != nil {
|
||||
return err
|
||||
}
|
||||
mapped := recordingutil.MapStocks(recordingID, incoming)
|
||||
return s.Repository.CreateStocks(tx, mapped)
|
||||
}
|
||||
|
||||
existingByWarehouse := make(map[uint][]entity.RecordingStock)
|
||||
for _, stock := range existing {
|
||||
existingByWarehouse[stock.ProductWarehouseId] = append(existingByWarehouse[stock.ProductWarehouseId], stock)
|
||||
}
|
||||
|
||||
stocksToConsume := make([]entity.RecordingStock, 0, len(incoming))
|
||||
for _, item := range incoming {
|
||||
list := existingByWarehouse[item.ProductWarehouseId]
|
||||
var stock entity.RecordingStock
|
||||
if len(list) > 0 {
|
||||
stock = list[0]
|
||||
existingByWarehouse[item.ProductWarehouseId] = list[1:]
|
||||
} else {
|
||||
zero := 0.0
|
||||
stock = entity.RecordingStock{
|
||||
RecordingId: recordingID,
|
||||
ProductWarehouseId: item.ProductWarehouseId,
|
||||
UsageQty: &zero,
|
||||
PendingQty: &zero,
|
||||
}
|
||||
if err := tx.Create(&stock).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
desired := item.Qty
|
||||
stock.UsageQty = &desired
|
||||
zero := 0.0
|
||||
stock.PendingQty = &zero
|
||||
stocksToConsume = append(stocksToConsume, stock)
|
||||
}
|
||||
|
||||
var leftovers []entity.RecordingStock
|
||||
for _, list := range existingByWarehouse {
|
||||
leftovers = append(leftovers, list...)
|
||||
}
|
||||
if len(leftovers) > 0 {
|
||||
if err := s.releaseRecordingStocks(ctx, tx, leftovers, note, actorID); err != nil {
|
||||
return err
|
||||
}
|
||||
ids := make([]uint, 0, len(leftovers))
|
||||
for _, stock := range leftovers {
|
||||
if stock.Id != 0 {
|
||||
ids = append(ids, stock.Id)
|
||||
}
|
||||
}
|
||||
if len(ids) > 0 {
|
||||
if err := tx.Where("id IN ?", ids).Delete(&entity.RecordingStock{}).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if len(stocksToConsume) == 0 {
|
||||
return nil
|
||||
}
|
||||
return s.consumeRecordingStocks(ctx, tx, stocksToConsume, note, actorID)
|
||||
}
|
||||
|
||||
type eggTotals struct {
|
||||
Qty int
|
||||
Weight float64
|
||||
@@ -1999,16 +1335,17 @@ func (s *recordingService) attachProductionStandard(ctx context.Context, item *e
|
||||
|
||||
var standard productionStandardValues
|
||||
var standardFcr *float64
|
||||
if category == string(utils.ProjectFlockCategoryLaying) {
|
||||
detail, err := standardDetailRepo.GetByStandardIDAndWeek(ctx, standardID, week)
|
||||
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
return err
|
||||
}
|
||||
if detail != nil {
|
||||
standard.HenDay = detail.TargetHenDayProduction
|
||||
standard.HenHouse = detail.TargetHenHouseProduction
|
||||
standard.EggWeight = detail.TargetEggWeight
|
||||
standard.EggMass = detail.TargetEggMass
|
||||
detail, err := standardDetailRepo.GetByStandardIDAndWeek(ctx, standardID, week)
|
||||
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
|
||||
return err
|
||||
}
|
||||
if detail != nil {
|
||||
standard.HenDay = detail.TargetHenDayProduction
|
||||
standard.HenHouse = detail.TargetHenHouseProduction
|
||||
standard.EggWeight = detail.TargetEggWeight
|
||||
standard.EggMass = detail.TargetEggMass
|
||||
if detail.StandardFCR != nil {
|
||||
standardFcr = detail.StandardFCR
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2019,21 +1356,6 @@ func (s *recordingService) attachProductionStandard(ctx context.Context, item *e
|
||||
if growthDetail != nil {
|
||||
standard.FeedIntake = growthDetail.FeedIntake
|
||||
standard.MaxDepletion = growthDetail.MaxDepletion
|
||||
if category == string(utils.ProjectFlockCategoryLaying) && growthDetail.TargetMeanBw != nil && item.ProjectFlockKandang.ProjectFlock.FcrId > 0 {
|
||||
targetWeight := *growthDetail.TargetMeanBw
|
||||
if targetWeight > 10 {
|
||||
targetWeight = targetWeight / 1000
|
||||
}
|
||||
if targetWeight > 0 {
|
||||
fcrStd, ok, err := s.Repository.GetFcrStandardNumber(db, item.ProjectFlockKandang.ProjectFlock.FcrId, targetWeight)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if ok {
|
||||
standardFcr = &fcrStd
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
item.StandardHenDay = standard.HenDay
|
||||
|
||||
@@ -0,0 +1,703 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"strings"
|
||||
|
||||
commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
|
||||
entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
|
||||
rProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
|
||||
repository "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/repositories"
|
||||
validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/validations"
|
||||
rStockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
|
||||
"gitlab.com/mbugroup/lti-api.git/internal/utils"
|
||||
"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
|
||||
recordingutil "gitlab.com/mbugroup/lti-api.git/internal/utils/recording"
|
||||
|
||||
"github.com/gofiber/fiber/v2"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
type RecordingFIFOIntegrationService interface {
|
||||
ConsumeRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock, note string, actorID uint) error
|
||||
ReleaseRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock, note string, actorID uint) error
|
||||
}
|
||||
|
||||
var recordingStockUsableKey = fifo.UsableKeyRecordingStock
|
||||
var recordingDepletionUsableKey = fifo.UsableKeyRecordingDepletion
|
||||
|
||||
func NewRecordingFIFOIntegrationService(
|
||||
repo repository.RecordingRepository,
|
||||
productWarehouseRepo rProductWarehouse.ProductWarehouseRepository,
|
||||
fifoSvc commonSvc.FifoService,
|
||||
stockLogRepo rStockLogs.StockLogRepository,
|
||||
) RecordingFIFOIntegrationService {
|
||||
return &recordingService{
|
||||
Log: utils.Log,
|
||||
Repository: repo,
|
||||
ProductWarehouseRepo: productWarehouseRepo,
|
||||
FifoSvc: fifoSvc,
|
||||
StockLogRepo: stockLogRepo,
|
||||
}
|
||||
}
|
||||
|
||||
func (s *recordingService) consumeRecordingStocks(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
stocks []entity.RecordingStock,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if len(stocks) == 0 || s.FifoSvc == nil {
|
||||
return nil
|
||||
}
|
||||
if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
|
||||
return errors.New("stock log repository is not available")
|
||||
}
|
||||
|
||||
for _, stock := range stocks {
|
||||
if stock.Id == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
var desired float64
|
||||
if stock.UsageQty != nil {
|
||||
desired = *stock.UsageQty
|
||||
}
|
||||
var pending float64
|
||||
if stock.PendingQty != nil {
|
||||
pending = *stock.PendingQty
|
||||
}
|
||||
desiredTotal := desired + pending
|
||||
|
||||
result, err := s.FifoSvc.Consume(ctx, commonSvc.StockConsumeRequest{
|
||||
UsableKey: recordingStockUsableKey,
|
||||
UsableID: stock.Id,
|
||||
ProductWarehouseID: stock.ProductWarehouseId,
|
||||
Quantity: desiredTotal,
|
||||
AllowPending: true,
|
||||
Tx: tx,
|
||||
})
|
||||
if err != nil {
|
||||
s.Log.Errorf("Failed to consume FIFO stock for recording stock %d: %+v", stock.Id, err)
|
||||
return err
|
||||
}
|
||||
|
||||
if err := s.Repository.UpdateStockUsage(tx, stock.Id, result.UsageQuantity, result.PendingQuantity); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
logDecrease := result.UsageQuantity
|
||||
if result.PendingQuantity > 0 {
|
||||
logDecrease += result.PendingQuantity
|
||||
}
|
||||
if logDecrease > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: stock.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Decrease: logDecrease,
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: stock.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, stock.ProductWarehouseId, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock -= log.Decrease
|
||||
} else {
|
||||
log.Stock -= log.Decrease
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *recordingService) consumeRecordingDepletions(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
depletions []entity.RecordingDepletion,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if len(depletions) == 0 || s.FifoSvc == nil {
|
||||
return nil
|
||||
}
|
||||
if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
|
||||
return errors.New("stock log repository is not available")
|
||||
}
|
||||
|
||||
for _, depletion := range depletions {
|
||||
if depletion.Id == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
sourceWarehouseID := uint(0)
|
||||
if depletion.SourceProductWarehouseId != nil {
|
||||
sourceWarehouseID = *depletion.SourceProductWarehouseId
|
||||
}
|
||||
if sourceWarehouseID == 0 {
|
||||
return fiber.NewError(fiber.StatusBadRequest, "Source product warehouse tidak ditemukan untuk depletion")
|
||||
}
|
||||
|
||||
desired := depletion.Qty + depletion.PendingQty
|
||||
result, err := s.FifoSvc.Consume(ctx, commonSvc.StockConsumeRequest{
|
||||
UsableKey: recordingDepletionUsableKey,
|
||||
UsableID: depletion.Id,
|
||||
ProductWarehouseID: sourceWarehouseID,
|
||||
Quantity: desired,
|
||||
AllowPending: false,
|
||||
Tx: tx,
|
||||
})
|
||||
if err != nil {
|
||||
s.Log.Errorf("Failed to consume FIFO stock for recording depletion %d: %+v", depletion.Id, err)
|
||||
return err
|
||||
}
|
||||
|
||||
if err := s.Repository.UpdateDepletionPending(tx, depletion.Id, result.PendingQuantity); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
logDecrease := result.UsageQuantity
|
||||
if result.PendingQuantity > 0 {
|
||||
logDecrease += result.PendingQuantity
|
||||
}
|
||||
if logDecrease > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: sourceWarehouseID,
|
||||
CreatedBy: actorID,
|
||||
Decrease: logDecrease,
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: depletion.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, sourceWarehouseID, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock -= log.Decrease
|
||||
} else {
|
||||
log.Stock -= log.Decrease
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
destDelta := depletion.Qty + depletion.PendingQty
|
||||
if depletion.ProductWarehouseId != 0 && destDelta > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
if depletion.ProductWarehouseId == sourceWarehouseID {
|
||||
continue
|
||||
}
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: depletion.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Increase: destDelta,
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: depletion.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, depletion.ProductWarehouseId, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock += log.Increase
|
||||
} else {
|
||||
log.Stock += log.Increase
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *recordingService) ConsumeRecordingStocks(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
stocks []entity.RecordingStock,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
return s.consumeRecordingStocks(ctx, tx, stocks, note, actorID)
|
||||
}
|
||||
|
||||
func (s *recordingService) releaseRecordingStocks(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
stocks []entity.RecordingStock,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if len(stocks) == 0 || s.FifoSvc == nil {
|
||||
return nil
|
||||
}
|
||||
if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
|
||||
return errors.New("stock log repository is not available")
|
||||
}
|
||||
|
||||
for _, stock := range stocks {
|
||||
if stock.Id == 0 {
|
||||
continue
|
||||
}
|
||||
if err := s.FifoSvc.ReleaseUsage(ctx, commonSvc.StockReleaseRequest{
|
||||
UsableKey: recordingStockUsableKey,
|
||||
UsableID: stock.Id,
|
||||
Tx: tx,
|
||||
}); err != nil {
|
||||
s.Log.Errorf("Failed to release FIFO stock for recording stock %d: %+v", stock.Id, err)
|
||||
return err
|
||||
}
|
||||
|
||||
if err := s.Repository.UpdateStockUsage(tx, stock.Id, 0, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if stock.UsageQty != nil && *stock.UsageQty > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: stock.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Increase: *stock.UsageQty,
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: stock.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, stock.ProductWarehouseId, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock += log.Increase
|
||||
} else {
|
||||
log.Stock += log.Increase
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *recordingService) releaseRecordingDepletions(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
depletions []entity.RecordingDepletion,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if len(depletions) == 0 || s.FifoSvc == nil {
|
||||
return nil
|
||||
}
|
||||
if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
|
||||
return errors.New("stock log repository is not available")
|
||||
}
|
||||
|
||||
for _, depletion := range depletions {
|
||||
if depletion.Id == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
sourceWarehouseID := uint(0)
|
||||
if depletion.SourceProductWarehouseId != nil {
|
||||
sourceWarehouseID = *depletion.SourceProductWarehouseId
|
||||
}
|
||||
if sourceWarehouseID == 0 {
|
||||
return fiber.NewError(fiber.StatusBadRequest, "Source product warehouse tidak ditemukan untuk depletion")
|
||||
}
|
||||
if err := s.FifoSvc.ReleaseUsage(ctx, commonSvc.StockReleaseRequest{
|
||||
UsableKey: recordingDepletionUsableKey,
|
||||
UsableID: depletion.Id,
|
||||
Tx: tx,
|
||||
}); err != nil {
|
||||
s.Log.Errorf("Failed to release FIFO stock for recording depletion %d: %+v", depletion.Id, err)
|
||||
return err
|
||||
}
|
||||
|
||||
if err := s.Repository.UpdateDepletionPending(tx, depletion.Id, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
logIncrease := depletion.Qty
|
||||
if depletion.PendingQty > 0 {
|
||||
logIncrease += depletion.PendingQty
|
||||
}
|
||||
if logIncrease > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: sourceWarehouseID,
|
||||
CreatedBy: actorID,
|
||||
Increase: logIncrease,
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: depletion.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, sourceWarehouseID, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock += log.Increase
|
||||
} else {
|
||||
log.Stock += log.Increase
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
destDelta := depletion.Qty + depletion.PendingQty
|
||||
if depletion.ProductWarehouseId != 0 && destDelta > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
if depletion.ProductWarehouseId == sourceWarehouseID {
|
||||
continue
|
||||
}
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: depletion.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Decrease: destDelta,
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: depletion.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, depletion.ProductWarehouseId, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock -= log.Decrease
|
||||
} else {
|
||||
log.Stock -= log.Decrease
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *recordingService) ReleaseRecordingStocks(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
stocks []entity.RecordingStock,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
return s.releaseRecordingStocks(ctx, tx, stocks, note, actorID)
|
||||
}
|
||||
|
||||
func (s *recordingService) logRecordingEggUsage(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
eggs []entity.RecordingEgg,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if len(eggs) == 0 || s.StockLogRepo == nil {
|
||||
return nil
|
||||
}
|
||||
if strings.TrimSpace(note) == "" || actorID == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
logs := make([]*entity.StockLog, 0, len(eggs))
|
||||
for _, egg := range eggs {
|
||||
if egg.ProductWarehouseId == 0 || egg.Qty <= 0 {
|
||||
continue
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, egg.ProductWarehouseId, 1)
|
||||
if err != nil {
|
||||
s.Log.Errorf("Failed to get stock logs: %+v", err)
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
latestStockLog := &entity.StockLog{}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog = stockLogs[0]
|
||||
} else {
|
||||
latestStockLog.Stock = 0
|
||||
}
|
||||
logs = append(logs, &entity.StockLog{
|
||||
ProductWarehouseId: egg.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Decrease: float64(egg.Qty),
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: egg.RecordingId,
|
||||
Notes: note,
|
||||
Stock: latestStockLog.Stock - float64(egg.Qty),
|
||||
})
|
||||
}
|
||||
if len(logs) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
return s.StockLogRepo.WithTx(tx).CreateMany(ctx, logs, nil)
|
||||
}
|
||||
|
||||
func (s *recordingService) logRecordingEggRollback(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
eggs []entity.RecordingEgg,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if len(eggs) == 0 || s.StockLogRepo == nil {
|
||||
return nil
|
||||
}
|
||||
if strings.TrimSpace(note) == "" || actorID == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
for _, egg := range eggs {
|
||||
if egg.ProductWarehouseId == 0 || egg.Qty <= 0 {
|
||||
continue
|
||||
}
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: egg.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Decrease: float64(egg.Qty),
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: egg.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *recordingService) replenishRecordingEggs(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
eggs []entity.RecordingEgg,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if len(eggs) == 0 || s.FifoSvc == nil {
|
||||
return nil
|
||||
}
|
||||
if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
|
||||
return errors.New("stock log repository is not available")
|
||||
}
|
||||
|
||||
for _, egg := range eggs {
|
||||
if egg.Id == 0 || egg.ProductWarehouseId == 0 || egg.Qty <= 0 {
|
||||
continue
|
||||
}
|
||||
if _, err := s.FifoSvc.Replenish(ctx, commonSvc.StockReplenishRequest{
|
||||
StockableKey: fifo.StockableKeyRecordingEgg,
|
||||
StockableID: egg.Id,
|
||||
ProductWarehouseID: egg.ProductWarehouseId,
|
||||
Quantity: float64(egg.Qty),
|
||||
Tx: tx,
|
||||
}); err != nil {
|
||||
s.Log.Errorf("Failed to replenish FIFO stock for recording egg %d: %+v", egg.Id, err)
|
||||
return err
|
||||
}
|
||||
|
||||
if strings.TrimSpace(note) != "" && actorID != 0 {
|
||||
log := &entity.StockLog{
|
||||
ProductWarehouseId: egg.ProductWarehouseId,
|
||||
CreatedBy: actorID,
|
||||
Increase: float64(egg.Qty),
|
||||
LoggableType: string(utils.StockLogTypeRecording),
|
||||
LoggableId: egg.RecordingId,
|
||||
Notes: note,
|
||||
}
|
||||
stockLogs, err := s.StockLogRepo.GetByProductWarehouse(ctx, egg.ProductWarehouseId, 1)
|
||||
if err != nil {
|
||||
return fiber.NewError(fiber.StatusInternalServerError, "Failed to get stock logs")
|
||||
}
|
||||
if len(stockLogs) > 0 {
|
||||
latestStockLog := stockLogs[0]
|
||||
log.Stock = latestStockLog.Stock
|
||||
log.Stock += log.Increase
|
||||
} else {
|
||||
log.Stock += log.Increase
|
||||
}
|
||||
|
||||
if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
type desiredStock struct {
|
||||
Usage float64
|
||||
Pending float64
|
||||
}
|
||||
|
||||
type desiredDepletion struct {
|
||||
Qty float64
|
||||
Pending float64
|
||||
}
|
||||
|
||||
func resetStockQuantitiesForFIFO(stocks []entity.RecordingStock, enabled bool) []desiredStock {
|
||||
desired := make([]desiredStock, len(stocks))
|
||||
for i := range stocks {
|
||||
if stocks[i].UsageQty != nil {
|
||||
desired[i].Usage = *stocks[i].UsageQty
|
||||
}
|
||||
if stocks[i].PendingQty != nil {
|
||||
desired[i].Pending = *stocks[i].PendingQty
|
||||
}
|
||||
if !enabled {
|
||||
continue
|
||||
}
|
||||
zero := 0.0
|
||||
stocks[i].UsageQty = &zero
|
||||
stocks[i].PendingQty = &zero
|
||||
}
|
||||
return desired
|
||||
}
|
||||
|
||||
func applyStockDesiredQuantities(stocks []entity.RecordingStock, desired []desiredStock, enabled bool) {
|
||||
if !enabled {
|
||||
return
|
||||
}
|
||||
for i := range stocks {
|
||||
if i >= len(desired) {
|
||||
break
|
||||
}
|
||||
usage := desired[i].Usage
|
||||
pending := desired[i].Pending
|
||||
stocks[i].UsageQty = &usage
|
||||
stocks[i].PendingQty = &pending
|
||||
}
|
||||
}
|
||||
|
||||
func resetDepletionQuantitiesForFIFO(depletions []entity.RecordingDepletion, enabled bool) []desiredDepletion {
|
||||
desired := make([]desiredDepletion, len(depletions))
|
||||
for i := range depletions {
|
||||
desired[i].Qty = depletions[i].Qty
|
||||
desired[i].Pending = depletions[i].PendingQty
|
||||
if !enabled {
|
||||
continue
|
||||
}
|
||||
depletions[i].Qty = 0
|
||||
depletions[i].PendingQty = 0
|
||||
}
|
||||
return desired
|
||||
}
|
||||
|
||||
func applyDepletionDesiredQuantities(depletions []entity.RecordingDepletion, desired []desiredDepletion, enabled bool) {
|
||||
if !enabled {
|
||||
return
|
||||
}
|
||||
for i := range depletions {
|
||||
if i >= len(desired) {
|
||||
break
|
||||
}
|
||||
depletions[i].Qty = desired[i].Qty
|
||||
depletions[i].PendingQty = desired[i].Pending
|
||||
}
|
||||
}
|
||||
|
||||
func (s *recordingService) syncRecordingStocks(
|
||||
ctx context.Context,
|
||||
tx *gorm.DB,
|
||||
recordingID uint,
|
||||
existing []entity.RecordingStock,
|
||||
incoming []validation.Stock,
|
||||
note string,
|
||||
actorID uint,
|
||||
) error {
|
||||
if s.FifoSvc == nil {
|
||||
if err := s.Repository.DeleteStocks(tx, recordingID); err != nil {
|
||||
return err
|
||||
}
|
||||
mapped := recordingutil.MapStocks(recordingID, incoming)
|
||||
return s.Repository.CreateStocks(tx, mapped)
|
||||
}
|
||||
|
||||
existingByWarehouse := make(map[uint][]entity.RecordingStock)
|
||||
for _, stock := range existing {
|
||||
existingByWarehouse[stock.ProductWarehouseId] = append(existingByWarehouse[stock.ProductWarehouseId], stock)
|
||||
}
|
||||
|
||||
stocksToConsume := make([]entity.RecordingStock, 0, len(incoming))
|
||||
for _, item := range incoming {
|
||||
list := existingByWarehouse[item.ProductWarehouseId]
|
||||
var stock entity.RecordingStock
|
||||
if len(list) > 0 {
|
||||
stock = list[0]
|
||||
existingByWarehouse[item.ProductWarehouseId] = list[1:]
|
||||
} else {
|
||||
zero := 0.0
|
||||
stock = entity.RecordingStock{
|
||||
RecordingId: recordingID,
|
||||
ProductWarehouseId: item.ProductWarehouseId,
|
||||
UsageQty: &zero,
|
||||
PendingQty: &zero,
|
||||
}
|
||||
if err := tx.Create(&stock).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
desired := item.Qty
|
||||
stock.UsageQty = &desired
|
||||
zero := 0.0
|
||||
stock.PendingQty = &zero
|
||||
stocksToConsume = append(stocksToConsume, stock)
|
||||
}
|
||||
|
||||
var leftovers []entity.RecordingStock
|
||||
for _, list := range existingByWarehouse {
|
||||
leftovers = append(leftovers, list...)
|
||||
}
|
||||
if len(leftovers) > 0 {
|
||||
if err := s.releaseRecordingStocks(ctx, tx, leftovers, note, actorID); err != nil {
|
||||
return err
|
||||
}
|
||||
ids := make([]uint, 0, len(leftovers))
|
||||
for _, stock := range leftovers {
|
||||
if stock.Id != 0 {
|
||||
ids = append(ids, stock.Id)
|
||||
}
|
||||
}
|
||||
if len(ids) > 0 {
|
||||
if err := tx.Where("id IN ?", ids).Delete(&entity.RecordingStock{}).Error; err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if len(stocksToConsume) == 0 {
|
||||
return nil
|
||||
}
|
||||
return s.consumeRecordingStocks(ctx, tx, stocksToConsume, note, actorID)
|
||||
}
|
||||
Reference in New Issue
Block a user