apskel-pos-backend/internal/services/sites/sites.go

package site

import (
	"context"
	"furtuna-be/internal/common/logger"
	"furtuna-be/internal/common/mycontext"
	"furtuna-be/internal/constants/role"
	"furtuna-be/internal/entity"
	"furtuna-be/internal/repository"
	"furtuna-be/internal/repository/users"

	"go.uber.org/zap"
)

type SiteService struct {
	repo repository.SiteRepository
	user users.UserRepository
}

func NewSiteService(repo repository.SiteRepository) *SiteService {
	return &SiteService{
		repo: repo,
	}
}

func (s *SiteService) Create(ctx mycontext.Context, siteReq *entity.Site) (*entity.Site, error) {
	siteDB := siteReq
	siteDB.CreatedBy = ctx.RequestedBy()

	siteDB, err := s.repo.Upsert(ctx, siteDB)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when creating site", zap.Error(err))
		return nil, err
	}

	return siteDB, nil
}

func (s *SiteService) Update(ctx mycontext.Context, id int64, siteReq *entity.Site) (*entity.Site, error) {
	existingSite, err := s.repo.GetByID(ctx, id)
	if err != nil {
		return nil, err
	}

	existingSite.ToUpdatedSite(ctx.RequestedBy(), *siteReq)

	updatedSiteDB, err := s.repo.Update(ctx, existingSite.ToSiteDB())
	if err != nil {
		logger.ContextLogger(ctx).Error("error when updating site", zap.Error(err))
		return nil, err
	}

	return updatedSiteDB.ToSite(), nil
}

func (s *SiteService) GetByID(ctx context.Context, id int64) (*entity.Site, error) {
	siteDB, err := s.repo.GetByID(ctx, id)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when getting site by ID", zap.Error(err))
		return nil, err
	}

	return siteDB.ToSite(), nil
}

func (s *SiteService) GetAll(ctx context.Context, search entity.SiteSearch) ([]*entity.Site, int, error) {
	sites, total, err := s.repo.GetAll(ctx, search)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when getting all sites", zap.Error(err))
		return nil, 0, err
	}

	return sites.ToSiteList(), total, nil
}

func (s *SiteService) Delete(ctx mycontext.Context, id int64) error {
	siteDB, err := s.repo.GetByID(ctx, id)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when getting site by ID", zap.Error(err))
		return err
	}

	siteDB.SetDeleted(ctx.RequestedBy())

	_, err = s.repo.Update(ctx, siteDB)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when updating site", zap.Error(err))
		return err
	}

	return nil
}

func (s *SiteService) Count(ctx mycontext.Context, req entity.SiteSearch) (*entity.SiteCount, error) {
	if req.SiteID != nil {
		total, err := s.user.CountUsersByRoleAndSiteOrPartner(ctx, int(role.Casheer), req.SiteID)
		if err != nil {
			logger.ContextLogger(ctx).Error("error when getting count user", zap.Error(err))
			return nil, err
		}
		return &entity.SiteCount{
			Count: total,
		}, nil
	}

	count, err := s.repo.Count(ctx, req)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when getting all sites", zap.Error(err))
		return nil, err
	}

	return count.ToSiteCount(), nil
}