GO/app/logic/manage/setting/manage.go

package setting

import (
	"base/app/common"
	"base/app/lib/bean"
	"base/app/model"
	"errors"
	"fmt"
	"git.oa00.com/go/acs"
	"git.oa00.com/go/mysql"
	"gorm.io/gorm"
)

var ManageLogic = &manageLogic{}

type manageLogic struct {
}
type manageItem struct {
	Id        uint   `json:"id"`
	Account   string `json:"account"`
	Name      string `json:"name"`
	Phone     string `json:"phone"`
	RoleId    uint   `json:"roleId"`
	RoleName  string `json:"roleName"`
	Status    uint   `json:"status"`
	CreatedAt int64  `json:"createdAt"`
	UpdatedAt int64  `json:"updatedAt"`
}
type ManageListsSearch struct {
	Id   uint
	Name string
}

// Lists @Title 用户列表
func (m *manageLogic) Lists(search ManageListsSearch, page bean.Page) (lists []manageItem, total int64) {
	lists = []manageItem{}
	var manages []model.Manage
	where := mysql.Db
	if search.Id > 0 {
		where = where.Where("id = ?", search.Id)
	}
	if search.Name != "" {
		where = where.Where("name like ?", fmt.Sprintf("%%%s%%", search.Name))
	}
	mysql.Db.Model(&manages).Where(where).Count(&total)
	if page.HasPage(total) {
		mysql.Db.
			Preload("Department").Preload("Role").
			Where(where).Offset(page.GetStart()).Limit(page.GetLimit()).Order("id desc").Find(&manages)
		for _, manage := range manages {
			lists = append(lists, manageItem{
				Id:        manage.Id,
				Account:   manage.Account,
				Name:      manage.Name,
				Phone:     manage.Phone,
				RoleId:    manage.RoleId,
				RoleName:  manage.Role.Name,
				Status:    manage.Status,
				CreatedAt: manage.CreatedAt.Unix(),
				UpdatedAt: manage.UpdatedAt.Unix(),
			})
		}
	}
	return
}

type ManageAdd struct {
	Account  string `binding:"required" label:"账号"`
	Password string `binding:"required,min=6" label:"密码"`
	Name     string `binding:"required" label:"姓名"`
	Phone    string `binding:"required" label:"手机号"`
	RoleId   uint   `binding:"required" label:"角色"`
	Status   uint   `binding:"required,oneof=1 2" label:"状态"`
}

// Add @Title 添加用户
func (m *manageLogic) Add(data ManageAdd) error {
	manage := model.Manage{Account: data.Account}
	mysql.Db.Where(&manage).First(&manage)
	if manage.Id > 0 {
		return errors.New("账号已存在")
	}
	salt := common.RandStr(8)
	return mysql.Db.Transaction(func(tx *gorm.DB) error {
		manageData := model.Manage{
			Name:     data.Name,
			Account:  data.Account,
			Salt:     salt,
			Password: common.GetPassword(data.Password, salt),
			Status:   data.Status,
			Phone:    data.Phone,
			RoleId:   data.RoleId,
		}
		if tx.Create(&manageData).Error != nil {
			return errors.New("添加失败")
		}
		if _, err := acs.Enforcer.AddGroupingPolicy(fmt.Sprintf("manage_%d", manageData.Id), fmt.Sprintf("role_%d", data.RoleId)); err != nil {
			return errors.New("添加失败")
		}
		return nil
	})
}

type ManageEdit struct {
	ManageId uint `binding:"required" label:"用户"`
	Password string
	Name     string `binding:"required" label:"姓名"`
	RoleId   uint   `binding:"required" label:"角色"`
	Phone    string `binding:"required" label:"手机号"`
	Status   uint   `binding:"required,oneof=1 2" label:"状态"`
}

// Edit @Title 编辑用户
func (m *manageLogic) Edit(data ManageEdit) error {
	manage := model.Manage{Id: data.ManageId}
	if mysql.Db.First(&manage).Error != nil {
		return errors.New("用户错误")
	}
	password := manage.Password
	if data.Password != "" {
		if len(data.Password) < 6 {
			return errors.New("密码不能小于6位")
		}
		password = common.GetPassword(data.Password, manage.Salt)
	}
	return mysql.Db.Transaction(func(tx *gorm.DB) error {
		if tx.Model(&manage).UpdateColumns(map[string]interface{}{
			"password": password,
			"name":     data.Name,
			"phone":    data.Phone,
			"role_id":  data.RoleId,
			"status":   data.Status,
		}).Error != nil {
			return errors.New("编辑失败")
		}
		if manage.RoleId != data.RoleId {
			groupingName := fmt.Sprintf("manage_%d", manage.Id)
			if _, err := acs.Enforcer.RemoveGroupingPolicies(acs.Enforcer.GetFilteredGroupingPolicy(0, groupingName)); err != nil {
				return errors.New("编辑失败")
			}
			if _, err := acs.Enforcer.AddGroupingPolicy(groupingName, fmt.Sprintf("role_%d", data.RoleId)); err != nil {
				return errors.New("编辑失败")
			}
		}
		return nil
	})
}

// Enabled @Title 启用
func (m *manageLogic) Enabled(manageId uint) error {
	manage := model.Manage{Id: manageId}
	if mysql.Db.First(&manage).Error != nil {
		return errors.New("用户错误")
	}
	if manage.Status == model.ManageStatusEnabled {
		return nil
	}
	if mysql.Db.Model(&manage).UpdateColumn("status", model.ManageStatusEnabled).Error != nil {
		return errors.New("启用失败")
	}
	return nil
}

// Disabled @Title 停用
func (m *manageLogic) Disabled(manageId uint) error {
	manage := model.Manage{Id: manageId}
	if mysql.Db.First(&manage).Error != nil {
		return errors.New("用户错误")
	}
	if manage.Status == model.ManageStatusDisabled {
		return nil
	}
	if mysql.Db.Model(&manage).UpdateColumn("status", model.ManageStatusDisabled).Error != nil {
		return errors.New("停用失败")
	}
	return nil
}

// Select @Title 用户筛选
func (m *manageLogic) Select() (result []bean.SelectItem) {
	result = []bean.SelectItem{}
	var manages []model.Manage
	mysql.Db.Find(&manages)
	for _, manage := range manages {
		result = append(result, bean.SelectItem{
			Id:   manage.Id,
			Name: manage.Name,
		})
	}
	return
}