ColdVerify_server/models/Account/Admin.go

package Account

import (
	"ColdVerify_server/lib"
	"ColdVerify_server/logs"
	"fmt"
	"strings"
	"sync"
	"time"

	"github.com/beego/beego/v2/adapter/orm"
	orm2 "github.com/beego/beego/v2/client/orm"
	_ "github.com/go-sql-driver/mysql"
	uuid "github.com/satori/go.uuid"
)

type Admin struct {
	Id              int    `orm:"column(ID);size(11);auto;pk"`
	T_uuid          string `orm:"size(256);null"`      //
	T_power         int    `orm:"size(2);;default(0)"` // 权限  0
	T_name          string `orm:"size(256);null"`      // 姓名
	T_user          string `orm:"size(256);null"`      // 用户名
	T_pass          string `orm:"size(256);null"`      // 密码
	T_wxname        string `orm:"size(256);null"`      // 微信name
	T_signature_img string `orm:"size(256);null"`      // 签名图片

	T_State          int       `orm:"size(200);default(1)"`                                  //  0删除  1 正常
	T_Distributor_id string    `orm:"size(256);null"`                                        // 分销商
	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 第一次保存时才设置时间
}

type Admin_R struct {
	T_uuid           string
	T_power          int    // 权限
	T_power_name     string // 权限
	T_name           string // 姓名
	T_user           string // 用户名
	T_wxname         string // 企业微信
	T_Distributor_id string // 经销商id
	T_signature_img  string // 签名图片
}

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

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

}

var adminCache = struct {
	sync.RWMutex
	data map[string]Admin
}{}

const (
	DefaultAdminPassword = "12345678"
)

func GetAdminFromCache(name string) (Admin, bool, error) {
	name = strings.TrimSpace(name)
	if len(name) == 0 {
		return Admin{}, false, nil
	}

	adminCache.RLock()
	cached := adminCache.data
	adminCache.RUnlock()

	if cached == nil {
		if err := RefreshAdminCache(); err != nil {
			return Admin{}, false, err
		}
		adminCache.RLock()
		cached = adminCache.data
		adminCache.RUnlock()
	}

	admin, ok := cached[name]
	return admin, ok, nil
}

func RefreshAdminCache() error {
	admins, err := Read_AllActiveAdmins()
	if err != nil {
		return err
	}
	cache := make(map[string]Admin, len(admins))
	for _, a := range admins {
		cache[a.T_name] = a
	}
	adminCache.Lock()
	adminCache.data = cache
	adminCache.Unlock()
	return nil
}

func UpsertAdminCache(admin Admin) {
	if len(admin.T_name) == 0 {
		return
	}
	adminCache.Lock()
	if adminCache.data == nil {
		adminCache.data = make(map[string]Admin)
	}
	adminCache.data[admin.T_name] = admin
	adminCache.Unlock()
}

func EnsureAdminByName(name, distributorID string) (Admin, error) {
	name = strings.TrimSpace(name)
	if len(name) == 0 {
		return Admin{}, fmt.Errorf("管理员名称为空")
	}

	if admin, ok, err := GetAdminFromCache(name); err != nil {
		return Admin{}, err
	} else if ok {
		return admin, nil
	}

	newUUID := uuid.NewV4().String()
	username := fmt.Sprintf("auto_%s", strings.ReplaceAll(newUUID, "-", "")[:8])

	newAdmin := Admin{
		T_uuid:           newUUID,
		T_power:          6,
		T_name:           name,
		T_user:           username,
		T_pass:           DefaultAdminPassword,
		T_wxname:         name,
		T_State:          1,
		T_Distributor_id: distributorID,
	}

	if _, err := Add_Admin(newAdmin); err != nil {
		return Admin{}, err
	}

	if err, persisted := Read_Admin_ByT_uuid(newUUID); err != nil {
		return Admin{}, err
	} else {
		UpsertAdminCache(persisted)
		return persisted, nil
	}
}
func AdminToAdmin_R(T Admin, powerMap map[int]string) (T_r Admin_R) {
	T_r.T_uuid = T.T_uuid
	T_r.T_power = T.T_power
	T_r.T_name = T.T_name
	T_r.T_user = T.T_user
	T_r.T_wxname = T.T_wxname
	T_r.T_power_name = powerMap[T.T_power]
	T_r.T_Distributor_id = T.T_Distributor_id
	T_r.T_signature_img = T.T_signature_img
	return T_r
}

// 获取 ByT_user
func Read_Admin_ByT_user(T_user string) (e error, r Admin) {
	o := orm.NewOrm()
	qs := o.QueryTable(new(Admin))
	e = qs.Filter("T_user", T_user).Filter("T_State", 1).One(&r)
	return e, r
}

// 获取 ByT_uuid
func Read_Admin_ByT_uuid(T_uuid string) (e error, r Admin) {
	o := orm.NewOrm()
	qs := o.QueryTable(new(Admin))
	e = qs.Filter("T_uuid", T_uuid).Filter("T_State", 1).One(&r)
	return e, r
}

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

	id, err = o.Insert(&m)
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}
	return id, err
}

func Read_Admin_verification(T_user string, T_pass string) (error, Admin) {
	o := orm.NewOrm()
	r := Admin{T_user: T_user, T_pass: T_pass, T_State: 1}
	err := o.Read(&r, "T_user", "T_pass", "T_State") // o.Read(&r,"Tokey") 如果不是 主键 就得指定字段名
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}
	return err, r
}

// 获取列表
func Read_Admin_List(T_Distributor_id string, T_name string, page int, page_z int, powerMap map[int]string) ([]Admin_R, int) {

	o := orm.NewOrm()
	var offset int
	if page <= 1 {
		offset = 0
	} else {
		offset = (page - 1) * page_z
	}
	qs := o.QueryTable(new(Admin))
	var r []Admin
	cond := orm.NewCondition()
	cond1 := cond.And("T_State", 1).AndCond(cond.Or("T_name__icontains", T_name).Or("T_user__icontains", T_name))
	if len(T_Distributor_id) > 0 {
		// 查询经销商用户数据
		cond1 = cond1.And("T_Distributor_id", T_Distributor_id)
	} else {
		// 只查询内部管理员数据
		cond1 = cond1.AndCond(cond1.Or("T_Distributor_id__isnull", true).Or("T_Distributor_id", ""))
	}
	qs.Limit(page_z, offset).SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&r)
	cnt, _ := qs.SetCond((*orm2.Condition)(cond1)).Count()

	// 转换
	var Admin_r []Admin_R
	for _, v := range r {
		Admin_r = append(Admin_r, AdminToAdmin_R(v, powerMap))
	}

	return Admin_r, int(cnt)

}

// 修改
func Update_Admin(m Admin, cols ...string) bool {
	o := orm.NewOrm()
	if num, err := o.Update(&m, cols...); err == nil {
		logs.Println("Number of records updated in database:", num)

		return true
	}
	return false
}

// 删除
func Delete_Admin(v Admin) bool {
	o := orm.NewOrm()
	if num, err := o.Delete(&v); err == nil {
		logs.Println("Number of records deleted in database:", num)
	} else {
		return false
	}

	return true
}

// 删除
func Delete_Admin_(v Admin) bool {
	o := orm.NewOrm()
	v.T_State = 0
	if num, err := o.Update(&v, "T_State"); err == nil {
		logs.Println("Number of records updated in database:", num)
	} else {
		return false
	}

	return true
}

// 获取全部列表
func Read_Admin_List_ALL() (maps []Admin) {

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

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

func Read_AllActiveAdmins() ([]Admin, error) {
	o := orm.NewOrm()
	var admins []Admin
	_, err := o.QueryTable(new(Admin)).Filter("T_State", 1).All(&admins)
	if err != nil {
		return nil, err
	}
	return admins, nil
}

// 获取全部列表-包括软删除数据
func Read_Admin_List_ALL_1() (maps []Admin) {

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

	qs.OrderBy("Id").All(&maps)
	return maps
}

// 获取全部列表
func Read_Admin_List_ALL_Power(T_Distributor_id string, T_name string, PowerMaps map[int]string) (maps []AdminPower_R) {

	o := orm.NewOrm()
	var r []Admin
	qs := o.QueryTable(new(Admin))
	if len(T_Distributor_id) > 0 {
		qs = qs.Filter("T_Distributor_id", T_Distributor_id)
	}
	if len(T_name) > 0 {
		qs = qs.Filter("T_name__icontains", T_name)
	}
	qs.Filter("T_State", 1).OrderBy("Id").All(&r)
	// 转换
	var Admin_Power_r []AdminPower_R
	for _, v := range r {
		Admin_Power_r = append(Admin_Power_r, AdminToAdminPower_R(v, PowerMaps))
	}
	return Admin_Power_r
}

// {"uuid":"name"}
func AdminListToMap(A []Admin) map[string]string {
	maps := make(map[string]string, len(A))
	for _, v := range A {
		maps[v.T_uuid] = v.T_name
	}
	return maps
}

func AdminWXListToMap(A []Admin) map[string]string {
	maps := make(map[string]string, len(A))
	for _, v := range A {
		maps[v.T_uuid] = v.T_wxname
	}
	return maps
}

type AdminPower_R struct {
	T_uuid       string `orm:"column(t_uuid)"`
	T_name       string `orm:"column(t_name)"`       // 姓名
	T_power_name string `orm:"column(t_power_name)"` // 权限
}

// PowerMaps {1:'管理员'}
func AdminToAdminPower_R(T Admin, PowerMaps map[int]string) (T_r AdminPower_R) {
	T_power_name, ok := PowerMaps[T.T_power]
	if !ok {
		T_power_name = ""
	}
	T_r.T_uuid = T.T_uuid
	T_r.T_name = T.T_name
	T_r.T_power_name = T_power_name
	return T_r
}

// 获取全部列表
func Read_Admin_List_ALL_T_power(T_power int) []Admin {

	o := orm.NewOrm()
	var r []Admin
	qs := o.QueryTable(new(Admin))

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

	return r
}