ERP_libs/Menu/API.go

package Menu

import (
	"encoding/json"
	"errors"
	"time"

	"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"
	"gogs.baozhida.cn/zoie/ERP_libs/lib"
)

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);default(POST)"` // http请求类型 GET,POST,PUT,DELETE 等
	T_enable  int    `orm:"size(2);default(1)"`      // 是否启用 0-禁用 1-启用
}

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

func NewAPI(orm orm.Ormer, redis cache.Cache) *APIDaoImpl {
	return &APIDaoImpl{orm: orm, redis: redis}
}

type APIDaoImpl struct {
	orm   orm.Ormer
	redis cache.Cache
}

func (m *APIDaoImpl) Redis_API_Set(key string, r []API) (err error) {
	//json序列化
	b, err := json.Marshal(r)
	if err != nil {
		return
	}

	err = m.redis.Put(key, b, 24*time.Hour)
	return
}

func (m *APIDaoImpl) Redis_API_Get(key string) (r []API, err error) {
	if m.redis.IsExist(key) {
		//println("找到key:",key)
		v := m.redis.Get(key)

		err = json.Unmarshal(v.([]byte), &r)
		return
	}
	return r, errors.New("key not exist: " + key)
}

func (m *APIDaoImpl) Redis_API_DelK(key string) (err error) {
	return m.redis.Delete(key)
}

// 获取列表
func (m *APIDaoImpl) Read_API_List_ByPower(T_power_id string, Menu_Bind string) (maps []API, err error) {

	if maps, err = m.Redis_API_Get(T_power_id); err == nil {
		return maps, nil
	}

	// 也可以直接使用 Model 结构体作为表名

	qs := m.orm.QueryTable(new(API))

	list := lib.SplitStringToIntIds(Menu_Bind, "M")
	AllIds := list
	if err = m.recursiveMenu(list, &AllIds); err != nil {
		return
	}
	_, err = qs.Filter("T_Menu_Id__in", list).All(&maps)
	if err != nil {
		return
	}
	m.Redis_API_Set(T_power_id, maps)
	return maps, nil
}

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

	_, err := qs.SetCond((*orm2.Condition)(cond)).OrderBy("T_sort", "Id").All(&subMenus)
	if err != nil {
		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 m.recursiveMenu(subIds, AllIds)
}

// 获取 ById
func (m *APIDaoImpl) Read_API_ById(id int) (r API, err error) {
	r.Id = id
	err = m.orm.Read(&r)
	return r, err
}

// 获取 ByMenuId - 根据菜单ID获取API列表
func (m *APIDaoImpl) Read_API_List_ByMenuId(T_Menu_Id int) (maps []API, err error) {
	qs := m.orm.QueryTable(new(API))
	_, err = qs.Filter("T_Menu_Id", T_Menu_Id).Filter("T_enable", 1).All(&maps)
	return maps, err
}

// 添加
func (m *APIDaoImpl) Add_API(r API) (id int64, err error) {
	if r.T_enable == 0 {
		r.T_enable = 1
	}
	if len(r.T_method) == 0 {
		r.T_method = "POST"
	}
	id, err = m.orm.Insert(&r)
	return id, err
}

// 批量添加
func (m *APIDaoImpl) InsertMulti_API(r []API) (id int64, err error) {
	id, err = orm.NewOrm().InsertMulti(len(r), r)
	return
}

// 修改
func (m *APIDaoImpl) Update_API(r API, cols ...string) (int64, error) {
	if len(cols) == 0 {
		return m.orm.Update(&r, "T_name", "T_uri", "T_method", "T_enable")
	}
	return m.orm.Update(&r, cols...)
}

// 删除（软删除，设置 T_enable = 0）
func (m *APIDaoImpl) Delete_API(r API) (int64, error) {
	r.T_enable = 0
	return m.orm.Update(&r, "T_enable")
}

// 根据菜单ID删除所有关联的API（软删除）
func (m *APIDaoImpl) Delete_API_ByMenuId(T_Menu_Id int) (int64, error) {
	qs := m.orm.QueryTable(new(API))
	return qs.Filter("T_Menu_Id", T_Menu_Id).Filter("T_enable", 1).Update(orm2.Params{"T_enable": 0})
}