wms-be/modules/aisle/service/aisle_service.go

package service

import (
	"context"

	"github.com/Caknoooo/go-gin-clean-starter/database/entities"
	"github.com/Caknoooo/go-gin-clean-starter/modules/aisle/dto"
	"github.com/Caknoooo/go-gin-clean-starter/modules/aisle/query"
	"github.com/Caknoooo/go-gin-clean-starter/modules/aisle/repository"
	"github.com/google/uuid"
	"gorm.io/gorm"
)

type AisleService interface {
	Create(ctx context.Context, req dto.AisleCreateRequest) (dto.AisleResponse, error)
	GetById(ctx context.Context, aisleId string) (dto.AisleResponse, error)
	GetAll(ctx context.Context, filter query.AisleFilter) ([]dto.AisleResponse, int64, error)
	Update(ctx context.Context, req dto.AisleUpdateRequest, aisleId string) (dto.AisleResponse, error)
	Delete(ctx context.Context, aisleId string) error
}

type aisleService struct {
	db        *gorm.DB
	aisleRepo repository.AisleRepository
}

func toAisleResponse(e entities.MAisleEntity) dto.AisleResponse {
	return dto.AisleResponse{
		ID:          e.ID.String(),
		Code:        e.Code,
		Name:        e.Name,
		IsleX:       e.IsleX,
		BinY:        e.BinY,
		LevelZ:      e.LevelZ,
		Dimension:   e.Dimension,
		Weight:      e.Weight,
		QrCodeAisle: e.QrCodeAisle,
		IsActive:    e.IsActive,
		ZoneID:      e.ZoneID.String(),
		DimUomID:    e.DimUomID.String(),
		WeightUomID: e.WeightUomID.String(),
		ClientID:    e.ClientID.String(),
	}
}

func (s *aisleService) Create(ctx context.Context, req dto.AisleCreateRequest) (dto.AisleResponse, error) {
	tx := s.db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	zoneUUID, err := uuid.Parse(req.ZoneID)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	dimUomUUID, err := uuid.Parse(req.DimUomID)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	weightUomUUID, err := uuid.Parse(req.WeightUomID)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	clientUUID, err := uuid.Parse(req.ClientID)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	aisle := entities.MAisleEntity{
		Code:        req.Code,
		Name:        req.Name,
		IsleX:       req.IsleX,
		BinY:        req.BinY,
		LevelZ:      req.LevelZ,
		Dimension:   req.Dimension,
		Weight:      req.Weight,
		QrCodeAisle: req.QrCodeAisle,
		IsActive:    req.IsActive,
		ZoneID:      zoneUUID,
		DimUomID:    dimUomUUID,
		WeightUomID: weightUomUUID,
		ClientID:    clientUUID,
	}
	created, err := s.aisleRepo.Create(ctx, tx, aisle)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	tx.Commit()
	result, err := s.aisleRepo.GetById(ctx, nil, created.ID.String())
	if err != nil {
		return dto.AisleResponse{}, err
	}
	return toAisleResponse(result), nil
}

func (s *aisleService) GetById(ctx context.Context, aisleId string) (dto.AisleResponse, error) {
	aisle, err := s.aisleRepo.GetById(ctx, nil, aisleId)
	if err != nil {
		return dto.AisleResponse{}, err
	}
	return toAisleResponse(aisle), nil
}

func (s *aisleService) GetAll(ctx context.Context, filter query.AisleFilter) ([]dto.AisleResponse, int64, error) {
	aisles, total, err := s.aisleRepo.GetAll(ctx, filter)
	if err != nil {
		return nil, 0, err
	}
	var responses []dto.AisleResponse
	for _, e := range aisles {
		responses = append(responses, toAisleResponse(e))
	}
	if responses == nil {
		responses = make([]dto.AisleResponse, 0)
	}
	return responses, total, nil
}

func (s *aisleService) Update(ctx context.Context, req dto.AisleUpdateRequest, aisleId string) (dto.AisleResponse, error) {
	tx := s.db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	aisle, err := s.aisleRepo.GetById(ctx, tx, aisleId)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	if req.Code != "" {
		aisle.Code = req.Code
	}
	if req.Name != "" {
		aisle.Name = req.Name
	}
	if req.IsleX != "" {
		aisle.IsleX = req.IsleX
	}
	if req.BinY != "" {
		aisle.BinY = req.BinY
	}
	if req.LevelZ != "" {
		aisle.LevelZ = req.LevelZ
	}
	if req.Dimension != "" {
		aisle.Dimension = req.Dimension
	}
	if req.Weight != "" {
		aisle.Weight = req.Weight
	}
	if req.QrCodeAisle != "" {
		aisle.QrCodeAisle = req.QrCodeAisle
	}
	aisle.IsActive = req.IsActive
	updated, err := s.aisleRepo.Update(ctx, tx, aisle)
	if err != nil {
		tx.Rollback()
		return dto.AisleResponse{}, err
	}
	tx.Commit()
	return toAisleResponse(updated), nil
}

func (s *aisleService) Delete(ctx context.Context, aisleId string) error {
	tx := s.db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	if err := s.aisleRepo.Delete(ctx, tx, aisleId); err != nil {
		tx.Rollback()
		return err
	}
	tx.Commit()
	return nil
}

func NewAisleService(aisleRepo repository.AisleRepository, db *gorm.DB) AisleService {
	return &aisleService{
		aisleRepo: aisleRepo,
		db:        db,
	}
}