pm/services/admin/auth.go

package admin

import (
	"errors"
	"fmt"
	"strings"
	"zhiyuan/models"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/redis"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/dept"
)

const AUTH_CACHE_KEY = "auth_list_"
const DATA_AUTH_CACHE_KEY = "data_auth_list_"

var Role models.Role
var Auth models.Auth

func IsSuperAdmin(id int) bool {
	return id == 1
}

func CheckAuth(authArr []string, id int) bool {
	admin, _ := GetInfoByID(id, nil, nil)
	if admin == nil {
		return false
	}
	if IsSuperAdmin(admin.ID) {
		return true
	}

	authList, err := GetAuth(admin.ID)
	if err != nil || len(authList) == 0 {
		return false
	}
	for _, v := range authArr {
		if !utils.IsContain(authList, v) {
			return false
		}
	}
	return true
}

func GetAuth(id int) ([]string, error) {
	admin, _ := GetInfoByID(id, nil, nil)
	if admin == nil {
		return []string{}, errors.New("empty admin info")
	}
	cacheKey := AUTH_CACHE_KEY + utils.ToStr(admin.ID)
	authList, err := redis.SMembers(cacheKey)
	if admin.RefreshAuth == 1 || err != nil || authList == nil || len(authList) == 0 {
		authListTemp := UpdateAuth(admin)
		authList = make([]string, 0)
		for _, v := range authListTemp {
			authList = append(authList, fmt.Sprint(v))
		}
		db.Update(Admin.TableName(), map[string]interface{}{"id": admin.ID}, map[string]interface{}{"refresh_auth": 0})
	}
	return authList, nil
}

func GetDataAuth(id int) (int, error) {
	admin, _ := GetInfoByID(id, nil, nil)
	if admin == nil {
		return 1, errors.New("empty admin info")
	}
	if IsSuperAdmin(admin.ID) {
		return 99, nil
	}
	cacheKey := DATA_AUTH_CACHE_KEY + utils.ToStr(admin.ID)
	roleSlice := strings.Split(admin.RoleIds, ",")
	res, err := redis.Get(cacheKey)
	dataAuth := utils.ToInt(res)
	if admin.RefreshDataAuth == 1 || err != nil {
		dataAuth = 1
		if len(roleSlice) > 0 {
			roleTemp, err := Role.GetOne(map[string]interface{}{"id in": roleSlice, "_orderby": "data_auth desc"}, []string{"data_auth"}, nil)
			if err != nil {
				return 1, err
			}
			dataAuth = utils.ToInt(roleTemp.DataAuth)
			db.Update(Admin.TableName(), map[string]interface{}{"id": admin.ID}, map[string]interface{}{"refresh_data_auth": 0})
		}
		redis.Set(cacheKey, dataAuth, 3600)
	}
	return dataAuth, nil
}

func GetAdminByDataAuth(adminId int) ([]int, error) {
	admin, err := GetInfoByID(adminId, nil, nil)
	if err != nil {
		return nil, err
	}
	dataAuth, err := GetDataAuth(admin.ID)
	if err != nil {
		return nil, err
	}
	if dataAuth == 1 {
		return []int{admin.ID}, nil
	} else if dataAuth == 99 {
		return []int{-1}, nil
	}

	if admin.DeptID <= 0 {
		return nil, nil
	}
	deptIds := make([]int, 0)
	adminIds := make([]int, 0)

	if dataAuth == 2 {
		deptIds = append(deptIds, admin.DeptID)
	} else if dataAuth == 3 {
		deptIds = dept.GetSubDeptIds(admin.DeptID, []int{admin.DeptID})
	}
	adminList, err := GetAdmins(map[string]interface{}{"dept_id in": deptIds}, []string{"id", "dept_id"}, app.Page{}, nil)
	if err != nil {
		return nil, err
	}
	for _, adminItem := range adminList {
		adminIds = append(adminIds, adminItem.ID)
	}
	return adminIds, nil
}

func UpdateAuth(admin *models.Admin) []interface{} {
	authList := make([]interface{}, 0)
	if IsSuperAdmin(admin.ID) {
		authListTemp, _ := Auth.GetMulti(nil, []string{"auth"}, nil)
		for _, v := range authListTemp {
			authList = append(authList, v.Auth)
		}
	} else {
		roleSlice := strings.Split(admin.RoleIds, ",")
		roleListTemp, _ := Role.GetMulti(map[string]interface{}{"id in": roleSlice}, []string{"auth_list"}, nil)
		for _, v := range roleListTemp {
			authListSlice := strings.Split(v.AuthList, ",")
			for _, vv := range authListSlice {
				authList = utils.AppendUniqueInterface(authList, vv)
			}
		}
	}
	cacheKey := AUTH_CACHE_KEY + utils.ToStr(admin.ID)
	if len(authList) == 0 {
		authList = append(authList, "empty")
	}
	redis.SAdd(cacheKey, authList, -1)
	return authList
}

func ClearAuthCacheByRole(id int) {
	if adminList, err := GetAdminsRaw(map[string]string{"where": "find_in_set({{role_id}}, role_ids)"}, map[string]interface{}{"role_id": id}, nil); err == nil {
		for _, v := range adminList {
			redis.Del(AUTH_CACHE_KEY + utils.ToStr(v.ID))
			redis.Del(DATA_AUTH_CACHE_KEY + utils.ToStr(v.ID))
		}
	}
}

func ClearAuthCacheByAdmin(id int) {
	redis.Del(AUTH_CACHE_KEY + utils.ToStr(id))
	redis.Del(DATA_AUTH_CACHE_KEY + utils.ToStr(id))
}

func ClearAuthAll() {
	db.Update(Admin.TableName(), map[string]interface{}{"id >": 0}, map[string]interface{}{"refresh_auth": 1, "refresh_data_auth": 1})
}