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

package partner

import (
	"context"
	"enaklo-pos-be/internal/common/logger"
	"enaklo-pos-be/internal/common/mycontext"
	"enaklo-pos-be/internal/entity"
	"enaklo-pos-be/internal/repository"
	"enaklo-pos-be/internal/services/users"
	"go.uber.org/zap"
)

type PartnerService struct {
	repo       repository.PartnerRepository
	trx        repository.TransactionManager
	userSvc    *users.UserService
	walletRepo repository.WalletRepository
	userRepo   repository.User
}

func NewPartnerService(repo repository.PartnerRepository,
	userSvc *users.UserService, repoManager repository.TransactionManager,
	walletRepo repository.WalletRepository,
	userRepo repository.User,
) *PartnerService {
	return &PartnerService{
		repo:       repo,
		userSvc:    userSvc,
		trx:        repoManager,
		walletRepo: walletRepo,
		userRepo:   userRepo,
	}
}

func (s *PartnerService) Create(ctx mycontext.Context, partnerReq *entity.CreatePartnerRequest) (*entity.Partner, error) {
	var err error

	tx, err := s.trx.Begin(ctx)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when starting transaction", zap.Error(err))
		return nil, err
	}

	defer func() {
		if r := recover(); r != nil {
			s.trx.Rollback(tx)
			panic(r)
		} else if err != nil {
			s.trx.Rollback(tx)
		} else {
			err = s.trx.Commit(tx).Error
		}
	}()

	// Create Partner
	partnerDB := partnerReq.ToPartnerDB(ctx.RequestedBy())
	if partnerDB, err = s.repo.CreateWithTx(ctx, tx, partnerDB); err != nil {
		logger.ContextLogger(ctx).Error("error when creating partner", zap.Error(err))
		return nil, err
	}

	adminUser := partnerReq.ToUserAdmin(partnerDB.ID)
	if adminUser, err = s.userSvc.CreateWithTx(ctx, tx, adminUser); err != nil {
		logger.ContextLogger(ctx).Error("error when creating admin user", zap.Error(err))
		return nil, err
	}

	partnerDB.AdminUserID = adminUser.ID
	if partnerDB, err = s.repo.UpdateWithTx(ctx, tx, partnerDB); err != nil {
		logger.ContextLogger(ctx).Error("error when creating partner", zap.Error(err))
		return nil, err
	}

	partnerWallet := partnerReq.ToWallet(partnerDB.ID)
	if partnerWallet, err = s.walletRepo.Create(ctx, tx, partnerWallet); err != nil {
		logger.ContextLogger(ctx).Error("error when creating wallet", zap.Error(err))
		return nil, err
	}

	return partnerDB.ToPartner(), nil
}

func (s *PartnerService) Update(ctx mycontext.Context, req *entity.PartnerUpdate) (*entity.Partner, error) {
	existingPartner, err := s.repo.GetByID(ctx, req.ID)
	if err != nil {
		return nil, err
	}
	existingPartner.ToUpdatedPartnerData(ctx.RequestedBy(), *req)

	tx, err := s.trx.Begin(ctx)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when starting transaction", zap.Error(err))
		return nil, err
	}

	defer func() {
		if r := recover(); r != nil {
			s.trx.Rollback(tx)
			panic(r)
		} else if err != nil {
			s.trx.Rollback(tx)
		} else {
			err = s.trx.Commit(tx).Error
		}
	}()

	updatedPartnerDB, err := s.repo.UpdateWithTx(ctx, tx, existingPartner.ToPartnerDB())
	if err != nil {
		logger.ContextLogger(ctx).Error("error when update Partner", zap.Error(err))
		return nil, err
	}

	partnerAdmin, err := s.userRepo.GetPartnerAdmin(ctx, req.ID)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when get Partner admin", zap.Error(err))
		return nil, err
	}

	if partnerAdmin != nil {
		req.AdminUserID = partnerAdmin.ID
		adminUser := req.ToUserAdmin(&req.ID)
		if adminUser, err = s.userSvc.UpdateWithTx(ctx, tx, adminUser); err != nil {
			logger.ContextLogger(ctx).Error("error when creating admin user", zap.Error(err))
			return nil, err
		}
	}

	return updatedPartnerDB.ToPartner(), nil
}

func (s *PartnerService) GetByID(ctx context.Context, id int64) (*entity.Partner, error) {
	PartnerDB, err := s.repo.GetByID(ctx, id)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when get Partner by id", zap.Error(err))
		return nil, err
	}

	return PartnerDB.ToPartner(), nil
}

func (s *PartnerService) GetAll(ctx context.Context, search entity.PartnerSearch) ([]*entity.Partner, int, error) {
	Partneres, total, err := s.repo.GetAll(ctx, search)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when get all Partneres", zap.Error(err))
		return nil, 0, err
	}

	return Partneres.ToPartnerList(), total, nil
}

func (s *PartnerService) Delete(ctx mycontext.Context, id int64) error {
	PartnerDB, err := s.repo.GetByID(ctx, id)
	if err != nil {
		logger.ContextLogger(ctx).Error("error when get Partner by id", zap.Error(err))
		return err
	}

	PartnerDB.SetDeleted(ctx.RequestedBy())

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

	return nil
}