Cold_Api/models/Account/Menu.go

package Account

import (
	"Cold_Api/conf"
	"Cold_Api/logs"
	"Cold_Api/models"
	"encoding/json"
	"fmt"
	"github.com/astaxie/beego/cache"
	_ "github.com/astaxie/beego/cache/redis"
	"github.com/beego/beego/v2/adapter/orm"
	orm2 "github.com/beego/beego/v2/client/orm"
	"strconv"
	"time"
)

type Menu struct {
	Id           int    `orm:"column(ID);size(11);auto;pk"`
	T_mid        int    `orm:"size(200);null"`      // 上一级 ID
	T_name       string `orm:"size(256);null"`      // 菜单标题
	T_permission string `orm:"size(256);null"`      // 权限表示
	T_icon       string `orm:"size(256);null"`      // 图标
	T_sort       int    `orm:"size(11);default(0)"` // 排序 越小的越靠前，可以为负数
	T_pid        int    `orm:"size(2);default(0)"`  // 1 进入公司后才能访问的菜单 0 公共菜单
	T_State      int    `orm:"size(2);default(1)"`  // 0删除 1正常 2共有菜单
	Children     []Menu `orm:"-"`
}

func (t *Menu) TableName() string {
	return "menu" // 数据库名称   // ************** 替换 FormulaList **************
}

type API struct {
	Id        int    `orm:"column(ID);size(11);auto;pk"`
	T_Menu_Id int    `orm:"size(11);null"`      // 所属菜单id 0 第一级菜单
	T_name    string `orm:"size(256);null"`     // 接口名称
	T_uri     string `orm:"size(256);null"`     // 接口路径
	T_method  string `orm:"size(256);null"`     // http请求类型 GET,POST,PUT,DELETE 等
	T_enable  int    `orm:"size(2);default(1)"` // 是否启用 0-禁用 1-启用
}

func (t *API) TableName() string {
	return "api" // 数据库名称   // ************** 替换 FormulaList **************
}

// var redisCache_Menu cache.Cache
var redisCache_API cache.Cache
var redisCache_Menu cache.Cache

func init() {
	//注册模型
	orm.RegisterModel(new(Menu))
	orm.RegisterModel(new(API))
	var err error
	menuConfig := fmt.Sprintf(`{"key":"%s","conn":"%s","dbNum":"%s","password":"%s"}`,
		"redis_User_Menu", conf.Redis_address, conf.Redis_dbNum, conf.Redis_password)
	fmt.Println(menuConfig)
	redisCache_Menu, err = cache.NewCache("redis", menuConfig)
	if err != nil || redisCache_Menu == nil {
		logs.Error("Redis Menu init err", err)
	}

	apiConfig := fmt.Sprintf(`{"key":"%s","conn":"%s","dbNum":"%s","password":"%s"}`,
		"redis_User_API", conf.Redis_address, conf.Redis_dbNum, conf.Redis_password)
	fmt.Println(apiConfig)
	redisCache_API, err = cache.NewCache("redis", apiConfig)
	if err != nil || redisCache_API == nil {
		logs.Error("Redis API init err", err)
	}
}

// ---------------- Redis -------------------
func Redis_API_Set(Power_Id int, r []API) (err error) {
	//json序列化
	str, err := json.Marshal(r)
	if err != nil {
		logs.Error("json Marshal err", err)
		return
	}

	err = redisCache_API.Put(strconv.Itoa(Power_Id), str, 24*time.Hour)
	if err != nil {
		logs.Error("Redis_API_Set", "set key:", strconv.Itoa(Power_Id), ",value:", str, err)
	}
	return
}

func Redis_API_Get(key string) (r []API, is bool) {
	if redisCache_API.IsExist(key) {
		//println("找到key:",key)
		v := redisCache_API.Get(key)

		err := json.Unmarshal(v.([]byte), &r)
		if err != nil {
			logs.Error("json Unmarshal err", err)
			return []API{}, false
		}
		return r, true
	}
	//println("没有 找到key:",key)
	return []API{}, false
}

func Redis_API_DelK(key string) (err error) {
	err = redisCache_API.Delete(key)
	if err != nil {
		logs.Error("Redis_API_DelK", err)
	}
	return
}

func Redis_Munu_Set(Power_Id, T_pid int, r []Menu) (err error) {
	//json序列化
	str, err := json.Marshal(r)
	if err != nil {
		fmt.Println(err)
		return
	}
	keys := strconv.Itoa(Power_Id) + "-Pid"
	if T_pid == 0 {
		keys = strconv.Itoa(Power_Id)
	}

	err = redisCache_Menu.Put(keys, str, 30*24*time.Hour)
	if err != nil {
		logs.Error("set key:", strconv.Itoa(Power_Id)+"|"+strconv.Itoa(T_pid), ",value:", str, err)
	}
	return
}

func Redis_Menu_Get(Power_Id, T_pid int) (r []Menu, is bool) {
	key := strconv.Itoa(Power_Id) + "-Pid"
	if T_pid == 0 {
		key = strconv.Itoa(Power_Id)
	}
	if redisCache_Menu.IsExist(key) {
		//println("找到key:",key)
		v := redisCache_Menu.Get(key)

		err := json.Unmarshal(v.([]byte), &r)
		if err != nil {
			logs.Error("json Unmarshal err", err)
			return []Menu{}, false
		}
		return r, true
	}
	//println("没有 找到key:",key)
	return []Menu{}, false
}

func Redis_Menu_DelK(Power_Id int) (err error) {
	err = redisCache_Menu.Delete(strconv.Itoa(Power_Id))
	if err != nil {
		logs.Error("Redis_Menu_DelK", err)
		return
	}
	err = redisCache_Menu.Delete(strconv.Itoa(Power_Id) + "-Pid")
	if err != nil {
		logs.Error("Redis_Menu_DelK Pid", err)
	}
	return
}

// ---------------- 特殊方法 -------------------

// 添加
func Add_Menu(m Menu) (id int64, err error) {
	o := orm.NewOrm()
	// 插入菜单信息
	id, err = o.Insert(&m)
	if err != nil {
		fmt.Println(err)
	}
	return id, err
}

// 修改
func Update_Menu(m Menu, cols ...string) bool {
	o := orm.NewOrm()
	if num, err := o.Update(&m, cols...); err == nil {
		fmt.Println("Number of records updated in database:", num)
		return true
	}
	return false
}

// 删除
func Delete_Menu(m Menu) bool {
	o := orm.NewOrm()
	if num, err := o.Delete(&m); err == nil {
		fmt.Println("Number of records updated in database:", num)
	} else {
		return false
	}
	return true
}

// 获取 ById
func Read_Menu_ById(Id int) (r Menu, e error) {
	o := orm.NewOrm()
	qs := o.QueryTable(new(Menu))
	e = qs.Filter("Id", Id).One(&r)
	return r, e
}

// 获取列表
func Read_Menu_Bind_List(Power_Id int, Bind_Menu string, T_pid int) (maps []Menu) {
	if r, is := Redis_Menu_Get(Power_Id, T_pid); is {
		return r
	}

	o := orm.NewOrm()
	// 也可以直接使用 Model 结构体作为表名

	qs := o.QueryTable(new(Menu))
	cond := orm.NewCondition()
	cond = cond.And("T_State__gt", 0)
	if T_pid == 0 {
		cond = cond.And("T_pid", 0)
	}
	if Bind_Menu == "*" {
		_, err := qs.SetCond((*orm2.Condition)(cond)).OrderBy("T_sort", "Id").All(&maps)
		if err != nil {
			logs.Error("Read_Menu_Bind_List", err)
			return
		}
		m := Menu_Call(maps, 0)
		Redis_Munu_Set(Power_Id, T_pid, m)
		return m
	}

	list := models.SplitStringToIntIds(Bind_Menu, "M")
	AllIds := list
	if err := recursiveMenu(T_pid, list, &AllIds); err != nil {
		return maps
	}

	cond = cond.And("Id__in", models.IntIdsDistinct(AllIds)).Or("T_State", 2)

	_, err := qs.SetCond((*orm2.Condition)(cond)).OrderBy("T_sort", "Id").All(&maps)
	if err != nil {
		logs.Error("Read_Menu_Bind_List", err)
		return
	}

	m := Menu_Call(maps, 0)

	Redis_Munu_Set(Power_Id, T_pid, m)
	return m
}

// 获取MenuIds下父id
func recursiveMenu(T_pid int, MenuIds []int, AllIds *[]int) error {
	if len(MenuIds) == 0 {
		return nil
	}
	var subMenus []Menu
	o := orm.NewOrm()
	qs := o.QueryTable(new(Menu))
	cond := orm.NewCondition()
	if T_pid == 0 {
		cond = cond.And("T_pid", 0)
	}
	cond = cond.And("Id__in", MenuIds)

	_, err := qs.SetCond((*orm2.Condition)(cond)).OrderBy("T_sort", "Id").All(&subMenus)
	if err != nil {
		logs.Error("recursiveMenu", err)
		return err
	}

	subIds := make([]int, 0)
	for _, menu := range subMenus {
		if menu.T_mid != 0 {
			subIds = append(subIds, menu.T_mid)
			*AllIds = append(*AllIds, menu.T_mid)
		}
	}
	return recursiveMenu(T_pid, subIds, AllIds)
}

func Read_Menu_List_All() (maps []Menu, menu_ids []int) {

	o := orm.NewOrm()
	// 也可以直接使用 Model 结构体作为表名

	qs := o.QueryTable(new(Menu))
	_, err := qs.Filter("T_State", 1).OrderBy("Id", "-T_sort").All(&maps)
	if err != nil {
		logs.Error("Read_Menu_List_All", err)
		return
	}
	for _, v := range maps {
		menu_ids = append(menu_ids, v.Id)
	}
	m := Menu_Call(maps, 0)

	return m, menu_ids
}

// Menu_Call 构建菜单树
// [{"Id":70,"T_mid":0,"T_name":"工单管理","T_permission":"workorder","T_sort":0,"T_pid":1,"T_bind":false,"Children":[{"Id":71,"T_mid":70,"T_name":"工单列表","T_permission":"workorder:list","T_sort":0,"T_pid":1,"T_bind":false,"Children":[]}]}]
func Menu_Call(list []Menu, parentId int) []Menu {
	res := make([]Menu, 0)
	for _, v := range list {
		if v.T_mid == parentId {
			v.Children = Menu_Call(list, v.Id)
			res = append(res, v)
		}
	}
	return res
}

// 添加
func Add_API(m API) (id int64, err error) {
	o := orm.NewOrm()
	id, err = o.Insert(&m)
	if err != nil {
		fmt.Println(err)
	}
	m.Id = int(id)
	return id, err
}

// 批量添加
func Add_Multi_API(m []API) (id int64, err error) {
	o := orm.NewOrm()
	id, err = o.InsertMulti(len(m), &m)
	if err != nil {
		fmt.Println(err)
	}
	return id, err
}

// 修改
func Update_API(m API, cols ...string) bool {
	o := orm.NewOrm()
	if num, err := o.Update(&m, cols...); err == nil {
		fmt.Println("Number of records updated in database:", num)
		return true
	}
	return false
}

// 删除
func Delete_API(m API) bool {
	o := orm.NewOrm()
	if num, err := o.Delete(&m); err == nil {
		fmt.Println("Number of records updated in database:", num)
	} else {
		return false
	}
	return true
}

// 批量删除
func Delete_Multi_API(m []API) bool {
	o := orm.NewOrm()
	if num, err := o.Delete(&m); err == nil {
		fmt.Println("Number of records updated in database:", num)
	} else {
		return false
	}
	return true
}

// 获取 ById
func Read_API_ById(Id int) (r API, e error) {
	o := orm.NewOrm()
	qs := o.QueryTable(new(API))
	e = qs.Filter("Id", Id).Filter("T_State", 1).One(&r)
	return r, e
}

// 获取列表
func Read_API_List_ByPower_Id(Power_Id int, Menu_Bind string) (maps []API) {

	if r, is := Redis_API_Get(strconv.Itoa(Power_Id)); is {
		//println("Redis_Get  OK")
		return r
	}

	o := orm.NewOrm()
	// 也可以直接使用 Model 结构体作为表名

	qs := o.QueryTable(new(API))

	list := models.SplitStringIds(Menu_Bind, "M")
	_, err := qs.Filter("T_Menu_Id__in", list).All(&maps)
	if err != nil {
		logs.Error("Read_API_List_ByPower_Id", err)
		return
	}
	Redis_API_Set(Power_Id, maps)
	return maps
}

func Read_API_List_By_Menu_Bind(Menu_Bind string) (maps []API) {
	o := orm.NewOrm()
	// 也可以直接使用 Model 结构体作为表名

	qs := o.QueryTable(new(API))

	list := models.SplitStringIds(Menu_Bind, "M")
	_, err := qs.Filter("T_Menu_Id__in", list).All(&maps)
	if err != nil {
		logs.Error("Read_API_List_By_Menu_Bind", err)
	}

	return maps
}