Cold_Api/models/Account/Power.go

package Account

import (
	"Cold_Api/conf"
	"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_role       int       `orm:"size(2);default(0)"`                                    //  1-内部 2-实施 3-养护员
	T_warning    int       `orm:"size(2);default(0)"`                                    //  告警权限 1-超标 2-异常 3-系统
	T_Menu_Bind  string    `orm:"size(256);null"`                                        //  权限绑定菜单id 1|2|3|4|5|
	T_Menu_Grant string    `orm:"size(256);null"`                                        //  可以授予的菜单id 1|2|3|4|5| * 代表全部菜单
	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 **************
}

var redisCache_Power cache.Cache

func init() {
	//注册模型
	orm.RegisterModel(new(Power))

	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_Bind))
	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_ALL_Power_Administration(Power_Administration int) (maps []Power) {

	o := orm.NewOrm()
	qs := o.QueryTable(new(Power))

	qs.Filter("T_State", 1).OrderBy("Id").All(&maps)

	return maps
}

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

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

	qs := o.QueryTable(new(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()

	return maps, cnt
}

// 获取列表
func Read_Power_List_ALL() (maps []Power, cnt int64) {

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

	qs := o.QueryTable(new(Power))

	qs.Filter("T_State", 1).OrderBy("Id").All(&maps)
	cnt, _ = qs.Filter("T_State", 1).Count()

	return maps, cnt
}

// 修改
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_Bind))
		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, "")
}