Cold_Api/models/Account/Company.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"
	orm2 "github.com/beego/beego/v2/client/orm"
	_ "github.com/go-sql-driver/mysql"
	"strconv"
	"time"
)

type Company struct {
	Id     int    `orm:"column(ID);size(11);auto;pk"`
	T_mid  int    `orm:"size(200);null"` //  上一级 ID
	T_name string `orm:"size(256);null"` // 公司名称

	T_State    int       `orm:"size(200);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 第一次保存时才设置时间

	Children []Company `orm:"-"`
}

type Company_R struct {
	Id       int
	T_mid    int    //  上一级 ID
	T_name   string // 公司名称
	Children []Company_R
}

func CompanyToCompany_R(r Company) (v Company_R) {
	v.Id = r.Id
	v.T_mid = r.T_mid
	v.T_name = r.T_name
	return v
}

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

var redisCache_Company cache.Cache

func init() {
	//注册模型
	orm.RegisterModel(new(Company))
	orm.Debug = true

	config := fmt.Sprintf(`{"key":"%s","conn":"%s","dbNum":"%s","password":"%s"}`,
		"redis_Cold_User_Company", conf.Redis_address, conf.Redis_dbNum, conf.Redis_password)
	fmt.Println(config)
	var err error
	redisCache_Company, err = cache.NewCache("redis", config)
	if err != nil || redisCache_Company == nil {
		errMsg := "failed to init redis"
		fmt.Println(errMsg, err)
	}

}

// ---------------- Redis -------------------
// Redis_Set(m.T_sn,m) // Redis 更新缓存
func Redis_Company_Set(r Company) (err error) {
	//json序列化
	str, err := json.Marshal(r)
	if err != nil {
		fmt.Print(err)
		return
	}

	err = redisCache_Company.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_Company_Get(key string) (r Company, is bool) {
	if redisCache_Company.IsExist(key) {
		//println("找到key:",key)
		v := redisCache_Company.Get(key)

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

func Redis_Company_DelK(key string) (err error) {
	err = redisCache_Company.Delete(key)
	return
}

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

// 添加
func Add_Company(m Company) (id int64, err error) {
	o := orm.NewOrm()
	id, err = o.Insert(&m)
	if err != nil {
		fmt.Println(err)
	}
	m.Id = int(id)
	Redis_Company_Set(m)
	return id, err
}

// 修改
func Update_Company(m Company, cols ...string) bool {
	o := orm.NewOrm()
	if num, err := o.Update(&m, cols...); err == nil {
		fmt.Println("Number of records updated in database:", num)
		Redis_Company_Set(m) // Redis 更新缓存
		return true
	}
	return false
}

// 删除
func Delete_Company(m Company) bool {
	o := orm.NewOrm()
	m.T_State = 0
	if num, err := o.Update(&m, "T_State"); err == nil {
		fmt.Println("Number of records updated in database:", num)
	} else {
		return false
	}
	Redis_Company_DelK(strconv.Itoa(m.Id))
	return true
}

// 获取 ById
func Read_Company_ById(Id int) (r Company, e error) {
	if r, is := Redis_Company_Get(strconv.Itoa(Id)); is {
		//println("Redis_Get  OK")
		return r, nil
	}

	o := orm.NewOrm()
	qs := o.QueryTable(new(Company))
	e = qs.Filter("Id", Id).Filter("T_State", 1).One(&r)
	return r, e
}

// 获取列表
func Read_Company_Tree(admin_r Admin, Company_name string) (CompanyList []Company_R, cnt int64) {

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

	qs := o.QueryTable(new(Company))
	var maps []Company

	cond := orm.NewCondition()
	cond1 := cond.And("T_State", 1)

	if admin_r.T_pid > 0 {
		cond1 = cond1.And("Id", admin_r.T_pid)
	}

	// 内部用户未绑定公司
	if admin_r.T_pid == 0 && len(admin_r.T_pids) == 0 {
		return CompanyList, cnt
	}

	// 内部用户已绑定公司，* 绑定所有公司
	if len(admin_r.T_pids) > 0 && admin_r.T_pids != "*" {
		T_pids := models.SplitStringIds(admin_r.T_pids, "P")
		cond1 = cond1.AndCond(cond.Or("Id__in", T_pids).Or("T_mid__in", T_pids))
	}

	if len(Company_name) > 0 {
		cond1 = cond1.And("T_name__icontains", Company_name)
	}

	qs.SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&maps)
	cnt, _ = qs.SetCond((*orm2.Condition)(cond1)).Count()

	parentMap, flag := getCompanyParent(maps)
	if flag {
		for i := 0; i < len(maps); i++ {
			if parentMap[maps[i].T_mid] {
				continue
			}
			r := Company_R{
				Id:       maps[i].Id,
				T_mid:    maps[i].T_mid,
				T_name:   maps[i].T_name,
				Children: nil,
			}
			info := CompanyCall(maps, r)
			CompanyList = append(CompanyList, info)
		}
	} else {
		for i := 0; i < len(maps); i++ {
			r := Company_R{
				Id:       maps[i].Id,
				T_mid:    maps[i].T_mid,
				T_name:   maps[i].T_name,
				Children: nil,
			}
			info := CompanyCall(maps, r)
			CompanyList = append(CompanyList, info)
		}
	}

	return CompanyList, cnt
}

func Read_Company_List(page, page_z int) (CompanyList []Company_R, cnt int64) {

	var offset int64
	if page <= 1 {
		offset = 0
	} else {
		offset = int64((page - 1) * page_z)
	}
	o := orm.NewOrm()
	// 也可以直接使用 Model 结构体作为表名

	qs := o.QueryTable(new(Company))
	var maps []Company

	cond := orm.NewCondition()
	cond1 := cond.And("T_State", 1)

	qs.Limit(page_z, offset).SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&maps)
	cnt, _ = qs.SetCond((*orm2.Condition)(cond1)).Count()

	for _, v := range maps {
		CompanyList = append(CompanyList, CompanyToCompany_R(v))
	}
	return CompanyList, cnt
}

func CompanyTree(list []Company, parentId int) []Company_R {
	res := make([]Company_R, 0)
	for _, v := range list {
		if v.T_mid == parentId {
			r := Company_R{
				Id:       v.Id,
				T_mid:    v.T_mid,
				T_name:   v.T_name,
				Children: nil,
			}
			r.Children = CompanyTree(list, v.Id)
			res = append(res, r)
		}
	}
	return res
}

func CompanyCall(CompanyList []Company, company Company_R) Company_R {
	list := CompanyList
	min := make([]Company_R, 0)
	for j := 0; j < len(list); j++ {
		if company.Id != list[j].T_mid {
			continue
		}
		mi := Company_R{}
		mi.Id = list[j].Id
		mi.T_mid = list[j].T_mid
		mi.T_name = list[j].T_name
		mi.Children = []Company_R{}
		ms := CompanyCall(CompanyList, mi)
		min = append(min, ms)
	}
	company.Children = min
	return company
}

func getCompanyParent(CompanyList []Company) (map[int]bool, bool) {
	list := CompanyList
	var flag = false
	var parentMap = map[int]bool{}
	for j := 0; j < len(list); j++ {
		parentMap[list[j].T_mid] = false
	}

	for j := 0; j < len(list); j++ {
		if _, ok := parentMap[list[j].Id]; !ok {
			continue
		}
		parentMap[list[j].Id] = true
		flag = true
	}
	return parentMap, flag
}

func Read_Company_List_All_ByT_name(T_name string) (maps []Company) {
	o := orm.NewOrm()
	// 也可以直接使用 Model 结构体作为表名

	qs := o.QueryTable(new(Company))
	if len(T_name) > 0 {
		qs.Filter("T_name", T_name).All(&maps)
		return maps
	}
	qs.All(&maps)
	return maps
}

// 获取列表
func Read_Company_List_ByT_pids(T_pids string, page int, page_z int) (Company_r []Company_R, cnt int64) {

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

	qs := o.QueryTable(new(Company))
	var offset int64
	if page_z == 0 {
		page_z = conf.Page_size
	}
	if page <= 1 {
		offset = 0
	} else {
		offset = int64((page - 1) * page_z)
	}

	var r []Company
	cond := orm.NewCondition()
	cond1 := cond.And("T_State", 1)
	if len(T_pids) >= 0 {
		list := models.SplitStringIds(T_pids, "P")
		cond1 = cond1.And("Id__in", list)
	}

	qs.Limit(page_z, offset).SetCond((*orm2.Condition)(cond1)).OrderBy("Id").All(&r)
	cnt, _ = qs.SetCond((*orm2.Condition)(cond1)).Count()

	for _, v := range r {
		Company_r = append(Company_r, CompanyToCompany_R(v))
	}
	return Company_r, cnt
}