scd_tools_go/service/models/bo/global_code.go

package bo

import (
	"errors"
	"fmt"
	"log"
	"scd_check_tools/global"
	"scd_check_tools/logger"
	"scd_check_tools/models/enum"
	"scd_check_tools/tools"
	"strconv"
	"strings"

	"github.com/astaxie/beego/orm"

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

type Global_const_code struct {
	Id         int    `orm:pk;auto`
	Code       string `orm:"size(20)"`
	Parentcode string `orm:"size(20)"`
	Name       string `orm:"size(20)"`
}

type Global struct {
	DeviceBaseModel
}

func init() {
	orm.RegisterModel(new(Global_const_code))
}

func LoadAndCacheGlobalCode() {
	db := orm.NewOrm()
	//初始化一些特定系统字典定义，主要是CDC数据类型
	db.Raw("insert IGNORE into global_const_code(code,parentcode,name)values(?,?,?)", "DingzhiCdcDatatype", "systemconstcode", "定值CDC数据类型").Exec()
	db.Raw("insert IGNORE into global_const_code(code,parentcode,name)values(?,?,?)", "YaoCeCdcDatatype", "systemconstcode", "遥测CDC数据类型").Exec()
	db.Raw("insert IGNORE into global_const_code(code,parentcode,name)values(?,?,?)", "YaoXinCdcDatatype", "systemconstcode", "遥信CDC数据类型").Exec()
	db.Raw("insert IGNORE into global_const_code(code,parentcode,name)values(?,?,?)", "YaoKongCdcDatatype", "systemconstcode", "遥控CDC数据类型").Exec()
	db.Raw("insert IGNORE into global_const_code(code,parentcode,name)values(?,?,?)", "OtherCdcDatatype", "systemconstcode", "其他CDC数据类型").Exec()

	lst := []orm.Params{}
	_, err := db.Raw("select * from global_const_code").Values(&lst)
	if err != nil {
		log.Println(err)
	}
	hasDingzhiCdcDatatype := false
	hasYaoCeCdcDatatype := false
	hasYaoXinCdcDatatype := false
	hasYaoKongCdcDatatype := false
	hasOtherCdcDatatype := false
	if len(lst) > 0 {
		for _, item := range lst {
			pcode := tools.IsEmpty(item["parentcode"])
			code := tools.IsEmpty(item["code"])
			name := tools.IsEmpty(item["name"])
			key := "global_code_" + pcode + code
			global.GoCahce.Set(key, item, -1)
			key = "global_code_" + tools.IsEmpty(item["id"])
			global.GoCahce.Set(key, item, -1)
			if pcode == "DingzhiCdcDatatype" {
				hasDingzhiCdcDatatype = true
				DingZhiMap[code] = name
			} else if pcode == "YaoCeCdcDatatype" {
				hasYaoCeCdcDatatype = true
				YaoCeMap[code] = name
			} else if pcode == "YaoXinCdcDatatype" {
				hasYaoXinCdcDatatype = true
				YaoXinMap[code] = name
			} else if pcode == "YaoKongCdcDatatype" {
				hasYaoKongCdcDatatype = true
				YaoKongMap[code] = name
			} else if pcode == "OtherCdcDatatype" {
				hasOtherCdcDatatype = true
				OtherCdcTypeMap[code] = name
			}
		}
	}
	if !hasDingzhiCdcDatatype {
		for k, v := range DingZhiMap {
			db.Raw("insert into global_const_code(code,parentcode,name)values(?,?,?)", k, "DingzhiCdcDatatype", v).Exec()
		}
	}
	if !hasYaoCeCdcDatatype {
		for k, v := range YaoCeMap {
			db.Raw("insert into global_const_code(code,parentcode,name)values(?,?,?)", k, "YaoCeCdcDatatype", v).Exec()
		}
	}
	if !hasYaoXinCdcDatatype {
		for k, v := range YaoXinMap {
			db.Raw("insert into global_const_code(code,parentcode,name)values(?,?,?)", k, "YaoXinCdcDatatype", v).Exec()
		}
	}
	if !hasYaoKongCdcDatatype {
		for k, v := range YaoKongMap {
			db.Raw("insert into global_const_code(code,parentcode,name)values(?,?,?)", k, "YaoKongCdcDatatype", v).Exec()
		}
	}
	if !hasOtherCdcDatatype {
		for k, v := range OtherCdcTypeMap {
			db.Raw("insert into global_const_code(code,parentcode,name)values(?,?,?)", k, "OtherCdcDatatype", v).Exec()
		}
	}
}

func SaveGlobalCode(obj Global_const_code, userinfo ...map[string]interface{}) (int, error) {
	has, errorn := checkName(obj)
	if !has || errorn != nil {
		return 0, errorn
	}
	dblog := new(SystemLog)
	if len(userinfo) > 0 {
		dblog.SetUserInfo(userinfo[0])
	} else {
		dblog.SetUserInfo(map[string]interface{}{"name": "", "ip": "127.0.0.1"})
	}
	dblog.Audittype = enum.AuditType_admin_system_dict
	dblog.Logtype = enum.LogType_Insert
	dblog.Eventtype = enum.OptEventType_Bus
	dblog.Eventlevel = enum.OptEventLevel_Mid
	global.GoCahce.Delete("global_code_" + obj.Parentcode + obj.Code)
	o := orm.NewOrm()
	if obj.Id > 0 {
		dblog.Logtype = enum.LogType_Update
		_, err := o.Update(&obj)
		if err != nil {
			logger.Logger.Error(err)
			dblog.Description = fmt.Sprintf("编辑数据失败：%s,操作数据：%+v", err.Error(), obj)
			dblog.Fail2()
			return 0, err
		}
		dblog.Description = fmt.Sprintf("编辑数据成功,操作数据：%+v", obj)
		dblog.Success2()
	} else {
		newid, err := o.Insert(&obj)
		if err != nil {
			logger.Logger.Error(err)
			dblog.Description = fmt.Sprintf("新增数据失败：%s,操作数据：%+v", err.Error(), obj)
			dblog.Fail2()
			return 0, err
		}
		obj.Id = int(newid)
		dblog.Description = fmt.Sprintf("新增数据成功,操作数据：%+v", obj)
		dblog.Success2()
	}
	return obj.Id, nil
}

func DeleteGlobalCode(param Global_const_code, userinfo map[string]interface{}) (result int64, err error) {
	o := orm.NewOrm()
	dblog := new(SystemLog)
	dblog.SetUserInfo(userinfo)
	dblog.Audittype = enum.AuditType_admin_system_dict
	dblog.Logtype = enum.LogType_Delete
	dblog.Eventtype = enum.OptEventType_Bus
	dblog.Eventlevel = enum.OptEventLevel_Mid
	if param.Id > 0 {
		global.GoCahce.Delete("global_code_" + tools.IsEmpty(param.Id))
		err = o.Read(&param)
		if err == nil {
			global.GoCahce.Delete("global_code_" + param.Parentcode + param.Code)
		}
		_, err = o.Raw("delete from global_const_code where id=?", param.Id).Exec()
	} else {
		_, err = o.Raw("delete from global_const_code where parentcode=?", param.Code).Exec()
		_, err = o.Raw("delete from global_const_code where code=?", param.Code).Exec()
	}
	if err != nil {
		dblog.Description = fmt.Sprintf("删除数据失败：%s,操作数据：%+v", err.Error(), param)
		dblog.Fail2()
		return 0, errors.New(err.Error())
	}
	dblog.Description = fmt.Sprintf("删除数据成功,操作数据：%+v", param)
	dblog.Success2()
	return 1, nil
}

func checkName(bo Global_const_code) (bool, error) {
	if tools.IsEmpty(bo.Code) == "" {
		return false, errors.New("系统常量编码不能为空")
	}
	if tools.IsEmpty(bo.Parentcode) == "" {
		return false, errors.New("上级编码不能为空")
	}
	if tools.IsEmpty(bo.Name) == "" {
		return false, errors.New("系统常量名称不能为空")
	}
	o := orm.NewOrm()
	var sqlCommandText string
	var sqlParameter []interface{}
	if bo.Id > 0 {
		sqlCommandText = "select 1 from global_const_code where parentcode=? and name=? and id!=?"
		sqlParameter = append(sqlParameter, bo.Parentcode, bo.Name, bo.Id)
	} else {
		sqlCommandText = "select 1 from global_const_code where parentcode=? and name=?"
		sqlParameter = append(sqlParameter, bo.Parentcode, bo.Name)
	}
	var maps []orm.Params
	_, err := o.Raw(sqlCommandText, sqlParameter).Values(&maps)
	if err != nil {
		return false, err
	}
	if len(maps) > 0 {
		return false, errors.New("系统常量名称已存在")
	}
	return true, nil
}

func (t *Global) GetChildrenGlobalCode(code string) ([]orm.Params, error) {
	o := orm.NewOrm()
	if code == "" {
		code = "systemconstcode" //根节点
	}
	tableData := []orm.Params{}
	var SqlCommandText = "select a.id,a.code,a.parentcode,a.name,(select case count(0) when 0 then 'false' else 'true' end from global_const_code where parentcode=a.code) isParent from global_const_code a where a.parentcode=? "

	_, err := o.Raw(SqlCommandText, code).Values(&tableData)
	if code == "systemconstcode" {
		tableData = append(tableData, orm.Params{"id": "0", "code": "systemconstcode", "parentcode": "", "name": "系统代码", "isParent": "true", "open": "true"})
	}
	return tableData, err
}

func (t *Global) QueryGlobalCodeList(param map[string]interface{}) ([]orm.Params, int, error) {
	dblog := new(SystemLog)
	dblog.SetUserInfo(t.GetUserInfo())
	dblog.Audittype = enum.AuditType_admin_system_dict
	dblog.Logtype = enum.LogType_Query
	dblog.Eventtype = enum.OptEventType_Bus
	dblog.Eventlevel = enum.OptEventLevel_Mid
	o := orm.NewOrm()
	tableData := []orm.Params{}
	var SqlCommandText = "select * from global_const_code "
	var sqlCondition []string
	var sqlParameter []interface{}
	var limit, totalSQL string
	if id, ok := param["id"]; ok && tools.IsEmpty(id) != "" {
		sqlCondition = append(sqlCondition, "id=?")
		sqlParameter = append(sqlParameter, id)
	} else if code, ok := param["code"]; ok && tools.IsEmpty(code) != "" {
		sqlCondition = append(sqlCondition, "code=?")
		sqlParameter = append(sqlParameter, code)
	} else if parentCode, ok1 := param["pcode"]; ok1 && tools.IsEmpty(parentCode) != "" {
		sqlCondition = append(sqlCondition, "parentcode=?")
		sqlParameter = append(sqlParameter, parentCode)
	}
	if len(sqlCondition) > 0 {
		SqlCommandText += " where " + strings.Join(sqlCondition, " and ") + " order by code asc "
		totalSQL = "select count(1) total from global_const_code where " + strings.Join(sqlCondition, " and ")
	} else {
		SqlCommandText += " order by code asc"
		totalSQL = "select count(1) total from global_const_code "
	}
	if index, ok := param["pageindex"]; ok {
		pageIndex, _ := strconv.Atoi(index.(string))
		pageSize, _ := strconv.Atoi(param["pagesize"].(string))
		limit = " limit " + strconv.Itoa((pageIndex-1)*pageSize) + "," + strconv.Itoa(pageSize)
		SqlCommandText += limit
	}
	var number int
	_, err := o.Raw(SqlCommandText, sqlParameter).Values(&tableData)
	dblog.Description = fmt.Sprintf("SQL:%s,参数：%+v", SqlCommandText, sqlParameter)
	if err == nil {
		dblog.Success2()
		totalTable := []orm.Params{}
		_, err1 := o.Raw(totalSQL, sqlParameter).Values(&totalTable)
		if err1 == nil && len(totalTable) > 0 {
			number, _ = strconv.Atoi(totalTable[0]["total"].(string))
		}
	} else {
		logger.Logger.Error(err, dblog.Description)
		dblog.Fail2()
	}
	return tableData, number, err
}

//获取指定ID的代码
func (t *Global) GetCodeInfoByID(id string) orm.Params {
	key := "global_code_" + id
	r, _ := global.GoCahce.Get(key)
	if r != nil {
		return r.(orm.Params)
	}
	return nil
}

func (t *Global) GetCodeInfoByCode(pcode, code string) orm.Params {
	key := "global_code_" + pcode + code
	r, _ := global.GoCahce.Get(key)
	if r != nil {
		return r.(orm.Params)
	}
	return nil
}

//类别管理树
func (t *Global) GetCategoryTree() ([]orm.Params, error) {
	o := orm.NewOrm()
	var tableData = []orm.Params{}
	var SqlCommandText = "select id,code,parentcode,name title from global_const_code where code like 'pstype%';"
	_, err := o.Raw(SqlCommandText).Values(&tableData)
	dblog := new(SystemLog)
	dblog.SetUserInfo(t.GetUserInfo())
	dblog.Audittype = enum.AuditType_admin_system_dict
	dblog.Logtype = enum.LogType_Query
	dblog.Eventtype = enum.OptEventType_System
	dblog.Eventlevel = enum.OptEventLevel_Low
	dblog.Description = SqlCommandText
	if err == nil {
		dblog.Success2()
	} else {
		logger.Logger.Error(err, SqlCommandText)
		dblog.Fail2()
	}
	return tableData, err
}

//获取角色管理菜单树
func (t *Global) GetMenuTree(roleId int) ([]orm.Params, error) {
	o := orm.NewOrm()
	tableData := []orm.Params{}
	var SqlCommandText string
	var sqlParameter []interface{}
	if roleId > -1 {
		SqlCommandText = "select funccodeid id from t_data_role_func where roleid=? "
		sqlParameter = append(sqlParameter, roleId)
	} else {
		SqlCommandText = "select funccodeid id from t_data_role_func "
	}
	SqlCommandText += " order by id asc "
	_, err := o.Raw(SqlCommandText, sqlParameter).Values(&tableData)
	dblog := new(SystemLog)
	dblog.SetUserInfo(t.GetUserInfo())
	dblog.Audittype = enum.AuditType_admin_system_dict
	dblog.Logtype = enum.LogType_Query
	dblog.Eventtype = enum.OptEventType_System
	dblog.Eventlevel = enum.OptEventLevel_Low
	dblog.Description = SqlCommandText
	if err == nil {
		dblog.Success2()
	} else {
		logger.Logger.Error(err, SqlCommandText)
		dblog.Fail2()
	}
	return tableData, err
}

//获取角色管理菜单树
func (t *Global) childrenMenu(code string, roleId int) ([]map[string]interface{}, error) {
	o := orm.NewOrm()
	tableData := []orm.Params{}
	var SqlCommandText string
	var sqlParameter []interface{}
	if roleId > -1 {
		SqlCommandText = "select a.id,a.name,case when b.id is null then 0 else 1 end checked " +
			"from global_const_code a left join (select funccodeid id from t_data_role_func where roleid=?) b on a.id=b.id where parentcode=?"
		sqlParameter = append(sqlParameter, roleId, code)
	} else {
		SqlCommandText = "select id,name,0 checked from global_const_code where parentcode=?"
		sqlParameter = append(sqlParameter, code)
	}
	_, err := o.Raw(SqlCommandText, sqlParameter).Values(&tableData)
	var result []map[string]interface{}
	if err == nil && len(tableData) > 0 {
		for _, record := range tableData {
			checked, _ := strconv.ParseBool(record["checked"].(string))
			result = append(result, map[string]interface{}{"id": record["id"], "name": record["name"], "checked": checked})
		}
	}
	return result, err
}