bileiqi/05.code/backend/rtelec_app_public_lib/service/alarm_device_service.go

package service

//告警设备配置服务类
import (
	"fmt"
	"github.com/astaxie/beego/orm"
	"rtzh_elec_temperature/enum"
	"rtzh_elec_temperature/logger"
	"rtzh_elec_temperature/models/bo"
	"rtzh_elec_temperature/rtelec_app_public_lib/models"
	"rtzh_elec_temperature/tools"
	"strconv"
	"sync"
)

var deviceTactics = sync.Map{}
var aloneTactics = sync.Map{}

type AlarmDeviceService struct {
	BaseService
}

// 根据设备id获取设备和设备的测点配置的策略
func (t *AlarmDeviceService) GetDeviceTactics(deviceid int64, pageindex int, pagesize int) ([]map[string]interface{}, error) {
	// 通过deviceid从iss库中获取设备下的测点
	ds := new(DeviceService)
	deviceMpList, _, err := ds.DeviceMpList(int32(deviceid), pageindex, pagesize)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Err is :%s", err))
		return nil, err
	}
	// 根据设备的测点，查询出这个测点使用的标准策略
	db := orm.NewOrm()
	var absSql = "SELECT a.id,t.alarm_type,a.strategy_name,a.mod_id,t.attrname,a.threshold FROM t_base_alarm_mplist t,t_base_absolute_alarm a WHERE t.fk_id = a.id AND t.alarm_type = 1 AND a.mod_id = t.mod_id AND t.mod_id = ? AND t.attrname =?"
	var riseSql = "SELECT a.id,t.alarm_type,a.strategy_name,a.mod_id,t.attrname,a.upcycle,a.scope threshold FROM t_base_alarm_mplist t,t_base_rise_alarm a WHERE t.fk_id = a.id AND t.alarm_type = 2 AND a.mod_id = t.mod_id AND t.mod_id = ? AND t.attrname =?"
	lst := []map[string]interface{}{}
	aloneLst := []orm.Params{}
	for _, row := range deviceMpList {
		tacticsObjs := []orm.Params{}
		obj := map[string]interface{}{}
		attrname := fmt.Sprint(row["attrname"])
		mpname := fmt.Sprint(row["mpname"])
		modid, err := strconv.ParseInt(fmt.Sprint(row["modelid"]), 10, 64)
		mpid, err := strconv.ParseInt(fmt.Sprint(row["mpid"]), 10, 64)
		if err != nil {
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Err is :%s", err))
			return nil, err
		}
		abs := []orm.Params{}
		rise := []orm.Params{}
		_, err = db.Raw(absSql, modid, attrname).Values(&abs)
		if err != nil {
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Err is :%s", err))
			return nil, err
		}
		tacticsObjs = append(tacticsObjs, abs...)
		_, err = db.Raw(riseSql, modid, attrname).Values(&rise)
		if err != nil {
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Err is :%s", err))
			return nil, err
		}
		tacticsObjs = append(tacticsObjs, rise...)
		obj["attrname"] = row["attrname"]
		obj["mpname"] = mpname
		obj["mpid"] = tools.IsEmpty(mpid)
		obj["mod_id"] = tools.IsEmpty(modid)
		obj["clientId"] = ""
		obj["tacticsList"] = tacticsObjs
		// 查询设备下这个测点的独立配置
		// 组装独立配置
		aloneAbs, err := t.GetAbsAloneList(deviceid, mpid)
		if err != nil {
			logger.Logger.Error(err)
			logger.Logger.Println(fmt.Sprintf("Err is :%s", err))
			return nil, err
		}
		aloneLst = append(aloneLst, aloneAbs...)
		aloneRise, err := t.GetRiseAloneList(deviceid, mpid)
		if err != nil {
			logger.Logger.Error(err, fmt.Sprintf("Err is :%s", err))
			return nil, err
		}
		aloneLst = append(aloneLst, aloneRise...)

		obj["aloneList"] = aloneLst
		lst = append(lst, obj)
	}
	return lst, nil
}

// 获取绝对值告警独立配置的列表
func (t *AlarmDeviceService) GetAbsAloneList(deviceid int64, mpid int64) ([]orm.Params, error) {
	db := orm.NewOrm()
	var aloneAbsSql = "SELECT a.id,a.alarm_type,b.strategy_name,b.mod_id,a.attrname,a.threshold FROM t_base_absolute_alarm b,t_base_alone_alarm a WHERE a.alarm_id = b.id and a.deviceid=? and a.mpid=?"
	lst := []orm.Params{}
	_, err := db.Raw(aloneAbsSql, deviceid, mpid).Values(&lst)
	if err != nil {
		logger.Logger.Error(err, fmt.Sprintf("Err is :%s", err))
		return nil, err
	}
	return lst, nil
}

// 获取升温告警独立配置的列表
func (t *AlarmDeviceService) GetRiseAloneList(deviceid int64, mpid int64) ([]orm.Params, error) {
	db := orm.NewOrm()
	var aloneRiseSql = "SELECT a.id,a.alarm_type,b.strategy_name,b.mod_id,a.attrname,b.upcycle,b.scope threshold FROM t_base_rise_alarm b,t_base_alone_alarm a WHERE a.alarm_id = b.id and a.deviceid=? and a.mpid=?"
	lst := []orm.Params{}
	_, err := db.Raw(aloneRiseSql, deviceid, mpid).Values(&lst)
	if err != nil {
		logger.Logger.Error(err, fmt.Sprintf("Err is :%s", err))
		return nil, err
	}
	return lst, nil
}

// 为测点的一个告警策略添加独立的告警阈值
func (t *AlarmDeviceService) InsertAloneDeviceTactics(obj models.T_base_alone_alarm) error {
	db := orm.NewOrm()
	_, err := db.Insert(&obj)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error is:%s", err.Error()))
		new(bo.SystemLog).Fail(enum.Alone_Alarm_Value,
			enum.LogType_Insert,
			enum.OptEventType_Bus,
			enum.OptEventLevel_Hight,
			fmt.Sprintf("保存测点的策略独立配置阈值信息失败:%s", err.Error()),
			map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
		)
		return err
	}
	new(bo.SystemLog).Success(enum.Alone_Alarm_Value,
		enum.LogType_Insert,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		fmt.Sprintf("保存测点的策略独立配置阈值信息成功!"),
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	key := fmt.Sprintf("aloneTactics#%s#%s", obj.Deviceid, obj.Mpid)
	aloneTactics.Delete(key)
	return nil
}

// 修改测点的一个告警策略添加独立的告警阈值
func (t *AlarmDeviceService) UpdateAloneDeviceTactics(obj models.T_base_alone_alarm) error {
	db := orm.NewOrm()
	_, err := db.Update(&obj)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error is:%s", err.Error()))
		new(bo.SystemLog).Fail(enum.Alone_Alarm_Value,
			enum.LogType_Update,
			enum.OptEventType_Bus,
			enum.OptEventLevel_Hight,
			fmt.Sprintf("更新测点的策略独立配置阈值信息失败:%s", err.Error()),
			map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
		)
		return err
	}
	new(bo.SystemLog).Success(enum.Alone_Alarm_Value,
		enum.LogType_Update,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		fmt.Sprintf("更新测点的策略独立配置阈值信息成功!"),
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	key := fmt.Sprintf("aloneTactics#%s#%s", obj.Deviceid, obj.Mpid)
	aloneTactics.Delete(key)
	return nil
}

// 根据deviceid删除独立配置
func (t *AlarmDeviceService) DelAloneDeviceTactics(deviceid int64) error {
	db := orm.NewOrm()
	var sqlCommondText = "DELETE FROM t_base_alone_alarm WHERE deviceid=?"
	_, err := db.Raw(sqlCommondText, deviceid).Exec()
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error is:%s", err.Error()))
		new(bo.SystemLog).Fail(enum.Alone_Alarm_Value,
			enum.LogType_Delete,
			enum.OptEventType_Bus,
			enum.OptEventLevel_Hight,
			fmt.Sprintf("删除测点的策略独立配置阈值信息失败:%s", err.Error()),
			map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
		)
	}
	mpidList, err := t.GetAloneByDevicId(deviceid)
	if err != nil {
		logger.Logger.Error(err, fmt.Sprintf("Error is:%s", err.Error()))
		return err
	}
	for _, item := range mpidList {
		mpid := tools.IsEmpty(item["mpid"])
		key := fmt.Sprintf("aloneTactics%s#%s", deviceid, mpid)
		aloneTactics.Delete(key)
	}
	new(bo.SystemLog).Success(enum.Alone_Alarm_Value,
		enum.LogType_Delete,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		fmt.Sprintf("删除测点的策略独立配置阈值信息成功!"),
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	return nil
}

// 复制一个设备的策略到另外多个设备
func (t *AlarmDeviceService) CopyDeviceTactics(oldDeviceId int64, otherDeviceId int64) (bool, error) {
	// 先从数据库中获取原有设备的独立配置
	db := orm.NewOrm()
	oldObjList := []models.T_base_alone_alarm{}
	_, err := db.QueryTable("t_base_alone_alarm").Filter("deviceid", oldDeviceId).All(&oldObjList)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error is:%s", err.Error()))
		return false, err
	}
	db.Begin()
	// 再改变deviceid的值，复制到其他设备，循环的时候需要判断每一个测点是否在另外的设备下
	for _, row := range oldObjList {
		var aloneObj models.T_base_alone_alarm
		aloneObj.Deviceid = otherDeviceId
		aloneObj.Alarm_type = row.Alarm_type
		aloneObj.Mpid = row.Mpid
		aloneObj.Mpname = row.Mpname
		aloneObj.Attrname = row.Attrname
		if row.Alarm_type == 2 {
			aloneObj.Upcycle = row.Upcycle
		}
		aloneObj.Threshold = row.Threshold
		aloneObj.Alarm_id = row.Alarm_id
		_, err = db.Insert(&aloneObj)
		if err != nil {
			db.Rollback()
			new(bo.SystemLog).Fail(enum.Alone_Alarm_Value,
				enum.LogType_Insert,
				enum.OptEventType_Bus,
				enum.OptEventLevel_Hight,
				fmt.Sprintf("复制测点的策略独立配置阈值信息失败:%s", err.Error()),
				map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
			)
			return false, err
		}
	}
	err = db.Commit()
	if err != nil {
		new(bo.SystemLog).Fail(enum.Alone_Alarm_Value,
			enum.LogType_Insert,
			enum.OptEventType_Bus,
			enum.OptEventLevel_Hight,
			fmt.Sprintf("复制策略批量提交新增失败:%s", err.Error()),
			map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
		)
		return false, err
	}
	return true, nil
}

// 根据deviceid和mpid删除独立配置
func (t *AlarmDeviceService) DelByDeviceMp(deviceid int64, mpid int64, alarmId int64) error {
	db := orm.NewOrm()
	var sqlCommondText = "DELETE FROM t_base_alone_alarm WHERE deviceid=? and mpid=? and alarm_id=?"
	_, err := db.Raw(sqlCommondText, deviceid, mpid, alarmId).Exec()
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error is:%s", err.Error()))
		new(bo.SystemLog).Fail(enum.Alone_Alarm_Value,
			enum.LogType_Delete,
			enum.OptEventType_Bus,
			enum.OptEventLevel_Hight,
			fmt.Sprintf("根据deviceid和mpid删除独立配置阈值信息失败:%s", err.Error()),
			map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
		)
	}
	new(bo.SystemLog).Success(enum.Alone_Alarm_Value,
		enum.LogType_Delete,
		enum.OptEventType_Bus,
		enum.OptEventLevel_Hight,
		fmt.Sprintf("根据deviceid和mpid删除独立配置阈值信息成功!"),
		map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
	)
	key := fmt.Sprintf("aloneTactics#%s#%s", deviceid, mpid)
	aloneTactics.Delete(key)
	return nil
}

// 根据deviceid和mpid获取mpid的独立配置信息
func (t *AlarmDeviceService) GetAloneDeviceTactics(deviceid int64, mpid int64) ([]orm.Params, error) {
	key := fmt.Sprintf("aloneTactics#%s#%s", deviceid, mpid)
	if info, ok := aloneTactics.Load(key); ok {
		return info.([]orm.Params), nil
	}
	db := orm.NewOrm()
	var sqlCommondText = "select * FROM t_base_alone_alarm WHERE deviceid=? and mpid=?"
	lst := []orm.Params{}
	_, err := db.Raw(sqlCommondText, deviceid, mpid).Values(&lst)
	if err != nil {
		logger.Logger.Error(err)
		logger.Logger.Println(fmt.Sprintf("Error is:%s", err.Error()))
		return nil, err
	}
	aloneTactics.Store(key, lst)
	return lst, nil
}

// 根据deviceid获取独立配置下的mpid
func (t *AlarmDeviceService) GetAloneByDevicId(deviceid int64) ([]orm.Params, error) {
	db := orm.NewOrm()
	var sql = "select mpid from t_base_alone_alarm where deviceid=?"
	lst := []orm.Params{}
	_, err := db.Raw(sql, deviceid).Values(&lst)
	if err != nil {
		logger.Logger.Error(err, fmt.Sprintf("Error is:%s", err.Error()))
		return nil, err
	}
	return lst, nil
}

// 根据所选设备导出该设备的所有测点对应的告警策略,作为导入模版
func (t *AlarmDeviceService) ImportModelsDeviceSettingData(deviceid int64) ([]orm.Params, error) {
	ds := new(DeviceService)
	deviceMpList, _, err := ds.DeviceMpList(int32(deviceid), 1, 1000)
	if err != nil {
		logger.Logger.Error(err, fmt.Sprintf("Error is:%s", err.Error()))
		return nil, err
	}
	lst := []orm.Params{}

	if len(deviceMpList) > 0 {
		mod_id, err := strconv.ParseInt(tools.IsEmpty(deviceMpList[0]["modelid"]), 10, 64)
		if err != nil {
			logger.Logger.Error(err, fmt.Sprintf("Error is:%s", err.Error()))
			return nil, err
		}
		db := orm.NewOrm()
		var sqlCommandText = "SELECT a.id alarm_id,m.attrname,m.alarm_type,m.mod_id,a.alarm_level,a.strategy_name,0 upcycle,a.threshold FROM t_base_absolute_alarm a,t_base_alarm_mplist m where a.id=m.fk_id and m.mod_id=?"
		sqlCommandText += " UNION "
		sqlCommandText += "SELECT a.id alarm_id,m.attrname,m.alarm_type,m.mod_id,a.alarm_level,a.strategy_name,a.upcycle,a.scope threshold FROM t_base_rise_alarm a,t_base_alarm_mplist m where a.id=m.fk_id and m.mod_id=?"
		_, err = db.Raw(sqlCommandText, mod_id, mod_id).Values(&lst)
		if err != nil {
			logger.Logger.Error(err, fmt.Sprintf("Error is:%s", err.Error()))
			return nil, err
		}
		if len(lst) > 0 {
			for index, item := range lst {
				for _, row := range deviceMpList {
					if tools.IsEmpty(item["attrname"]) == tools.IsEmpty(row["attrname"]) {
						item["deviceid"] = row["deviceid"]
						item["mpid"] = row["mpid"]
						item["mpname"] = row["mpname"]
						lst[index] = item
						break
					}
				}
			}
		}
	}
	return lst, nil
}

// 根据excel文件导入到独立配置表中
func (t *AlarmDeviceService) ImportExcelDeviceSettingData(param map[string]interface{}) error {
	dataList := param["datalist"].([]map[int]string)
	db := orm.NewOrm()
	var sqlCommandText = "insert into t_base_alone_alarm (alarm_id,deviceid,mpid,attrname,mpname,alarm_type,upcycle,threshold) values "
	feilds := ""
	if len(dataList) > 0 {
		for i := 0; i < len(dataList); i++ {
			feilds += "("
			feilds += "'" + dataList[i][1] + "',"
			if dataList[i][2] == "" {
				feilds = ""
				continue
			}
			feilds += "'" + dataList[i][2] + "',"
			feilds += "'" + dataList[i][3] + "',"
			feilds += "'" + dataList[i][4] + "',"
			feilds += "'" + dataList[i][5] + "',"
			feilds += "'" + dataList[i][6] + "',"
			feilds += "'" + dataList[i][9] + "',"
			if i == len(dataList)-1 {
				feilds += "'" + dataList[i][10] + "')"
			} else {
				feilds += "'" + dataList[i][10] + "'),"
			}
			sqlCommandText += feilds
			feilds = ""
		}
		_, err := db.Raw(sqlCommandText).Exec()
		if err != nil {
			new(bo.SystemLog).Fail(enum.Alone_Alarm_Value,
				enum.LogType_Insert,
				enum.OptEventType_Bus,
				enum.OptEventLevel_Hight,
				fmt.Sprintf("批量导入测点的策略独立配置阈值信息失败:%s", err.Error()),
				map[string]interface{}{"name": t.UserInfo.Usrname, "ip": t.UserInfo.Ip},
			)
		}
	}
	return nil
}

// 专门用于导出的设备
func (t *AlarmDeviceService) ExportExcelDeviceSettingData(deviceid int64) ([]orm.Params, error) {
	lst := []orm.Params{}
	ds := new(DeviceService)
	deviceMpList, _, err := ds.DeviceMpList(int32(deviceid), 1, 10000)
	if err != nil {
		logger.Logger.Error(err, fmt.Sprintf("Error is:%s", err.Error()))
		return nil, err
	}
	for _, row := range deviceMpList {
		mpid, err := strconv.ParseInt(fmt.Sprint(row["mpid"]), 10, 64)
		if err != nil {
			logger.Logger.Error(err, fmt.Sprintf("Error is:%s", err.Error()))
			return nil, err
		}
		abs, err := t.GetAbsAloneList(deviceid, mpid)
		if err != nil {
			logger.Logger.Error(err, fmt.Sprintf("Error is:%s", err.Error()))
			return nil, err
		}
		lst = append(lst, abs...)
		rise, err := t.GetRiseAloneList(deviceid, mpid)
		if err != nil {
			logger.Logger.Error(err, fmt.Sprintf("Error is:%s", err.Error()))
			return nil, err
		}
		lst = append(lst, rise...)
	}
	return lst, nil
}