scd_tools_go/service/models/bo/user.go

package bo

import (
	"scd_check_tools/logger"
	"scd_check_tools/models/enum"
	"scd_check_tools/tools"
	"crypto/md5"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/astaxie/beego/orm"

	_ "github.com/astaxie/beego/orm"
)

type T_data_user struct {
	Id             int    `orm:"pk;auto"`
	Name           string `orm:"size(20)"`
	Account        string `orm:"size(20)"`
	Pwd            string `orm:"size(256)"`
	PwdExpire      string
	Mobilephone    string
	Role           int
	BindIps        string
	DatelimitStart string
	DatelimitEnd   string
	Memo           string
	Createtime     string
	Createuser     int
}

type T_data_user_func struct {
	Id       int `orm:"pk"`
	Userid   int
	Funccode string
}

func init() {
	orm.RegisterModel(new(T_data_user))
	orm.RegisterModel(new(T_data_user_func))
}

func OneUser(dataobj T_data_user) T_data_user {
	db := orm.NewOrm()
	db.Read(&dataobj)
	return dataobj
}

func SaveUser(dataobj T_data_user, userinfo map[string]interface{}) (result int64, err error) {
	opt := "创建"
	if dataobj.Id > 0 {
		opt = "编辑"
	}
	dblog := new(SystemLog)
	dblog.SetUserInfo(userinfo)
	dblog.Audittype = enum.AuditType_admin_system_user
	dblog.Logtype = enum.LogType_Insert
	dblog.Eventtype = enum.OptEventType_Bus
	dblog.Eventlevel = enum.OptEventLevel_Hight
	if dataobj.Account == "admin" {
		dblog.Description = opt + "用户失败：帐号admin已存在"
		dblog.Fail2()
		return 0, errors.New("帐号admin已存在")
	}
	has, err2 := checkUserAccount(dataobj)
	if !has || err2 != nil {
		dblog.Description = opt + "用户失败：" + err2.Error()
		dblog.Fail2()
		return 0, err2
	}
	o := orm.NewOrm()
	var id int64
	if dataobj.Id == 0 {
		dataobj.Createtime = tools.NowTime()
		dataobj.Createuser, _ = strconv.Atoi(tools.IsEmpty(userinfo["userid"]))
		id, err = o.Insert(&dataobj)
	} else {
		id, err = o.Update(&dataobj)
	}
	if err == nil {
		dblog.Description = opt + "用户成功！"
		dblog.Success2()
	} else {
		dblog.Description = opt + "用户失败：" + err.Error()
		dblog.Fail2()
		logger.Logger.Error(err, fmt.Sprintf("操作数据：%+v", dataobj))
	}
	return id, err
}

func SavePwd(dataobj T_data_user, userinfo map[string]interface{}) (result int64, err error) {
	dblog := new(SystemLog)
	dblog.SetUserInfo(userinfo)
	dblog.Audittype = enum.AuditType_admin_system_user
	dblog.Logtype = enum.LogType_changepassword
	dblog.Eventtype = enum.OptEventType_Bus
	dblog.Eventlevel = enum.OptEventLevel_Hight
	o := orm.NewOrm()
	newPwd := dataobj.Pwd
	e := o.Read(&dataobj)
	if e != nil || e == orm.ErrNoRows {
		dblog.Description = fmt.Sprintf("用户%d重置密码失败:%s", dataobj.Id, e.Error())
		dblog.Fail2()
		return 0, errors.New("无效的用户ID")
	}
	if len(newPwd) > 32 {
		newPwd = tools.OriginalCode(newPwd)
	}
	has := md5.Sum([]byte(newPwd))
	newPwd = fmt.Sprintf("%x", has)
	dataobj.Pwd = newPwd
	pwd_expire_day, _ := GetSysParamValue("user_pwd_expire_day", "60")
	pwd_expire_date := ""
	if pwd_expire_day == "0" {
		//永不过期
		pwd_expire_date = "1970-01-01 00:00:00"
	} else {
		pwd_expire_dayInt, _ := strconv.Atoi(pwd_expire_day)
		pwd_expire_dayInt = pwd_expire_dayInt * 24
		d, _ := time.ParseDuration(strconv.Itoa(pwd_expire_dayInt) + "h")
		pwd_expire_date = time.Now().Add(d).Format("2006-01-02 15:04:05")
	}
	dataobj.PwdExpire = pwd_expire_date
	var id int64
	id, err = o.Update(&dataobj)
	if err != nil {
		logger.Logger.Error(err)
		dblog.Description = fmt.Sprintf("用户%s重置密码失败:%s", dataobj.Name, e.Error())
		dblog.Fail2()
		return 0, err
	}
	dblog.Description = fmt.Sprintf("用户重置密码成功|%s", dataobj.Name)
	dblog.Success2()
	return id, err
}

func AuthUser(account string, pwd string) (result int64, err error) {
	var obj = T_data_user{Account: account}
	o := orm.NewOrm()
	has := o.QueryTable("t_data_user")
	has.Filter("account", account).One(&obj)
	if obj.Id > 0 {
		tmpValuePart := strings.Split(pwd, "0000")
		pwdpart := strings.Split(obj.Pwd, "0000")
		fmt.Println(pwdpart[1])
		fmt.Println(tmpValuePart[1])
		if pwdpart[1] == tmpValuePart[1] {
			return int64(obj.Id), nil
		}
		return 0, nil
	} else {
		//判断是否是管理员
		var er2 error
		var tmpValue string
		tmpValue, er2 = GetSysParamValue("admin_account", "")
		if er2 != nil {
			return 0, er2
		}
		if tmpValue == account {
			tmpValue, er2 = GetSysParamValue("admin_pwd", "")
			if er2 != nil {
				return 0, er2
			}
			tmpValuePart := strings.Split(tmpValue, "0000")
			pwdpart := strings.Split(pwd, "0000")
			if tmpValuePart[1] == pwdpart[1] {
				return 9999, nil
			}
		}
		return 0, er2
	}
}

func checkUserAccount(bo T_data_user) (bool, error) {
	if tools.IsEmpty(bo.Account) == "" {
		return false, errors.New("用户帐号不能为空")
	}
	o := orm.NewOrm()
	sql := "select id from t_data_user where account=?"
	var maps []orm.Params
	num, err := o.Raw(sql, bo.Account).Values(&maps)
	if err != nil {
		return false, err
	}
	if num > 0 {
		var oldid = 0
		for _, term := range maps {
			oldid, _ = strconv.Atoi(term["id"].(string))
		}
		if bo.Id > 0 && bo.Id != oldid {
			return false, errors.New("帐号已存在")
		} else if bo.Id == 0 {
			return false, errors.New("帐号已存在")
		}
	}
	return true, nil
}

func HasUserName(uname string) (bool, error) {
	if tools.IsEmpty(uname) == "" {
		return false, errors.New("用户名称不能为空")
	}
	o := orm.NewOrm()
	sql := "select id from t_data_user where name=?"
	var maps []orm.Params
	_, err := o.Raw(sql, uname).Values(&maps)
	if err != nil {
		return false, err
	}
	if len(maps) > 0 {
		return true, nil
	}
	return false, nil
}

func QueryUserList(param map[string]interface{}, dataobj T_data_user, userinfo map[string]interface{}) (data map[string]interface{}, err error) {
	o := orm.NewOrm()
	var dberr error
	var maps = map[string]interface{}{}
	querycondtion := param["datatable"].(map[string]interface{})
	var paramvalues = []interface{}{}
	var sqls = []string{}
	sqlcolnum := "select *,(select ifnull(count(0),0) cnt from t_data_user_func b where a.id=b.userid ) privcount FROM t_data_user a WHERE 1=1"
	sqltotal := "select count(1) cnt FROM t_data_user WHERE 1=1"
	sqls = append(sqls, " and not exist(select 1 from global_const_code where a.role=id and code='role_superadmin')")
	if dataobj.Id > 0 {
		sqls = append(sqls, " and a.id=?")
		paramvalues = append(paramvalues, dataobj.Id)
	}
	if name, ok2 := querycondtion["name"]; ok2 && tools.IsEmpty(name) != "" {
		sqls = append(sqls, " and a.name like like %?%")
		paramvalues = append(paramvalues, name)
	}
	if account, ok3 := querycondtion["account"]; ok3 && tools.IsEmpty(account) != "" {
		sqls = append(sqls, " and a.account like %?%")
		paramvalues = append(paramvalues, account)
	}

	limitStr, meta := tools.ParsePaginationToSqlPart(param)
	datas := []orm.Params{}
	sql := sqlcolnum + strings.Join(sqls, " ") + limitStr
	_, dberr = o.Raw(sql, paramvalues).Values(&datas)
	dblog := new(SystemLog)
	dblog.SetUserInfo(userinfo)
	dblog.Audittype = enum.AuditType_admin_system_user
	dblog.Logtype = enum.LogType_Query
	dblog.Eventtype = enum.OptEventType_Bus
	dblog.Eventlevel = enum.OptEventLevel_Low
	sqllog := fmt.Sprintf("SQL:%s 参数：%+v", sql, paramvalues)
	if dberr != nil {
		logger.Logger.Error(dberr)
		dblog.Description = sqllog
		dblog.Fail2()
		return nil, dberr
	} else {
		dblog.Description = sqllog
		dblog.Success2()
	}
	//查询数据记录数
	ts := []orm.Params{}
	_, dberr = o.Raw(sqltotal+strings.Join(sqls, " "), paramvalues).Values(&ts)
	for _, v := range ts {
		meta["total"], _ = strconv.Atoi(v["cnt"].(string))
	}
	if dberr == nil {
		maps["meta"] = meta
		if datas == nil || len(datas) == 0 {
			maps["data"] = ""
		} else {
			maps["data"] = datas
		}
		return maps, nil
	}
	return nil, dberr
}

func QueryUserPrivList(dataobj T_data_user_func, userinfo map[string]interface{}) (data map[string]interface{}, err error) {
	if dataobj.Userid == 0 {
		return nil, errors.New("用户ID不能为空")
	}
	o := orm.NewOrm()
	var dberr error
	var maps = map[string]interface{}{}
	datas := []orm.Params{}
	sql := "select a.*,b.name funcname FROM t_data_user_func a,global_const_code b WHERE a.funccode=b.code and b.parentcode='userpriv' and a.userid=? "
	_, dberr = o.Raw(sql, dataobj.Userid).Values(&datas)
	dblog := new(SystemLog)
	dblog.SetUserInfo(userinfo)
	dblog.Audittype = enum.AuditType_admin_system_userrole
	dblog.Logtype = enum.LogType_Query
	dblog.Eventtype = enum.OptEventType_Bus
	dblog.Eventlevel = enum.OptEventLevel_Low
	sqllog := fmt.Sprintf("SQL:%s 参数：%+v", sql, dataobj)
	if dberr != nil {
		logger.Logger.Error(dberr)
		dblog.Description = sqllog
		dblog.Fail2()
		return nil, dberr
	} else {
		dblog.Description = sqllog
		dblog.Success2()
		maps["data"] = datas
		return maps, nil
	}
	return nil, dberr
}

func SaveUserPrivList(uid int, policyids string, userinfo map[string]interface{}) (result int, err error) {
	if uid == 0 {
		return 0, errors.New("用户ID不能为空")
	}
	dblog := new(SystemLog)
	dblog.SetUserInfo(userinfo)
	dblog.Audittype = enum.AuditType_admin_system_userrole
	dblog.Logtype = enum.LogType_Update
	dblog.Eventtype = enum.OptEventType_Bus
	dblog.Eventlevel = enum.OptEventLevel_Hight
	o := orm.NewOrm()
	_, err = o.Raw("delete from t_data_user_func where userid=?", uid).Exec()
	if err != nil {
		dblog.Description = fmt.Sprintf("用户%d权限设置失败:%s", uid, err.Error())
		dblog.Fail2()
		return 0, err
	}

	ids := strings.Split(policyids, ",")
	dataobj := T_data_user_func{Userid: uid}
	for _, code := range ids {
		if tools.IsEmpty(code) == "" {
			continue
		}
		dataobj.Funccode = code
		newid, err2 := o.Insert(&dataobj)
		if err2 != nil {
			logger.Logger.Error(err2)
			dblog.Description = fmt.Sprintf("用户%d权限设置失败:%s", uid, err2.Error())
			dblog.Fail2()
			return 0, err2
		}
		dataobj.Id = int(newid + 1)
	}
	dblog.Description = fmt.Sprintf("用户%d权限设置成功！", uid)
	dblog.Success2()
	return dataobj.Id, nil
}