ERP_user/models/Account/Menu.go

package Account

import (
	"ERP_user/conf"
	"encoding/json"
	"fmt"
	"time"

	"github.com/astaxie/beego/cache"
	_ "github.com/astaxie/beego/cache/redis"
	"github.com/astaxie/beego/logs"
	"github.com/beego/beego/v2/adapter/orm"
	menulibs "gogs.baozhida.cn/zoie/ERP_libs/Menu"
	powerlibs "gogs.baozhida.cn/zoie/ERP_libs/Power"
	"gogs.baozhida.cn/zoie/ERP_libs/lib"
)

var redisCache_API cache.Cache
var redisCache_Menu cache.Cache

func init() {
	//注册模型
	orm.RegisterModel(new(menulibs.Menu))
	orm.RegisterModel(new(menulibs.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 {
		errMsg := "failed to init redis menu"
		logs.Error(errMsg, err)
		panic(errMsg)
	}

	apiConfig := fmt.Sprintf(`{"key":"%s","conn":"%s","dbNum":"%s","password":"%s"}`,
		"redis_ERP_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 {
		errMsg := "failed to init redis api"
		logs.Error(errMsg, err)
		panic(errMsg)
	}
}

func Redis_Munu_Set(T_power_id string, r []menulibs.Menu) (err error) {
	//json序列化
	str, err := json.Marshal(r)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return
	}

	err = redisCache_Menu.Put(T_power_id, str, 24*time.Hour)
	if err != nil {
		logs.Error("set key:", T_power_id+",value:", str, err)
	}
	return
}

func Redis_Menu_Get(T_power_id string) (r []menulibs.Menu, is bool) {
	if redisCache_Menu.IsExist(T_power_id) {
		//println("找到key:",key)
		v := redisCache_Menu.Get(T_power_id)

		err := json.Unmarshal(v.([]byte), &r)
		if err != nil {
			logs.Error(lib.FuncName(), err)
			return r, false
		}
		return r, true
	}
	return r, false
}

func Redis_Menu_DelK(T_power_id string) (err error) {
	err = redisCache_Menu.Delete(T_power_id)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return
	}
	return
}

// Redis_Menu_DelAll 清除所有菜单缓存
func Redis_Menu_DelAll() (err error) {
	o := orm.NewOrm()
	powerDao := powerlibs.NewPower(o)

	// 获取所有权限ID列表（不分页，获取全部）
	// 使用较大的page_z值来获取所有权限
	powerList, _ := powerDao.Read_Power_List("", 1, 9999) // 假设最多10000个权限

	// 遍历所有权限ID，逐个删除缓存
	for _, power := range powerList {
		err = Redis_Menu_DelK(power.T_id)
		if err != nil {
			logs.Error(lib.FuncName(), "删除缓存失败:", power.T_id, err)
			// 继续删除其他缓存，不中断
		}
	}

	return nil
}

func Read_Menu_List() ([]menulibs.Menu, error) {
	o := orm.NewOrm()
	MenuDao := menulibs.NewMenu(o)
	m, err := MenuDao.Read_Menu_List()
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return nil, err
	}

	return m, nil
}

// Read_User_Bind_Menu_List 获取用户绑定的菜单列表
func Read_User_Bind_Menu_List(T_Menu string) ([]menulibs.Menu, error) {
	o := orm.NewOrm()
	MenuDao := menulibs.NewMenu(o)
	m, err := MenuDao.Read_Menu_List_ByPower_T_Menu(T_Menu)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return nil, err
	}

	return m, nil
}

// 获取列表
func Read_API_List_ByPower(T_power_id string, Menu_Bind string) (maps []menulibs.API) {
	if len(Menu_Bind) == 0 {
		return
	}
	o := orm.NewOrm()
	APIDao := menulibs.NewAPI(o, redisCache_API)
	maps, err := APIDao.Read_API_List_ByPower(T_power_id, Menu_Bind)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return
	}
	return maps
}

// 添加菜单
func Add_Menu(r menulibs.Menu) (id int, err error) {
	o := orm.NewOrm()
	_, err = o.Insert(&r)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return 0, err
	}
	return r.Id, err
}

// 获取菜单 ById
func Read_Menu_ById(id int) (r menulibs.Menu, err error) {
	o := orm.NewOrm()
	r.Id = id
	err = o.Read(&r)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return r, err
	}
	return r, nil
}

// 修改菜单
func Update_Menu(r menulibs.Menu, cols ...string) (id int, err error) {
	o := orm.NewOrm()

	_, err = o.Update(&r, cols...)

	if err != nil {
		logs.Error(lib.FuncName(), err)
		return r.Id, err
	}
	return r.Id, err
}

// 删除菜单（软删除，设置 T_State = 0）
func Delete_Menu(r menulibs.Menu) (id int, err error) {
	o := orm.NewOrm()
	r.T_State = 0 // 软删除
	_, err = o.Update(&r, "T_State")
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return r.Id, err
	}
	return r.Id, err
}

// ========== API 相关方法 ==========

// 根据菜单ID获取API列表
func Read_API_List_ByMenuId(T_Menu_Id int) (maps []menulibs.API, err error) {
	o := orm.NewOrm()
	APIDao := menulibs.NewAPI(o, redisCache_API)
	maps, err = APIDao.Read_API_List_ByMenuId(T_Menu_Id)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return maps, err
	}
	return maps, nil
}

// 批量添加API
func InsertMulti_API(r []menulibs.API) (id int64, err error) {
	o := orm.NewOrm()
	APIDao := menulibs.NewAPI(o, redisCache_API)
	id, err = APIDao.InsertMulti_API(r)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return 0, err
	}
	return id, err
}

// 根据菜单ID删除所有关联的API（软删除）
func Delete_API_ByMenuId(T_Menu_Id int) (int64, error) {
	o := orm.NewOrm()
	APIDao := menulibs.NewAPI(o, redisCache_API)
	cnt, err := APIDao.Delete_API_ByMenuId(T_Menu_Id)
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return 0, err
	}
	return cnt, err
}

// Redis_API_DelAll 清除所有API缓存
func Redis_API_DelAll() (err error) {
	o := orm.NewOrm()
	powerDao := powerlibs.NewPower(o)

	// 获取所有权限ID列表（不分页，获取全部）
	// 使用较大的page_z值来获取所有权限
	powerList, _ := powerDao.Read_Power_List("", 1, 9999) // 假设最多10000个权限

	// 遍历所有权限ID，逐个删除API缓存
	APIDao := menulibs.NewAPI(o, redisCache_API)
	for _, power := range powerList {
		err = APIDao.Redis_API_DelK(power.T_id)
		if err != nil {
			logs.Error(lib.FuncName(), "删除API缓存失败:", power.T_id, err)
			// 继续删除其他缓存，不中断
		}
	}

	return nil
}