dy-admin-temp/internal/pcmserver/sys/service/user.go

package service

import (
	"dy-admin/internal/pcmserver/global"
	"dy-admin/internal/pcmserver/pkg/code"
	"dy-admin/internal/pcmserver/sys/model"
	"dy-admin/internal/pcmserver/sys/model/request"
	"dy-admin/internal/pcmserver/utils"
	"dy-admin/pkg/rescode"
	"github.com/pkg/errors"
	uuid "github.com/satori/go.uuid"
	"gorm.io/gorm"
)

type UserService struct {
}

func (us *UserService) Register(u model.User) (user model.User, err error) {
	err = global.DB.Where("username = ?", u.Username).First(&model.User{}).Error
	if !errors.Is(err, gorm.ErrRecordNotFound) {
		return user, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrUserAlreadyExistCode])
	}

	//找到用户指定的角色
	if u.RoleIds != nil && len(u.RoleIds) != 0 {
		var roles []model.Role
		err = global.DB.Where("role_id in ?", u.RoleIds).Find(&roles).Error
		if err != nil {
			return user, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
		}
		u.Roles = roles
	}

	if u.DeptId != 0 {
		var dept model.Dept
		err = global.DB.Where("dept_id = ?", u.DeptId).First(&dept).Error
		if err != nil {
			return user, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
		}
		u.Dept = dept
	}

	u.Password = utils.BcryptHash(u.Password)
	u.UUID = uuid.NewV4().String()
	err = global.DB.Create(&u).Error
	if err != nil {
		return user, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	return u, err
}

func (us *UserService) UpdateUser(u model.User) (err error) {
	var user model.User
	err = global.DB.Where("user_id = ?", u.UserID).Preload("Roles").First(&user).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrUserNotFoundCode])
		} else {
			return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
		}
	}

	if u.DeptId != 0 {
		var dept model.Dept
		err = global.DB.Where("dept_id = ?", u.DeptId).First(&dept).Error
		if err != nil {
			return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
		}
	}

	var newRoles []model.Role
	err = global.DB.Where("role_id in ?", u.RoleIds).Find(&newRoles).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	tx := global.DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()

	// 删除旧的角色
	err = tx.Model(&user).Association("Roles").Delete(user.Roles)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	u.Roles = newRoles
	err = tx.Session(&gorm.Session{FullSaveAssociations: true}).Debug().Updates(&u).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	// 清楚角色casbin缓存
	_ = CasbinServiceInstance.Casbin().InvalidateCache()
	return
}

func (us *UserService) Login(u model.User) (user model.User, err error) {
	err = global.DB.Where("username = ?", u.Username).Preload("Roles").First(&user).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return user, rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrUserNotFoundCode])
		} else {
			return user, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
		}
	}
	if ok := utils.BcryptCheck(u.Password, user.Password); !ok {
		return user, rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrPasswordCode])
	}

	if user.Status != "1" {
		return user, rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrNotAllowLoginCode])
	}

	return
}

func (us *UserService) ChangePassword(u model.User, newPassword string) (err error) {
	var user model.User
	err = global.DB.Where("user_id = ?", u.UserID).First(&user).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	if ok := utils.BcryptCheck(u.Password, user.Password); !ok {
		return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrPasswordCode])
	}
	user.Password = utils.BcryptHash(newPassword)
	err = global.DB.Save(&user).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	return
}

func (us *UserService) GetUserInfoList(info request.SearchUserReq) (users []model.User, total int64, err error) {
	var limit, offset int
	if info.Page == 0 || info.PageSize == 0 {
		limit = -1
		offset = -1
	} else {
		limit = info.PageSize
		offset = info.PageSize * (info.Page - 1)
	}
	db := global.DB.Model(&model.User{})

	if info.NickName != "" {
		db = db.Where("nick_name LIKE ?", "%"+info.NickName+"%")
	}

	if info.Phone != "" {
		db = db.Where("phone LIKE ?", "%"+info.Phone+"%")
	}

	if info.DeptId != 0 {
		deptIds, _ := ServicesGroupApp.DeptService.GetSonDeptIds(info.DeptId)
		db = db.Where("dept_id in (?)", deptIds)
	}

	if info.Status != "" {
		db = db.Where("status = ?", info.Status)
	}

	err = db.Count(&total).Error
	if err != nil {
		return users, total, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	err = db.Limit(limit).Offset(offset).Preload("Roles").Find(&users).Error
	if err != nil {
		return users, total, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	return
}

func (us *UserService) GetUserInfoByDeptID(deptId int) (users []model.User, total int64, err error) {
	err = global.DB.Model(&model.User{}).Where("dept_id = ?", deptId).Count(&total).Preload("Roles").Find(&users).Error
	if err != nil {
		return users, total, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	return
}

func (us *UserService) GetUserByID(userId int) (user model.User, err error) {
	err = global.DB.Preload("Roles").Where("user_id = ?", userId).First(&user).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return user, rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrUserNotFoundCode])
		} else {
			return user, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
		}
	}
	return
}

func (us *UserService) ResetPassword(userId int) (err error) {
	err = global.DB.Model(&model.User{}).Where("user_id = ?", userId).Update("password", utils.BcryptHash("123456")).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	return
}

func (us *UserService) DeleteUser(userId int) (err error) {
	tx := global.DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()

	var user model.User

	err = tx.Preload("Roles").Where("user_id = ?", userId).First(&user).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrUserNotFoundCode])
		} else {
			return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
		}
	}

	// 删除关联
	err = tx.Model(&user).Association("Roles").Delete(user.Roles)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	err = tx.Where("user_id = ?", userId).Delete(&user).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	return
}