affiliate_dash/backend/internal/service/user.go

package service

import (
	"errors"

	"affiliate_dash/internal/model"

	"golang.org/x/crypto/bcrypt"
	"gorm.io/gorm"
)

type UserService struct {
	db     *gorm.DB
	tenant *TenantService
}

func NewUserService(db *gorm.DB, tenant *TenantService) *UserService {
	return &UserService{db: db, tenant: tenant}
}

type UserListQuery struct {
	MerchantID uint
	Page       int
	Size       int
	Keyword    string
	Role       string
	Status     *int
}

func (s *UserService) List(q UserListQuery) ([]model.User, int64, error) {
	if q.Page < 1 {
		q.Page = 1
	}
	if q.Size < 1 || q.Size > 100 {
		q.Size = 20
	}
	tx := s.db.Model(&model.User{})
	if q.MerchantID != 0 {
		tx = tx.Joins("JOIN merchant_members ON merchant_members.user_id = users.id").
			Where("merchant_members.merchant_id = ?", q.MerchantID)
	}
	if q.Keyword != "" {
		like := "%" + q.Keyword + "%"
		tx = tx.Where("users.username LIKE ? OR users.nickname LIKE ?", like, like)
	}
	if q.Role != "" {
		tx = tx.Where("users.role = ?", q.Role)
	}
	if q.Status != nil {
		tx = tx.Where("users.status = ?", *q.Status)
	}
	var total int64
	if err := tx.Count(&total).Error; err != nil {
		return nil, 0, err
	}
	var list []model.User
	err := tx.Order("users.id DESC").Offset((q.Page - 1) * q.Size).Limit(q.Size).Find(&list).Error
	return list, total, err
}

func (s *UserService) Create(username, password, nickname, role string, merchantID uint) (*model.User, error) {
	var count int64
	s.db.Model(&model.User{}).Where("username = ?", username).Count(&count)
	if count > 0 {
		return nil, errors.New("用户名已存在")
	}
	if role == "" {
		role = model.RoleMerchant
	}
	if role != model.RoleAdmin && role != model.RoleMerchant {
		return nil, errors.New("无效的账号角色")
	}
	hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
	if err != nil {
		return nil, err
	}
	user := &model.User{
		Username:     username,
		PasswordHash: string(hash),
		Nickname:     nickname,
		Role:         role,
		Status:       1,
	}
	if user.Nickname == "" {
		user.Nickname = username
	}
	err = s.db.Transaction(func(tx *gorm.DB) error {
		if err := tx.Create(user).Error; err != nil {
			return err
		}
		if s.tenant != nil && merchantID != 0 {
			memberRole := model.MemberRoleOperator
			if role == model.RoleAdmin {
				memberRole = model.MemberRoleOwner
			}
			member := model.MerchantMember{
				MerchantID: merchantID,
				UserID:     user.ID,
				Role:       memberRole,
				Status:     user.Status,
				IsDefault:  role == model.RoleAdmin,
			}
			if err := tx.Create(&member).Error; err != nil {
				return err
			}
		}
		return nil
	})
	if err != nil {
		return nil, err
	}
	return user, nil
}

func (s *UserService) UpdateStatus(id uint, status int) error {
	if status != 0 && status != 1 {
		return errors.New("用户状态无效")
	}
	return s.db.Transaction(func(tx *gorm.DB) error {
		var user model.User
		if err := tx.First(&user, id).Error; err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return errors.New("用户不存在")
			}
			return err
		}
		if user.Role == model.RoleAdmin && user.Status == 1 && status == 0 {
			var admins int64
			if err := tx.Model(&model.User{}).Where("role = ? AND status = ?", model.RoleAdmin, 1).Count(&admins).Error; err != nil {
				return err
			}
			if admins <= 1 {
				return errors.New("至少保留一个启用的平台管理员")
			}
		}
		return tx.Model(&user).Update("status", status).Error
	})
}

// Delete removes a platform account and its merchant memberships. It protects the current
// account and the final enabled platform administrator so the platform cannot be locked out.
func (s *UserService) Delete(id, actorUserID uint) error {
	if id == 0 {
		return errors.New("用户不存在")
	}
	if id == actorUserID {
		return errors.New("不能删除当前登录账号")
	}
	return s.db.Transaction(func(tx *gorm.DB) error {
		var user model.User
		if err := tx.First(&user, id).Error; err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return errors.New("用户不存在")
			}
			return err
		}
		if user.Role == model.RoleAdmin && user.Status == 1 {
			var admins int64
			if err := tx.Model(&model.User{}).Where("role = ? AND status = ?", model.RoleAdmin, 1).Count(&admins).Error; err != nil {
				return err
			}
			if admins <= 1 {
				return errors.New("至少保留一个启用的平台管理员")
			}
		}
		if err := tx.Where("user_id = ?", id).Delete(&model.MerchantMember{}).Error; err != nil {
			return err
		}
		return tx.Delete(&user).Error
	})
}