lckt-server/service/user/user.go

package user

import (
	"context"
	"fmt"
	"git.echol.cn/loser/lckt/global"
	"git.echol.cn/loser/lckt/model/user"
	"git.echol.cn/loser/lckt/model/user/request"
	"git.echol.cn/loser/lckt/utils/sms"
	"github.com/ArtisanCloud/PowerSocialite/v3/src/providers"
	"go.uber.org/zap"
	"golang.org/x/crypto/bcrypt"
	"math/rand"
	"time"
)

type UserService struct{}

func (u *UserService) GetUserById(id string) (user user.User, err error) {
	err = global.GVA_DB.Where("id = ?", id).First(&user).Error
	if err != nil {
		global.GVA_LOG.Error("查询用户失败", zap.Error(err))
		return
	}
	return
}

// SendCode 发送验证码
func (u *UserService) SendCode(req request.SendCodeReq) (err error) {
	rdb := global.GVA_REDIS

	key := fmt.Sprintf("VerifyCode:%s", req.Phone)

	// 发送频率检查
	result, err := rdb.Get(context.Background(), key).Result()
	if result != "" {
		global.GVA_LOG.Error("验证码发送过于频繁", zap.String("phone", req.Phone))
		return
	}

	rand.New(rand.NewSource(time.Now().UnixNano()))
	verifyCode := fmt.Sprintf("%06v", rand.Int31n(1000000))

	if ok := sms.SendSMS(req.Phone, verifyCode); !ok {
		global.GVA_LOG.Error("发送验证码失败")
		return
	}
	//
	if err = rdb.Set(context.Background(), key, verifyCode, time.Duration(global.GVA_CONFIG.SMS.ExpireTime)*time.Second).Err(); err != nil {
		global.GVA_LOG.Error("设置验证码缓存失败", zap.Error(err))
		return
	}

	return
}

// Login 用户登录
func (u *UserService) Login(req request.CodeLoginReq) (users user.User, err error) {
	// 1. 判断用户是否存在
	var count int64
	err = global.GVA_DB.Model(&user.User{}).Where("phone = ?", req.Phone).Count(&count).Error
	if err != nil {
		global.GVA_LOG.Error("查询用户失败", zap.Error(err))
		return
	}

	// 2. 如果用户不存在，则创建用户
	if count == 0 {
		user := user.User{
			Phone:     req.Phone,
			UserLabel: 1,
		}
		err = global.GVA_DB.Save(&user).Error
		if err != nil {
			global.GVA_LOG.Error("创建用户失败", zap.Error(err))
			return
		}
	} else {
		err = global.GVA_DB.Where("phone = ?", req.Phone).First(&users).Error
		if err != nil {
			global.GVA_LOG.Error("查询用户失败", zap.Error(err))
			return
		}
	}

	return
}

// GetUserList 获取用户列表
func (u *UserService) GetUserList(p request.GetUserListReq) (userList []user.User, total int64, err error) {
	limit := p.PageSize
	offset := p.PageSize * (p.Page - 1)
	// 创建db
	db := global.GVA_DB.Model(&user.User{})
	// 如果有条件搜索 下方会自动创建搜索语句
	if p.Type != 0 {
		db = db.Where("user_type = ?", p.Type)
	}
	if p.UserLabel != "" {
		db = db.Where("user_label = ?", p.UserLabel)
	}
	if p.Status != 0 {
		db = db.Where("status = ?", p.Status)
	}

	if p.Name != "" {
		db = db.Where("nick_name like ?", "%"+p.Name+"%")
	}

	err = db.Count(&total).Error
	if err != nil {
		return
	}

	if limit != 0 {
		db = db.Limit(limit).Offset(offset)
	}
	err = db.Find(&userList).Error
	return

}

// SetBalance 设置用户余额
func (u *UserService) SetBalance(p request.SetBalanceReq) (err error) {
	err = global.GVA_DB.Model(&user.User{}).Where("id = ?", p.Id).Update("balance", p.Balance).Error
	if err != nil {
		global.GVA_LOG.Error("设置用户余额失败", zap.Error(err))
		return
	}
	return
}

// WechatLogin 微信登录
func (u *UserService) WechatLogin(info *providers.User) (users user.User, err error) {
	openID := info.GetOpenID()
	var count int64
	// 1. 判断用户是否存在
	err = global.GVA_DB.Model(&users).Where("open_id = ?", openID).Count(&count).Error
	if err != nil {
		global.GVA_LOG.Error("查询用户失败", zap.Error(err))
		return
	}

	if count == 0 {
		newUser := user.User{
			OpenId:   openID,
			NickName: info.GetNickname(),
			Avatar:   info.GetAvatar(),
		}
		err = global.GVA_DB.Save(&newUser).Error
		if err != nil {
			global.GVA_LOG.Error("创建用户失败", zap.Error(err))
			return
		}
		return newUser, nil
	} else {
		err = global.GVA_DB.Where("open_id = ?", openID).First(&users).Error
		if err != nil {
			global.GVA_LOG.Error("查询用户失败", zap.Error(err))
			return
		}
	}
	return
}

// PwdLogin 用户密码登录
func (u *UserService) PwdLogin(req request.PwdLoginReq) (users user.User, err error) {
	// 1. 判断用户是否存在
	var count int64
	err = global.GVA_DB.Model(&user.User{}).Where("phone = ?", req.Phone).First(&users).Count(&count).Error
	if err != nil {
		global.GVA_LOG.Error("查询用户失败", zap.Error(err))
		return
	}
	if count == 0 {
		global.GVA_LOG.Error("用户不存在")
		err = fmt.Errorf("用户不存在")
		return
	}

	// 2. 判断密码是否正确
	err = bcrypt.CompareHashAndPassword([]byte(users.Password), []byte(req.Password))
	if err != nil {
		global.GVA_LOG.Error("密码错误", zap.Error(err))
		return
	}
	return
}

// Register 用户注册-后台用
func (u *UserService) Register(req request.RegisterReq) (err error) {
	// 1. 判断用户是否存在
	var count int64
	err = global.GVA_DB.Model(&user.User{}).Where("phone = ?", req.Phone).Count(&count).Error
	if err != nil {
		global.GVA_LOG.Error("查询用户失败", zap.Error(err))
		return
	}
	if count == 0 {
		var password []byte
		password, err = bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
		if err != nil {
			global.GVA_LOG.Error("密码加密失败", zap.Error(err))
			return
		}
		user := user.User{
			Phone:     req.Phone,
			Password:  string(password),
			NickName:  req.NickName,
			UserLabel: req.UserLabel,
			Status:    1,
			UserType:  req.UserType,
		}
		if req.UserLabel != 0 {
			user.IsVip = 1
			date := time.Now().Truncate(24*time.Hour).AddDate(0, 0, 30)
			//将date转为string
			user.VipExpireTime = date.Format("2006-01-02 15:04:05")
		}
		err = global.GVA_DB.Save(&user).Error
		if err != nil {
			global.GVA_LOG.Error("创建用户失败", zap.Error(err))
			return
		}
		return
	} else {
		err = fmt.Errorf("用户已存在")
	}

	return
}

// SetUserStatus 设置用户状态
func (u *UserService) SetUserStatus(id string) (err error) {
	user := user.User{}

	err = global.GVA_DB.Model(&user).Where("id = ?", id).First(&user).Error
	if err != nil {
		global.GVA_LOG.Error("查询用户状态失败", zap.Error(err))
		return
	}
	if user.Status == 1 {
		err = global.GVA_DB.Model(&user).Where("id = ?", id).Update("status", 0).Error
	} else {
		err = global.GVA_DB.Model(&user).Where("id = ?", id).Update("status", 1).Error
	}
	if err != nil {
		global.GVA_LOG.Error("设置用户状态失败", zap.Error(err))
		return
	}
	return
}