Cold_Api/models/Account/Power.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"
	"strconv"
	"strings"
	"time"
)

type Power struct {
	Id         int       `orm:"column(ID);size(11);auto;pk"`
	T_code     string    `orm:"size(256);null"`                                        //  唯一编码
	T_name     string    `orm:"size(256);null"`                                        //  权限名称
	T_select   string    `orm:"size(256);null"`                                        //  Account.Power.Id S1|S2|
	T_warning  string    `orm:"size(256);null"`                                        //  Warning.WarningType.Id W1|W2|W3|W4|W5|
	T_menu     string    `orm:"size(256);null"`                                        //  Account.Menu.Id 设备通知策略  M1|M2|
	T_State    int       `orm:"size(2);default(1)"`                                    //  0删除  1 正常
	CreateTime time.Time `orm:"column(create_time);type(timestamp);null;auto_now_add"` //auto_now 每次 model 保存时都会对时间自动更新
	UpdateTime time.Time `orm:"column(update_time);type(timestamp);null;auto_now"`     //auto_now_add 第一次保存时才设置时间
}

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

type Power_R struct {
	Id      int
	T_name  string //  权限名称
	T_check bool   // 是否勾选
}

type Power_ struct {
	Id         int
	T_name     string // 权限名称
	UpdateTime string // 修改时间
}

func PowerToPower_R(r Power, T_select string) (v Power_R) {
	v.Id = r.Id
	v.T_name = r.T_name
	if strings.Contains(T_select, "S"+strconv.Itoa(v.Id)+"|") || T_select == "*" {
		v.T_check = true
	}
	return v
}

func PowerToPower_(r Power) (v Power_) {
	v.Id = r.Id
	v.T_name = r.T_name
	v.UpdateTime = r.UpdateTime.Format("2006-01-02 15:04:05")
	return v
}

var redisCache_Power cache.Cache

var Power_list map[int]string // 泛型

func init() {
	//注册模型
	orm.RegisterModel(new(Power))
	Power_list = make(map[int]string)

	config := fmt.Sprintf(`{"key":"%s","conn":"%s","dbNum":"%s","password":"%s"}`,
		"redis_User_Power", conf.Redis_address, conf.Redis_dbNum, conf.Redis_password)
	fmt.Println(config)
	var err error
	redisCache_Power, err = cache.NewCache("redis", config)
	if err != nil || redisCache_Power == nil {
		logs.Error("Redis Power init err", err)
	}

}

// ---------------- Redis -------------------
// Redis_Set(m.T_sn,m) // Redis 更新缓存
func Redis_Power_Set(r Power) (err error) {
	//json序列化
	str, err := json.Marshal(r)
	if err != nil {
		logs.Error("json Marshal err", err)
		return
	}

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

// if r,is :=Redis_Get(T_sn);is{
// return r,nil
// }
func Redis_Power_Get(key string) (r Power, is bool) {
	if redisCache_Power.IsExist(key) {
		//println("找到key:",key)
		v := redisCache_Power.Get(key)

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

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

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

// 添加
func Add_Power(m Power) (id int64, err error) {
	o := orm.NewOrm()

	// 生成编号
	rand_x := 0
	for true {
		m.T_code = models.GetRandstring(6, "", int64(rand_x)) // 1,336,336
		err := o.Read(&m, "T_code")                           // o.Read(&r,"Tokey") 如果不是 主键 就得指定字段名
		if err != nil {
			break
		}
		rand_x += 1
	}

	id, err = o.Insert(&m)
	if err != nil {
		logs.Error("Add_Power", err)
		return id, err
	}
	Redis_API_Set(int(id), Read_API_List_By_Menu_Bind(m.T_menu))
	Redis_Power_Set(m)

	return id, err
}

// 获取 ById
func Read_Power_ById(Id int) (r Power, err error) {
	if r, is := Redis_Power_Get(strconv.Itoa(Id)); is {
		//println("Redis_Get  OK")
		return r, nil
	}

	o := orm.NewOrm()
	r = Power{Id: Id, T_State: 1}
	err = o.Read(&r, "Id", "T_State") // o.Read(&r,"Tokey") 如果不是 主键 就得指定字段名
	if err != nil {
		logs.Error("Read_Power_ById", err)
		return
	}
	Redis_Power_Set(r)

	return r, err
}

// 获取列表
func Read_Power_List(T_name string, page int, page_z int) (r []Power_, cnt int64) {

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

	qs := o.QueryTable(new(Power))
	var maps []Power
	var offset int64
	if page <= 1 {
		offset = 0
	} else {
		offset = int64((page - 1) * page_z)
	}

	_, err := qs.Limit(page_z, offset).Filter("T_name__icontains", T_name).Filter("T_State", 1).OrderBy("Id").All(&maps)
	if err != nil {
		logs.Error("Read_Power_List", err)
		return
	}
	cnt, err = qs.Filter("T_name__icontains", T_name).Filter("T_State", 1).Count()
	if err != nil {
		logs.Error("Read_Power_List Count", err)
		return
	}
	for _, v := range maps {
		r = append(r, PowerToPower_(v))
	}
	return r, cnt
}

// 添加用户 - 权限选择列表
func Read_Power_List_ALL_User(T_select string) (r []Power_) {

	o := orm.NewOrm()
	// 也可以直接使用 Model 结构体作为表名
	var maps []Power
	var err error
	qs := o.QueryTable(new(Power))

	if T_select == "*" {
		_, err = qs.Filter("Id__gt", 1).Filter("T_State", 1).OrderBy("Id").All(&maps)
	} else {
		list := models.SplitStringIds(T_select, "S")
		_, err = qs.Filter("Id__in", list).Filter("T_State", 1).OrderBy("Id").All(&maps)
	}
	if err != nil {
		logs.Error("Read_Power_List_ALL_User", err)
		return
	}
	for _, v := range maps {
		r = append(r, PowerToPower_(v))
	}
	return r
}

// 获取列表
func Read_Power_List_ALL_T_select(T_select string) (r []Power_R) {

	o := orm.NewOrm()
	// 也可以直接使用 Model 结构体作为表名
	var maps []Power
	qs := o.QueryTable(new(Power))
	_, err := qs.Filter("Id__gt", 1).Filter("T_State", 1).OrderBy("Id").All(&maps)
	if err != nil {
		logs.Error("Read_Power_List_ALL_T_select", err)
		return
	}
	for _, v := range maps {
		r = append(r, PowerToPower_R(v, T_select))
	}
	return r
}

// 修改
func Update_Power(v Power, cols ...string) bool {
	o := orm.NewOrm()
	num, err := o.Update(&v, cols...)
	if err != nil {
		logs.Error("Update_Power", err)
		return false
	}
	fmt.Println("Number of records updated in database:", num)
	Redis_API_Set(v.Id, Read_API_List_By_Menu_Bind(v.T_menu))
	Redis_Power_Set(v)    // Redis 更新缓存
	Redis_Menu_DelK(v.Id) // 删除菜单缓存
	return true
}

// 删除
func Delete_Power(v Power) bool {
	o := orm.NewOrm()
	v.T_State = 0
	num, err := o.Update(&v, "T_State")
	if err != nil {
		logs.Error("Delete_Power", err)
		return false
	}
	fmt.Println("Number of records updated in database:", num)
	Redis_Menu_DelK(v.Id)                // 删除菜单缓存
	Redis_API_DelK(strconv.Itoa(v.Id))   // Redis 删除API缓存
	Redis_Power_DelK(strconv.Itoa(v.Id)) // Redis 删除缓存
	return true
}

// 获取全部
func Read_Power_All_Map() {
	o := orm.NewOrm()
	var r []Power
	qs := o.QueryTable(new(Power))
	_, err := qs.All(&r)
	if err != nil {
		logs.Error("Read_Power_All_Map", err)
		return
	}

	for _, v := range r {
		Power_list[v.Id] = v.T_name
	}

}
func Read_Power_Get(Id int) string {
	// 有先加入 给全部人发消息
	v, ok := Power_list[Id] /*如果确定是真实的,则存在,否则不存在 */
	if ok {
		return v
	} else {
		return ""
	}
}