Cold_Api/models/Account/Menu.go

package Account

import (
	"Cold_Api/conf"
	"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"
	"strings"
	"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_sort       int    `orm:"size(11);null"`      // 排序
	T_pid        int    `orm:"size(2);default(0)"` // 1 进入公司后才能访问的菜单1，0 公共菜单
	T_bind       bool   `orm:"-"`                  // 是否选中
	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 **************
}

type Menu_R struct {
	Id       int
	T_name   string // 菜单标题
	T_mid    int    // 菜单标题
	T_pid    int
	Children map[string]Menu_R
}

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

func init() {
	//注册模型
	orm.RegisterModel(new(Menu))
	orm.RegisterModel(new(API))

	//menuConfig := fmt.Sprintf(`{"key":"%s","conn":"%s","dbNum":"%s","password":"%s"}`,
	//	"redis_Cold_User_Menu", conf.Redis_address, conf.Redis_dbNum, conf.Redis_password)
	//fmt.Println(menuConfig)
	//var err error
	//redisCache_Menu, err = cache.NewCache("redis", menuConfig)
	//if err != nil || redisCache_Menu == nil {
	//	errMsg := "failed to init redis"
	//	fmt.Println(errMsg, err)
	//}

	apiConfig := fmt.Sprintf(`{"key":"%s","conn":"%s","dbNum":"%s","password":"%s"}`,
		"redis_Cold_User_API", conf.Redis_address, conf.Redis_dbNum, conf.Redis_password)
	fmt.Println(apiConfig)
	var err error
	redisCache_API, err = cache.NewCache("redis", apiConfig)
	if err != nil || redisCache_API == nil {
		errMsg := "failed to init redis"
		fmt.Println(errMsg, err)
	}
}

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

	err = redisCache_API.Put(strconv.Itoa(Power_Id), str, 24*time.Hour)
	if err != nil {
		fmt.Println("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)

		json.Unmarshal(v.([]byte), &r)
		return r, true
	}
	//println("没有 找到key:",key)
	return []API{}, false
}

func Redis_API_DelK(key string) (err error) {
	err = redisCache_API.Delete(key)
	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_List(Grant_Menu string) (maps []Menu) {

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

	qs := o.QueryTable(new(Menu))
	if Grant_Menu == "*" {
		qs.OrderBy("-T_sort").All(&maps)
	} else {
		list := models.SplitStringIds(Grant_Menu)
		qs.Filter("Id__in", list).OrderBy("-T_sort").All(&maps)
	}
	m := Menu_Call(maps, 0)
	return m
}

func Read_Menu_Bind_List(Grant_Menu string, Bind_Menu string) (maps []Menu) {

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

	qs := o.QueryTable(new(Menu))
	if Grant_Menu == "*" {
		qs.OrderBy("-T_sort").All(&maps)
	} else {
		list := models.SplitStringIds(Grant_Menu)
		qs.Filter("Id__in", list).OrderBy("-T_sort").All(&maps)
	}
	m := Bind_Menu_Call(maps, 0, Bind_Menu)

	return m
}

// 获取左侧菜单树
func Read_Menu_Tree(Menu_Bind string, T_pid int) (MenuList []Menu) {

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

	qs := o.QueryTable(new(Menu))
	cond := orm.NewCondition()
	T_pid_list := []int{0}
	if T_pid > 0 {
		T_pid_list = append(T_pid_list, 1)
	}
	cond1 := cond.And("T_pid__in", T_pid_list)
	var maps []Menu
	if Menu_Bind != "*" {
		list := models.SplitStringIds(Menu_Bind)
		cond1 = cond1.And("Id__in", list)
	}
	qs.SetCond((*orm2.Condition)(cond1)).OrderBy("-T_sort").All(&maps)

	//m := Menu_Tree(maps, 0)
	MenuList = Menu_Call(maps, 0)
	//parentMap, flag := getMenuParent(maps)
	//if flag {
	//	for i := 0; i < len(maps); i++ {
	//		if parentMap[maps[i].T_mid] {
	//			continue
	//		}
	//		info := MenuCall(maps, maps[i])
	//		MenuList = append(MenuList, info)
	//	}
	//} else {
	//	for i := 0; i < len(maps); i++ {
	//		info := MenuCall(maps, maps[i])
	//		MenuList = append(MenuList, info)
	//	}
	//}
	return MenuList
}

// Bind_Menu_Call 构建菜单树,包含是否绑定
func Bind_Menu_Call(list []Menu, parentId int, Bind_Menu string) []Menu {
	res := make([]Menu, 0)
	for _, v := range list {
		if v.T_mid == parentId {
			if strings.Contains(Bind_Menu, strconv.Itoa(v.Id)) || Bind_Menu == "*" {
				v.T_bind = true
			}
			v.Children = Bind_Menu_Call(list, v.Id, Bind_Menu)
			res = append(res, v)
		}
	}
	return res
}

// 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 MenuCall(MenuList []Menu, company Menu) Menu {
	list := MenuList
	min := make([]Menu, 0)
	for j := 0; j < len(list); j++ {
		if company.Id != list[j].T_mid {
			continue
		}
		mi := Menu{}
		mi.Id = list[j].Id
		mi.T_mid = list[j].T_mid
		mi.T_name = list[j].T_name
		mi.Children = []Menu{}
		ms := MenuCall(MenuList, mi)
		min = append(min, ms)
	}
	company.Children = min
	return company
}

func getMenuParent(MenuList []Menu) (map[int]bool, bool) {
	list := MenuList
	var flag = false
	var parentMap = map[int]bool{}
	for j := 0; j < len(list); j++ {
		parentMap[list[j].T_mid] = false
	}

	for j := 0; j < len(list); j++ {
		if _, ok := parentMap[list[j].Id]; !ok {
			continue
		}
		parentMap[list[j].Id] = true
		flag = true
	}
	return parentMap, flag
}

// Menu_Tree 构建菜单树
// {"workorder":{"Id":70,"T_name":"工单管理","T_mid":0,"T_pid":1,"Children":{"workorder:list":{"Id":71,"T_name":"工单列表","T_mid":70,"T_pid":1,"Children":{}}}}}
func Menu_Tree(list []Menu, parentId int) map[string]Menu_R {
	res := make(map[string]Menu_R, 0)
	for _, v := range list {
		if v.T_mid == parentId {
			r := Menu_R{
				Id:     v.Id,
				T_mid:  v.T_mid,
				T_pid:  v.T_pid,
				T_name: v.T_name,
			}
			r.Children = Menu_Tree(list, v.Id)
			res[v.T_permission] = r
		}
	}
	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)
	qs.Filter("T_Menu_Id__in", list).All(&maps)

	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)
	qs.Filter("T_Menu_Id__in", list).All(&maps)

	return maps
}