lti-api/internal/modules/inventory/stock-logs/services/stock-log.service.go

package service

import (
	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
	m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/stock-logs/validations"
	stockLogRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
	"gitlab.com/mbugroup/lti-api.git/internal/utils"

	"github.com/go-playground/validator/v10"
	"github.com/gofiber/fiber/v2"
	"github.com/sirupsen/logrus"
	"gorm.io/gorm"
)

type StockLogService interface {
	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.StockLog, int64, error)
	GetAllForExport(ctx *fiber.Ctx, productWarehouseID uint) ([]entity.StockLog, error)
}

type stockLogService struct {
	Log              *logrus.Logger
	Validate         *validator.Validate
	StockLogRepo     stockLogRepo.StockLogRepository
}

func NewStockLogService(
	stockLogRepo stockLogRepo.StockLogRepository,
	validate *validator.Validate,
) StockLogService {
	return &stockLogService{
		Log:          utils.Log,
		Validate:     validate,
		StockLogRepo: stockLogRepo,
	}
}

func (s *stockLogService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.StockLog, int64, error) {
	if err := s.Validate.Struct(params); err != nil {
		return nil, 0, err
	}

	locationScope, areaScope, err := m.ResolveLocationAreaScopes(c, s.StockLogRepo.DB())
	if err != nil {
		return nil, 0, err
	}

	offset := (params.Page - 1) * params.Limit

	stockLogs, total, err := s.StockLogRepo.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
		db = db.Where("product_warehouse_id = ?", params.ProductWarehouseID)

		if locationScope.Restrict || areaScope.Restrict {
			if (locationScope.Restrict && len(locationScope.IDs) == 0) || (areaScope.Restrict && len(areaScope.IDs) == 0) {
				return db.Where("1 = 0")
			}
			db = db.
				Joins("JOIN product_warehouses pw ON pw.id = stock_logs.product_warehouse_id").
				Joins("JOIN warehouses w ON w.id = pw.warehouse_id")
			if locationScope.Restrict {
				db = db.Where("w.location_id IN ?", locationScope.IDs)
			}
			if areaScope.Restrict {
				db = db.Where("w.area_id IN ?", areaScope.IDs)
			}
		}

		db = db.
			Preload("CreatedUser").
			Order("stock_logs.created_at DESC")

		return db
	})
	if err != nil {
		s.Log.Errorf("Failed to get stock logs: %+v", err)
		return nil, 0, err
	}

	if total == 0 {
		return []entity.StockLog{}, 0, nil
	}

	return stockLogs, total, nil
}

func (s *stockLogService) GetAllForExport(c *fiber.Ctx, productWarehouseID uint) ([]entity.StockLog, error) {
	locationScope, areaScope, err := m.ResolveLocationAreaScopes(c, s.StockLogRepo.DB())
	if err != nil {
		return nil, err
	}

	stockLogs, _, err := s.StockLogRepo.GetAll(c.Context(), 0, -1, func(db *gorm.DB) *gorm.DB {
		db = db.Where("product_warehouse_id = ?", productWarehouseID)

		if locationScope.Restrict || areaScope.Restrict {
			if (locationScope.Restrict && len(locationScope.IDs) == 0) || (areaScope.Restrict && len(areaScope.IDs) == 0) {
				return db.Where("1 = 0")
			}
			db = db.
				Joins("JOIN product_warehouses pw ON pw.id = stock_logs.product_warehouse_id").
				Joins("JOIN warehouses w ON w.id = pw.warehouse_id")
			if locationScope.Restrict {
				db = db.Where("w.location_id IN ?", locationScope.IDs)
			}
			if areaScope.Restrict {
				db = db.Where("w.area_id IN ?", areaScope.IDs)
			}
		}

		db = db.
			Preload("CreatedUser").
			Preload("ProductWarehouse").
			Preload("ProductWarehouse.Warehouse").
			Order("stock_logs.created_at ASC")

		return db
	})
	if err != nil {
		s.Log.Errorf("Failed to get stock logs for export: %+v", err)
		return nil, err
	}

	return stockLogs, nil
}