scd_tools_go/service/models/bo/task.go

package bo

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

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

//检测任务模型
type T_data_task struct {
	Id        int    `orm:"pk"`
	Name      string // '任务名称' ,
	Code      string // '任务编号' ,
	StationId int    // '所属变电站' ,
	ScdId     int64  // 'SCD文件编号' ,
	ReportId  int    // '报告模板ID' ,
	Memo      string // '任务说明' ,
	State     int    // '检测状态;0 未检查 1 检测中 2检测结束 3 异常中断' ,
	StartTime string // '开始检测时间' ,
	EndTime   string // '检测结束时间' ,
	Cr        int    // '创建人' ,
	Ct        string `orm:"-"` // '创建时间' ,
	Ur        int    // '更新人' ,
	Ut        string `orm:"-"` // '更新时间'
}

//检测任务管理对象
type TaskMgr struct {
	Model T_data_task
	DeviceBaseModel
}

var TaskSCD = sync.Map{}

var modelDesc = "检测任务"

//已终止的任务
var stopedTaskMap = sync.Map{}

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

//重置检测异常中断的任务状态。一般在系统启动时处理
func (c *TaskMgr) ChangeErr2Normal() {
	db := orm.NewOrm()
	db.Raw("update t_data_task set state=0 where state=1").Exec()
}

//设置指定任务的状态 flag:0 未检查 1 检测中 2检测结束 3 异常中断
func (c *TaskMgr) SetActive(flag int) (err error) {
	dblog := new(SystemLog)
	dblog.SetUserInfo(c.GetUserInfo())
	dblog.Audittype = enum.AuditType_check_task
	dblog.Logtype = enum.LogType_Execute
	dblog.Eventtype = enum.OptEventType_Bus
	dblog.Eventlevel = enum.OptEventLevel_Hight
	db := orm.NewOrm()
	err = db.Read(&c.Model)
	if err != nil {
		logger.Logger.Error(err)
		return err
	}
	if flag == 0 {
		c.Model.StartTime = "1970-01-01 00:00:00"
		c.Model.EndTime = "1970-01-01 00:00:00"
	}
	if flag == 1 {
		if c.Model.State == 1 {
			return errors.New("当前任务正在检测中")
		}
		c.Model.StartTime = tools.NowTime()
		c.Model.EndTime = "1970-01-01 00:00:00"
	}
	if flag == 2 {
		c.Model.EndTime = tools.NowTime()
	}
	c.Model.State = flag
	_, err = db.Update(&c.Model)
	if err != nil {
		logger.Logger.Error(err)
		dblog.Description = fmt.Sprintf("更新%s%s状态失败：%s,操作数据：%+v", modelDesc, c.Model.Name, err.Error(), c.Model)
		dblog.Fail2()
	} else {
		dblog.Description = fmt.Sprintf("更新%s%s状态,操作数据：%+v", modelDesc, c.Model.Name, c.Model)
		dblog.Success2()
		if flag == 0 {
			return nil
		}
		if flag == 1 {
			return c.start(c.Model)
		}
		if flag == 2 {
			return c.finish(c.Model)
		}
		if flag == 3 {
			return c.stop(c.Model)
		}
	}
	return err
}

//开始检测
func (c *TaskMgr) start(task T_data_task) error {
	scdParse := new(ScdParse)
	scdParse.SetUserInfo(c.GetUserInfo())
	scdMgr := new(ScdMgr)
	scdMgr.SetUserInfo(c.GetUserInfo())
	scdInfo, err := scdMgr.One(fmt.Sprintf("%d", task.ScdId))
	if err != nil {
		return err
	}
	c.Model.Id = task.Id
	_, cnt, _ := c.GetModels()
	if cnt == 0 {
		return errors.New("该检测任务还未配置检测模型")
	}
	TaskSCD.Store(task.ScdId, task)
	db := orm.NewOrm()
	//清除原步骤及状态
	db.Raw("delete from t_data_task_check_step where task_id=?", task.Id).Exec()
	db.Raw("delete from t_scd_node_rule_parse where scd_id=?", task.ScdId).Exec()
	//生成新的步骤
	db.Raw("insert into t_data_task_check_step(task_id,task_step_id,state) select ?,id,0 from global_const_code where parentcode='CHECK_STEP' order by id", task.Id).Exec()
	var isStop = func(taskid int) bool {
		v, r := stopedTaskMap.Load(taskid)
		if r {
			return v.(bool)
		}
		return false
	}
	go func(task T_data_task, scdInfo orm.Params) {
		_, err = scdParse.XmlIEDParse(tools.IsEmpty(scdInfo["station_id"]), tools.IsEmpty(scdInfo["path"]), tools.IsEmpty(scdInfo["scd_name"]))
		if isStop(task.Id) {
			return
		}
		if err == nil {
			scdParse.XmlCheckParse(task.ScdId)
			if isStop(task.Id) {
				return
			}
			//模型分析
			c.SetStep(tools.IsEmpty(task.ScdId), enum.TaskStep_SCD_model_parse.Code(), 1)
			checkAreaMgr := new(CheckAreaMgr)
			checkAreaMgr.ScdId = task.ScdId
			err = checkAreaMgr.CheckAreaIedRelation()
			if isStop(task.Id) {
				return
			}
			if err != nil {
				c.SetStep(tools.IsEmpty(task.ScdId), enum.TaskStep_SCD_model_parse.Code(), 3, err.Error())
				c.SetStep(tools.IsEmpty(task.ScdId), enum.TaskStep_SCD_func_parse.Code(), 3, "终止")
				c.SetStep(tools.IsEmpty(task.ScdId), enum.TaskStep_SCD_fcda_parse.Code(), 3, "终止")
			} else {
				c.SetStep(tools.IsEmpty(task.ScdId), enum.TaskStep_SCD_model_parse.Code(), 2)
				//功能分析
				err = checkAreaMgr.CheckAreaIedRelation()
				if isStop(task.Id) {
					return
				}
				c.SetStep(tools.IsEmpty(task.ScdId), enum.TaskStep_SCD_func_parse.Code(), 1)
				if err != nil {
					c.SetStep(tools.IsEmpty(task.ScdId), enum.TaskStep_SCD_func_parse.Code(), 3, err.Error())
					c.SetStep(tools.IsEmpty(task.ScdId), enum.TaskStep_SCD_fcda_parse.Code(), 3, "终止")
				} else {
					c.SetStep(tools.IsEmpty(task.ScdId), enum.TaskStep_SCD_func_parse.Code(), 2)
					//端子分析
					c.SetStep(tools.IsEmpty(task.ScdId), enum.TaskStep_SCD_fcda_parse.Code(), 1)
					err = checkAreaMgr.CheckIedFcda()
					if isStop(task.Id) {
						return
					}
					if err != nil {
						c.SetStep(tools.IsEmpty(task.ScdId), enum.TaskStep_SCD_fcda_parse.Code(), 3, err.Error())
					} else {
						c.SetStep(tools.IsEmpty(task.ScdId), enum.TaskStep_SCD_fcda_parse.Code(), 2)
					}
				}
			}
		}
	}(task, scdInfo)
	return err
}

//取消/终止检测
func (c *TaskMgr) stop(task T_data_task) error {
	TaskSCD.Delete(task.ScdId)
	stopedTaskMap.Store(task.Id, true)
	db := orm.NewOrm()
	_, err := db.Raw("update t_data_task_check_step set state=3,ut=now() where task_id=? and state<2", task.Id).Exec()
	return err
}

//完成检测
func (c *TaskMgr) finish(task T_data_task) error {
	db := orm.NewOrm()
	_, err := db.Raw("update t_data_task_check_step set state=2,ut=now() where task_id=? and state=0", task.Id).Exec()
	return err
}

//更新检测步骤状态
func (c *TaskMgr) SetStep(scdid string, stepcode string, state int, msg ...string) {
	db := orm.NewOrm()
	scdidint64, _ := strconv.ParseInt(scdid, 10, 64)
	taskid, has := TaskSCD.Load(scdidint64)
	if !has {
		return
	}
	errormsg := ""
	if len(msg) > 0 {
		errormsg = msg[0]
	}
	t1 := "ct" //步骤开始时间字段
	if state > 1 {
		t1 = "ut" //步骤结束时间字段
	}
	db.Raw("update t_data_task_check_step set state=?,state_msg=?,"+t1+"=now() where task_id=? and task_step_id=(select id from global_const_code where parentcode='CHECK_STEP' and code=?)", state, errormsg, taskid, stepcode).Exec()
	// 所有步骤都不为0和1了，则分析完成
	hasStep := []orm.Params{}
	_, err := db.Raw("select count(1) cnt from t_data_task_check_step where task_id=? and state in(0,1)", taskid).Values(&hasStep)
	if err != nil {
		logger.Logger.Error(err)
		return
	}
	if len(hasStep) == 0 || tools.IsEmpty(hasStep[0]["cnt"]) == "0" {
		// 全部步骤检测完成，更改任务检测状态为已完成
		db.Raw("update t_data_task set state=2 where id=?", taskid).Exec()
	}
}

//保存任务信息
func (c *TaskMgr) Save() (id int, err error) {
	dblog := new(SystemLog)
	dblog.SetUserInfo(c.GetUserInfo())
	dblog.Audittype = enum.AuditType_check_task
	dblog.Logtype = enum.LogType_Insert
	dblog.Eventtype = enum.OptEventType_Bus
	dblog.Eventlevel = enum.OptEventLevel_Hight
	db := orm.NewOrm()
	oldinfo := T_data_task{}
	oldid, _ := c.ExistName(c.Model.Name)
	if c.Model.Id == 0 {
		if oldid != "" {
			return 0, errors.New("任务名称（" + c.Model.Name + "）已存在")
		}
		c.Model.StartTime = "1970-01-01 00:00:00"
		c.Model.EndTime = "1970-01-01 00:00:00"
		c.Model.State = 0
		c.Model.Cr, _ = strconv.Atoi(c.GetUserId())
		id64 := int64(0)
		id64, err = db.Insert(&c.Model)
		id = int(id64)
	} else {
		if oldid != "" && oldid != tools.IsEmpty(c.Model.Id) {
			return 0, errors.New("任务名称（" + c.Model.Name + "）已存在")
		}
		id = c.Model.Id
		oldinfo, _ = c.One()
		if oldinfo.State == 1 {
			return 0, errors.New("任务正在检测中，不允许编辑")
		}
		if oldinfo.State == 2 {
			return 0, errors.New("任务已检测完成，不允许编辑")
		}
		c.Model.StartTime = oldinfo.StartTime
		c.Model.EndTime = oldinfo.EndTime
		c.Model.State = oldinfo.State
		c.Model.Ur, _ = strconv.Atoi(c.GetUserId())
		_, err = db.Update(&c.Model)
	}
	if err != nil {
		logger.Logger.Error(err)
		dblog.Description = fmt.Sprintf("保存%s信息失败：%s,操作数据：%+v", modelDesc, err.Error(), c.Model)
		dblog.Fail2()
	} else {
		dblog.Description = fmt.Sprintf("保存%s信息成功,操作数据：%+v", modelDesc, c.Model)
		dblog.Success2()
		if oldinfo.Id == 0 || oldinfo.ScdId != c.Model.ScdId {
			// 解析模型间隔及标准装置
			checkArea := new(CheckAreaMgr)
			checkArea.ScdId = c.Model.ScdId
			checkArea.Reset()
		}
	}
	return id, err
}

func (c *TaskMgr) One() (T_data_task, error) {
	if c.Model.Id == 0 {
		return c.Model, errors.New("未指定id")
	}
	o := orm.NewOrm()
	tmp := T_data_task{Id: c.Model.Id}
	err := o.Read(&tmp)
	if err != nil {
		logger.Logger.Error(err)
	}
	return tmp, err
}

func (c *TaskMgr) ExistName(name string) (string, error) {
	o := orm.NewOrm()
	rowset := []orm.Params{}
	_, err := o.Raw("select id from t_data_task where name=?", name).Values(&rowset)
	if err != nil {
		logger.Logger.Error(err)
		return "", err
	}
	if len(rowset) > 0 {
		return tools.IsEmpty(rowset[0]["id"]), nil
	}
	return "", nil
}

//根据model中指定的id删除检测任务
func (c *TaskMgr) Delete() (err error) {
	dblog := new(SystemLog)
	u := c.GetUserInfo()
	dblog.SetUserInfo(u)
	dblog.Audittype = enum.AuditType_check_task
	dblog.Logtype = enum.LogType_Delete
	dblog.Eventtype = enum.OptEventType_Bus
	dblog.Eventlevel = enum.OptEventLevel_Hight
	db := orm.NewOrm()
	if c.Model.Id == 0 {
		return errors.New("无效的ID")
	} else {
		db.Read(&c.Model)
		if c.Model.State == 1 {
			return errors.New("任务正在检测中，不允许删除")
		}
		_, err = db.Delete(&c.Model)
	}
	if err != nil {
		logger.Logger.Error(err)
		dblog.Description = fmt.Sprintf("删除%s%s失败：%s", modelDesc, c.Model.Name, err.Error())
		dblog.Fail2()
	} else {
		TaskSCD.Delete(c.Model.ScdId)
		dblog.Description = fmt.Sprintf("删除%s%s成功", modelDesc, c.Model.Name)
		dblog.Success2()
		//同步删除关联数据
		db.Raw("delete from t_data_task_check_step where task_id=?", c.Model.Id).Exec()
		db.Raw("delete from t_data_check_area where scd_id=?", c.Model.ScdId).Exec()
		db.Raw("delete from t_data_check_area_ied where scd_id=?", c.Model.ScdId).Exec()
		scdmgr := new(ScdMgr)
		scdmgr.SetUserInfo(u)
		scdmgr.DeleteScd(strconv.FormatInt(c.Model.ScdId, 10), true)
		//删除关联模型
		m1 := new(TaskModelMgr)
		m1.SetUserInfo(u)
		m1.Model = T_data_task_model{TaskId: c.Model.Id}
		m1.Delete()
		//删除报告关联数据
		r1 := new(TaskReportMgr)
		r1.SetUserInfo(u)
		r1.Model = T_data_task_report{TaskId: c.Model.Id}
		r1.Delete()
	}
	return err
}

//根据model中的指定过滤属性条件查询任务列表
func (c *TaskMgr) List(pageno, pagesize int) ([]orm.Params, int, error) {
	dblog := new(SystemLog)
	dblog.SetUserInfo(c.GetUserInfo())
	dblog.Audittype = enum.AuditType_check_task
	dblog.Logtype = enum.LogType_Query
	dblog.Eventtype = enum.OptEventType_Bus
	dblog.Eventlevel = enum.OptEventLevel_Low
	o := orm.NewOrm()
	sqlParamters := []interface{}{}
	sql := "select t.*,u.name username,s.scd_name,ts.area_name station_name,c1.id voltage_level,c1.name voltage_name from t_data_task t left join t_scd_scl s on t.scd_id=s.id left join t_data_user u on t.cr=u.id left join t_data_area ts on t.station_id=ts.ID left join global_const_code c1 on ts.AREA_LEVEL=c1.id and c1.parentcode='voltage_level' where 1=1 "

	if c.Model.Id > 0 {
		sql += " and t.id=?"
		sqlParamters = append(sqlParamters, c.Model.Id)
	}
	if c.Model.StationId > 0 {
		sql += " and t.station_id=?"
		sqlParamters = append(sqlParamters, c.Model.StationId)
	}
	if c.Model.Name != "" {
		sql += " and t.name like ?"
		sqlParamters = append(sqlParamters, "%"+c.Model.Name+"%")
	}
	if c.Model.ScdId > 0 {
		sql += " and t.scd_id=?"
		sqlParamters = append(sqlParamters, c.Model.ScdId)
	}
	if c.Model.State >= 0 {
		sql += " and t.state=?"
		sqlParamters = append(sqlParamters, c.Model.State)
	}
	if c.Model.StartTime != "" {
		sql += " and t.ct>=?"
		sqlParamters = append(sqlParamters, c.Model.StartTime+" 00:00:00")
	}
	if c.Model.EndTime != "" {
		sql += " and t.ct<=?"
		sqlParamters = append(sqlParamters, c.Model.EndTime+" 23:59:59")
	}
	limit := fmt.Sprintf(" order by t.ct desc limit %d,%d", (pageno-1)*pagesize, pagesize)
	r := []orm.Params{}
	_, err := o.Raw(sql+limit, sqlParamters).Values(&r)
	dblog.Description = fmt.Sprintf("SQL：%s 参数：%+v", sql+limit, sqlParamters)
	if err != nil {
		logger.Logger.Error(err, dblog.Description)
		dblog.Fail2()
		return nil, 0, err
	}
	dblog.Success2()
	total := []orm.Params{}
	_, err = o.Raw(strings.Replace(sql, "t.*,u.name username,s.scd_name,ts.area_name station_name", "count(1) cnt", 1), sqlParamters).Values(&total)
	if err != nil {
		logger.Logger.Error(err)
		return nil, 0, err
	}
	totalCnt := 0
	if len(total) > 0 {
		totalCnt, _ = strconv.Atoi(tools.IsEmpty(total[0]["cnt"]))
	}
	return r, totalCnt, err
}

//获取指定任务的已选择模型对应的系统内置模型
func (c *TaskMgr) GetModels() ([]orm.Params, int, error) {
	if c.Model.Id == 0 {
		return nil, 0, errors.New("任务ID不能为空")
	}
	db := orm.NewOrm()
	rowset := []orm.Params{}
	_, err := db.Raw("select t.*,t1.from_model_id sys_model_id,t2.model_name,t2.vol_id,t2.line_link_style from t_data_task_model t,t_data_model_defualt t1,t_data_model_defualt t2 where t.model_id=t1.id and t1.from_model_id=t2.id and t.task_id=?", c.Model.Id).Values(&rowset)
	if err != nil {
		return rowset, 0, err
	}
	return rowset, len(rowset), nil
}

//根据SCD ID获取指定任务的已选择模型
func (c *TaskMgr) GetModelsByScdID(scdid int64) ([]orm.Params, int, error) {
	if scdid == 0 {
		return nil, 0, errors.New("SCD ID不能为空")
	}
	db := orm.NewOrm()
	rowset := []orm.Params{}
	_, err := db.Raw("select t.*,t1.model_name,t1.vol_id,t1.line_link_style from t_data_task a, t_data_task_model t,t_data_model_defualt t1 where a.id=t.task_id and t.model_id=t1.id and a.scd_id=?", scdid).Values(&rowset)
	if err != nil {
		return rowset, 0, err
	}
	return rowset, len(rowset), nil
}

func (c *TaskMgr) GetCheckStepInfo() ([]orm.Params, int, error) {
	db := orm.NewOrm()
	rowset := []orm.Params{}
	_, err := db.Raw("select a.*,a1.name step_name,case a.state when 0 then '未开始' when 1 then '检测中' when 2 then '已完成' when 3 then '检测终止' else '检测异常' end state_name from t_data_task_check_step a left join global_const_code a1 on a.task_step_id=a1.id and a1.parentcode='CHECK_STEP' where a.task_id=? order by a1.id ", c.Model.Id).Values(&rowset)
	if err != nil {
		return rowset, 0, err
	}
	return rowset, len(rowset), nil
}