Cold_Api/models/Account/Power.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"
	"math/rand"
	"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_Cold_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 {
		errMsg := "failed to init redis"
		fmt.Println(errMsg, 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 {
		fmt.Print(err)
		return
	}

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

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

func Redis_Power_DelK(key string) (err error) {
	err = redisCache_Power.Delete(key)
	return
}

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

// 修改
func Update_Power_ById_Basics(m Power) (err error) {
	o := orm.NewOrm()
	v := Power{Id: m.Id}
	// ascertain id exists in the database
	if err = o.Read(&v); err == nil {
		var num int64
		m.Id = v.Id
		if num, err = o.Update(&m, "Power_name", "Power_Administration", "Power_User_r", "Power_User_e", "Power_User_entry", "Power_Device_r", "Power_Device_a", "Power_Device_Parameter_e", "Power_DeviceSensor_Class", "Power_DeviceSensor_Parameter_e", "Power_DeviceSensor_Compensate_e", "Power_Device_Bind_e", "Power_DataScreen_r", "Logs_Sys_r", "Logs_User_r"); err == nil {
			fmt.Println("Number of records updated in database:", num)
		}
		Redis_Power_Set(m)
	}

	return err
}

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

	// 生成编号
	rand_x := 0
	for true {
		m.T_code = 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 {
		fmt.Println(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 {
		fmt.Println(err)
	} else {
		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)
	}

	qs.Limit(page_z, offset).Filter("T_name__icontains", T_name).Filter("T_State", 1).OrderBy("Id").All(&maps)
	cnt, _ = qs.Filter("T_name__icontains", T_name).Filter("T_State", 1).Count()
	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
	qs := o.QueryTable(new(Power))

	if T_select == "*" {
		qs.Filter("Id__gt", 1).Filter("T_State", 1).OrderBy("Id").All(&maps)
	} else {
		list := models.SplitStringIds(T_select, "S")
		qs.Filter("Id__in", list).Filter("T_State", 1).OrderBy("Id").All(&maps)
	}
	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))
	qs.Filter("Id__gt", 1).Filter("T_State", 1).OrderBy("Id").All(&maps)
	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()
	if num, err := o.Update(&v, cols...); err == nil {
		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 更新缓存
		return true
	}
	return false
}

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

// #取得随机字符串：通过打乱slice来操作
func GetRandString(length int, char string, rand_x int64) string {
	if length < 1 {
		return ""
	}

	if len(char) <= 6 || len(char) <= length {
		char = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
	}

	charArr := strings.Split(char, "")
	ran := rand.New(rand.NewSource(time.Now().Unix() + rand_x))

	l := len(charArr)
	for i := l - 1; i > 0; i-- {
		r := ran.Intn(i)
		charArr[r], charArr[i] = charArr[i], charArr[r]
	}
	rchar := charArr[:length]
	return strings.Join(rchar, "")
}

// 获取全部
func Read_Power_All_Map() {
	o := orm.NewOrm()
	var r []Power
	qs := o.QueryTable(new(Power))
	qs.All(&r)

	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 ""
	}
}