cardverse-be/internal/modules/seriessetmaster/service.go

package seriessetmaster

import (
	"errors"

	"cardverse/internal/pkg/utils"
)

var ErrSeriesSetNotFound = errors.New("data series atau set tidak ditemukan")

type Service interface {
	GetAllSeries(query ListSeriesQuery) ([]SeriesSetMaster, error)
	GetAllSets(query ListSetQuery) ([]SeriesSetMaster, error)
	GetByID(id uint) (*SeriesSetMaster, error)
	GetSetByCode(code string) (*SeriesSetMaster, error)
	CreateSeries(req CreateSeriesRequest) (*SeriesSetMaster, error)
	CreateSet(req CreateSetRequest) (*SeriesSetMaster, error)
	UpdateSeries(id uint, req UpdateSeriesRequest) (*SeriesSetMaster, error)
	UpdateSet(id uint, req UpdateSetRequest) (*SeriesSetMaster, error)
	Delete(id uint) error
}

type service struct {
	repo Repository
}

func NewService(repo Repository) Service {
	return &service{repo: repo}
}

func (s *service) GetAllSeries(query ListSeriesQuery) ([]SeriesSetMaster, error) {
	return s.repo.FindAllSeries(query.Search)
}

func (s *service) GetAllSets(query ListSetQuery) ([]SeriesSetMaster, error) {
	return s.repo.FindAllSets(query.Search, query.ParentID)
}

func (s *service) GetByID(id uint) (*SeriesSetMaster, error) {
	m, err := s.repo.FindByID(id)
	if err != nil {
		return nil, ErrSeriesSetNotFound
	}
	return m, nil
}

func (s *service) GetSetByCode(code string) (*SeriesSetMaster, error) {
	m, err := s.repo.FindBySetCode(code)
	if err != nil {
		return nil, ErrSeriesSetNotFound
	}
	return m, nil
}

func (s *service) CreateSeries(req CreateSeriesRequest) (*SeriesSetMaster, error) {
	m := &SeriesSetMaster{
		SeriesName: req.Name,
		Image:      req.Image,
		ParentID:   nil,
	}

	if err := s.repo.Create(m); err != nil {
		return nil, err
	}

	return m, nil
}

func (s *service) CreateSet(req CreateSetRequest) (*SeriesSetMaster, error) {
	parent, err := s.repo.FindByID(req.ParentID)
	if err != nil || parent == nil || parent.ParentID != nil {
		return nil, errors.New("parent_id tidak ditemukan atau bukan merupakan series")
	}

	m := &SeriesSetMaster{
		ParentID:    &req.ParentID,
		SetCode:     req.SetCode,
		SetName:     req.SetName,
		SeriesName:  parent.SeriesName,
		Image:       req.Image,
		Logo:        req.Logo,
		ReleaseDate: req.ReleaseDate,
	}

	if err := s.repo.CreateSet(m); err != nil {
		return nil, err
	}

	return m, nil
}

func (s *service) UpdateSeries(id uint, req UpdateSeriesRequest) (*SeriesSetMaster, error) {
	m, err := s.repo.FindByID(id)
	if err != nil {
		return nil, ErrSeriesSetNotFound
	}

	if m.ParentID != nil {
		return nil, errors.New("record ini adalah set, bukan series")
	}

	if req.Name != "" {
		m.SeriesName = req.Name
	}
	if req.Image != "" {
		if m.Image != "" && m.Image != req.Image {
			utils.DeleteLocalFile(m.Image)
		}
		m.Image = req.Image
	}

	if err := s.repo.Update(m); err != nil {
		return nil, err
	}

	return m, nil
}

func (s *service) UpdateSet(id uint, req UpdateSetRequest) (*SeriesSetMaster, error) {
	m, err := s.repo.FindByID(id)
	if err != nil {
		return nil, ErrSeriesSetNotFound
	}

	if m.ParentID == nil {
		return nil, errors.New("record ini adalah series, bukan set")
	}

	var oldParentID *uint
	if req.ParentID != nil && (m.ParentID == nil || *req.ParentID != *m.ParentID) {
		oldParentID = m.ParentID
		parent, err := s.repo.FindByID(*req.ParentID)
		if err != nil || parent == nil || parent.ParentID != nil {
			return nil, errors.New("parent_id tidak ditemukan atau bukan merupakan series")
		}
		m.ParentID = req.ParentID
		m.SeriesName = parent.SeriesName
	}

	if req.SetCode != "" {
		m.SetCode = req.SetCode
	}
	if req.SetName != "" {
		m.SetName = req.SetName
	}
	if req.Image != "" {
		if m.Image != "" && m.Image != req.Image {
			utils.DeleteLocalFile(m.Image)
		}
		m.Image = req.Image
	}
	if req.Logo != "" {
		if m.Logo != "" && m.Logo != req.Logo {
			utils.DeleteLocalFile(m.Logo)
		}
		m.Logo = req.Logo
	}
	if req.ReleaseDate != nil {
		m.ReleaseDate = req.ReleaseDate
	}

	if err := s.repo.UpdateSet(m, oldParentID); err != nil {
		return nil, err
	}

	return m, nil
}

func (s *service) Delete(id uint) error {
	m, err := s.repo.FindByID(id)
	if err != nil {
		return ErrSeriesSetNotFound
	}

	if m.ParentID == nil {
		childSets, _ := s.repo.FindAllSets("", m.ID)
		for _, set := range childSets {
			cardImages, _ := s.repo.FindCardImagesBySetID(set.ID)
			for _, imgPath := range cardImages {
				utils.DeleteLocalFile(imgPath)
			}
			if set.Image != "" {
				utils.DeleteLocalFile(set.Image)
			}
			if set.Logo != "" {
				utils.DeleteLocalFile(set.Logo)
			}
		}
		if m.Image != "" {
			utils.DeleteLocalFile(m.Image)
		}
	} else {
		cardImages, _ := s.repo.FindCardImagesBySetID(m.ID)
		for _, imgPath := range cardImages {
			utils.DeleteLocalFile(imgPath)
		}
		if m.Image != "" {
			utils.DeleteLocalFile(m.Image)
		}
		if m.Logo != "" {
			utils.DeleteLocalFile(m.Logo)
		}
	}

	return s.repo.DeleteCascade(m)
}