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_check      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 **************
}

// 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_Bind_List(Bind_Menu string) (maps []Menu) {

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

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

func Read_Menu_List_All() (maps []Menu) {

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

	qs := o.QueryTable(new(Menu))
	qs.OrderBy("-T_sort").All(&maps)
	m := Menu_Call(maps, 0)

	return m
}

func Read_Menu_List_All_T_Menu(T_Menu string) (maps []Menu) {

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

	qs := o.QueryTable(new(Menu))
	qs.OrderBy("-T_sort").All(&maps)
	m := Bind_Menu_Call(maps, 0, T_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, "M")
		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_check = 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 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")
	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, "M")
	qs.Filter("T_Menu_Id__in", list).All(&maps)

	return maps
}