You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
564 lines
19 KiB
564 lines
19 KiB
package task
|
|
|
|
import (
|
|
dal "LAPP_ACURA_MOM_BACKEND/dao/base"
|
|
dal_pm "LAPP_ACURA_MOM_BACKEND/dao/pm"
|
|
"LAPP_ACURA_MOM_BACKEND/db"
|
|
"LAPP_ACURA_MOM_BACKEND/grmi"
|
|
meta "LAPP_ACURA_MOM_BACKEND/meta/pm"
|
|
model "LAPP_ACURA_MOM_BACKEND/models/pm"
|
|
"LAPP_ACURA_MOM_BACKEND/utils"
|
|
"LAPP_ACURA_MOM_BACKEND/web/middleware/glog"
|
|
"context"
|
|
"log"
|
|
"strconv"
|
|
"time"
|
|
)
|
|
|
|
func CreateTask() {
|
|
tick := time.Tick(60 * time.Second)
|
|
for {
|
|
select {
|
|
case <-tick:
|
|
CreateOrder()
|
|
}
|
|
}
|
|
}
|
|
|
|
//结构体
|
|
type TaskData struct {
|
|
TaskType string
|
|
PmAsset model.Asset
|
|
PmTemplate model.Template
|
|
PmService model.Service
|
|
}
|
|
|
|
var taskChan = make(chan TaskData, 1000) //定义一个调度任务通道
|
|
|
|
/****
|
|
*生成维护工单
|
|
***************/
|
|
func CreateOrder() {
|
|
|
|
//创建继承Baxkground的子节点Context
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
go doSth(ctx)
|
|
|
|
data := make([]model.CreateData, 0)
|
|
//第一步，多表联查出所有的数据
|
|
engine := db.Eloquent.Master()
|
|
query := engine.Table("PM_ASSET")
|
|
query = query.Join("INNER", "PM_AssetTemplateLst", "PM_Asset.PlantNr = PM_AssetTemplateLst.PlantNr and PM_Asset.AssetNr = PM_AssetTemplateLst.AssetNr")
|
|
query = query.Join("INNER", "PM_Template", "PM_Template.PlantNr = PM_AssetTemplateLst.PlantNr and PM_Template.MainTemplateNr = PM_AssetTemplateLst.MainTemplateNr")
|
|
query = query.Join("INNER", "PM_TemplateServiceLst", "PM_Template.PlantNr = PM_TemplateServiceLst.PlantNr and PM_Template.MainTemplateNr = PM_TemplateServiceLst.MainTemplateNr")
|
|
query = query.Join("INNER", "PM_Service", "PM_Service.PlantNr = PM_TemplateServiceLst.PlantNr and PM_Service.MainServiceNr = PM_TemplateServiceLst.MainServiceNr")
|
|
|
|
query = query.Where("PM_Service.SchedType = ?", "AUTO")
|
|
err := query.Find(&data)
|
|
if err != nil {
|
|
return
|
|
}
|
|
//第二步，把所有的服务调度放到channel
|
|
for _, v := range data {
|
|
//判断激活状态
|
|
if utils.ValueIsEmpty(v.Service.EnabledToggle) {
|
|
continue
|
|
}
|
|
dataone := TaskData{}
|
|
dataone.PmService = v.Service
|
|
dataone.PmTemplate = v.Template
|
|
dataone.PmAsset = v.Asset
|
|
//判断taskType
|
|
if v.Service.MaintByDateToggle {
|
|
dataone.TaskType = "A" //A是按照日期维护
|
|
} else if v.Service.MaintByHourToggle {
|
|
dataone.TaskType = "B" //B是按照小时维护
|
|
} else if v.Service.MaintByMileageToggle {
|
|
dataone.TaskType = "C" //C是按照仪表值维护
|
|
} else if v.Service.NeedScheduleToggle {
|
|
dataone.TaskType = "D" //D是按照调度维护
|
|
} else {
|
|
continue
|
|
}
|
|
taskChan <- dataone
|
|
}
|
|
}
|
|
|
|
//生成任务工单
|
|
func doSth(ctx context.Context) {
|
|
engine := db.Eloquent.Master()
|
|
//第三步，启动协程，从channel里读取数据，根据服务维护日期进入不同的方法里
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case task, ok := <-taskChan:
|
|
if !ok {
|
|
log.Println("调度生成终止")
|
|
return //停机退出
|
|
}
|
|
session := engine.NewSession()
|
|
defer session.Close()
|
|
|
|
dao_workorder := dal_pm.NewWorkOrderDAO(session, task.PmService.PlantNr, "PM_Service")
|
|
snrDao := dal.NewSnrDAO(session, task.PmService.PlantNr, "PM_Service")
|
|
dao_serviceattrlst := dal_pm.NewServiceAttrLstDAO(session, task.PmService.PlantNr, "PM_Service")
|
|
dao_workorderattrlst := dal_pm.NewWorkOrderAttrLstDAO(session, task.PmService.PlantNr, "PM_Service")
|
|
dao_workcalendarlst := dal.NewWorkCalendarLstDAO(session, task.PmAsset.PlantNr, "PM_Service")
|
|
dao_AssetKpi := dal_pm.NewAssetKpiDAO(session, task.PmAsset.PlantNr, "PM_Service")
|
|
|
|
switch task.TaskType {
|
|
case "A":
|
|
//当前零点时间
|
|
today := utils.GetZeroTime(time.Now())
|
|
//逻辑：判断是否到了维护时间，（当前时间戳-起始时间戳）%间隔时间
|
|
t1 := utils.TimeFormat(time.Now(), "yyyyMMdd")
|
|
t2 := task.PmService.DueDateOn
|
|
time1, _ := utils.TimeParseyyyyMMdd(t1)
|
|
time2, _ := utils.TimeParseyyyyMMdd(t2.ToString())
|
|
timelen := int(time1.Unix()) - int(time2.Unix())
|
|
timeunit := task.PmService.DueDateInterval
|
|
glog.InfoExtln("维护工单A", "Mainservicenr:", task.PmService.MainServiceNr)
|
|
glog.InfoExtln("维护工单A", "t1:", t1)
|
|
glog.InfoExtln("维护工单A", "t2:", task.PmService.DueDateOn)
|
|
glog.InfoExtln("维护工单A", "timelen:", timelen)
|
|
glog.InfoExtln("维护工单A", "timeunit:", timeunit)
|
|
glog.InfoExtln("维护工单A", "res:", ((timelen / 86400) % timeunit))
|
|
if res := ((timelen / 86400) % timeunit); res == 0 {
|
|
//判断是否已经生成了维护工单，如果生成了，跳过
|
|
tem, err := dao_workorder.SelectLastOne(task.PmService.PlantNr,task.PmService.MainServiceNr,task.PmAsset.AssetNr)
|
|
if err!=nil {
|
|
glog.InfoExtln("维护工单A", "err:", err)
|
|
continue
|
|
}
|
|
//判断是否添加了服务
|
|
t2now, _ := utils.TimeParse(tem.ActBegTime.ToString())
|
|
endtime := t2now.AddDate(0, 0, timeunit)
|
|
//先把时间字符串格式化成相同的时间类型
|
|
nowtime, _ := utils.TimeParseyyyyMMdd(t1)
|
|
|
|
if nowtime.Before(endtime) {
|
|
//处理逻辑
|
|
glog.InfoExtln("维护工单A", "nowtime:", nowtime)
|
|
glog.InfoExtln("维护工单A", "endtime:", endtime)
|
|
continue
|
|
}
|
|
|
|
glog.InfoExtln("维护工单A", "endtime:", endtime)
|
|
|
|
workOrderId, err := snrDao.GetNextSnr("WorkOrder")
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
//符合逻辑生成维护工单
|
|
pm := new(model.WorkOrder)
|
|
pm.PlantNr = task.PmService.PlantNr
|
|
pm.MaintWorkOrderId = workOrderId
|
|
pm.MainServiceNr = strconv.Itoa(task.PmService.MainServiceNr)
|
|
pm.Descr = task.PmService.Descr
|
|
pm.Status = 26
|
|
pm.Priority = task.PmService.Priority
|
|
pm.AssetNr = task.PmAsset.AssetNr
|
|
pm.PlBegDat = grmi.Date(time.Now())
|
|
pm.SchedBegTime = grmi.DateTime(time.Now())
|
|
endtime = today.AddDate(0, 0, timeunit)
|
|
pm.SchedEndTime = grmi.DateTime(endtime)
|
|
pm.ActBegTime = grmi.DateTime(today)
|
|
pm.ActEndTime = grmi.DateTime(endtime)
|
|
//查询当天是否是工作日,如果是跳过
|
|
engine := db.Eloquent.Master()
|
|
session := engine.NewSession()
|
|
defer session.Close()
|
|
dao := dal.NewWorkCalendarLstDAO(session, task.PmAsset.PlantNr, "PM_Service")
|
|
ok := dao.IsWorkDate(t1)
|
|
if !ok {
|
|
result, err := dao.SelectNearWorkDate(t1)
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
if result == nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
} else {
|
|
Acttime := result.WorkDate.Restore()
|
|
pm.ActBegTime = grmi.DateTime(Acttime)
|
|
Actendtime := Acttime.AddDate(0, 0, timeunit)
|
|
glog.InfoExtln("维护工单A", "Actendtime:", Actendtime)
|
|
pm.ActEndTime = grmi.DateTime(Actendtime)
|
|
}
|
|
}
|
|
|
|
pm.MaintType = task.PmService.MaintType
|
|
err = dao_workorder.InsertOne(pm)
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
|
|
data, err := dao_serviceattrlst.Select([]grmi.Predicate{meta.ServiceAttrLst_PlantNr.NewPredicate(grmi.Equal, task.PmService.PlantNr), meta.ServiceAttrLst_MainServiceNr.NewPredicate(grmi.Equal, task.PmService.MainServiceNr)}, nil)
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
//生成属性
|
|
for _, v := range data {
|
|
at := new(model.WorkOrderAttrLst)
|
|
at.PlantNr = v.PlantNr
|
|
at.Descr = v.Descr
|
|
at.MainServiceNr = v.MainServiceNr
|
|
at.MaintWorkOrderId = workOrderId
|
|
at.Pos = v.Pos
|
|
at.Parameter = v.Parameter
|
|
at.ParaValue = v.ParaValue
|
|
at.AttrNr = v.AttrNr
|
|
err := dao_workorderattrlst.InsertOne(at)
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
session.Commit()
|
|
case "B":
|
|
today := utils.TimeFormat(time.Now(), "yyyyMMdd")
|
|
//查询当天是否是工作日,如果是跳过
|
|
engine := db.Eloquent.Master()
|
|
session := engine.NewSession()
|
|
defer session.Close()
|
|
|
|
ok := dao_workcalendarlst.IsWorkDate(today)
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
//逻辑：起始时间+间隔时间，
|
|
t1 := utils.TimeFormat(time.Now(), "yyyyMMddHHmmss")
|
|
//判断是否已经生成了维护工单，如果生成了，跳过
|
|
tem, err := dao_workorder.SelectLastOne(task.PmService.PlantNr,task.PmService.MainServiceNr,task.PmAsset.AssetNr)
|
|
if err != nil{
|
|
glog.InfoExtln("维护工单B", "err:", err)
|
|
continue
|
|
}
|
|
|
|
glog.InfoExtln("维护工单B", "tem:", tem)
|
|
|
|
time2, _ := utils.TimeParse(tem.ActBegTime.ToString())
|
|
time1, _ := utils.TimeParse(t1)
|
|
timelen := int(time1.Unix()) - int(time2.Unix())
|
|
timeunit := task.PmService.DueHourInterval
|
|
|
|
glog.InfoExtln("维护工单B", "Mainservicenr:", task.PmService.MainServiceNr)
|
|
glog.InfoExtln("维护工单B", "tem.Actbegtime:", tem.ActBegTime)
|
|
glog.InfoExtln("维护工单B", "timelen:", timelen)
|
|
glog.InfoExtln("维护工单B", "timeunit:", timeunit)
|
|
if (timelen - timeunit*3600) > 0 {
|
|
workOrderId, err := snrDao.GetNextSnr("WorkOrder")
|
|
if err != nil {
|
|
glog.InfoExtln("维护工单B", "err:", err)
|
|
continue
|
|
}
|
|
|
|
//查询当天是否是工作日,如果是跳过
|
|
engine := db.Eloquent.Master()
|
|
session := engine.NewSession()
|
|
defer session.Close()
|
|
|
|
res := dao_workcalendarlst.IsWorkDate(today)
|
|
if !res {
|
|
continue
|
|
}
|
|
|
|
//符合逻辑生成维护工单
|
|
pm := new(model.WorkOrder)
|
|
pm.PlantNr = task.PmService.PlantNr
|
|
pm.MaintWorkOrderId = workOrderId
|
|
pm.MainServiceNr = strconv.Itoa(task.PmService.MainServiceNr)
|
|
pm.Descr = task.PmService.Descr
|
|
pm.Status = 26
|
|
pm.Priority = task.PmService.Priority
|
|
pm.AssetNr = task.PmAsset.AssetNr
|
|
pm.PlBegDat = grmi.Date(time.Now())
|
|
timeNow := time.Now()
|
|
pm.SchedBegTime = grmi.DateTime(timeNow)
|
|
//计算结束时间
|
|
endtime := timeNow.Add(time.Duration(timeunit) * time.Hour)
|
|
glog.InfoExtln("维护工单B", "timeunit:", timeunit)
|
|
pm.SchedEndTime = grmi.DateTime(endtime)
|
|
pm.ActBegTime = grmi.DateTime(timeNow)
|
|
pm.ActEndTime = grmi.DateTime(endtime)
|
|
pm.MaintType = task.PmService.MaintType
|
|
err = dao_workorder.InsertOne(pm)
|
|
if err != nil {
|
|
glog.InfoExtln("维护工单B", "err:", err)
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
|
|
data, err := dao_serviceattrlst.Select([]grmi.Predicate{meta.ServiceAttrLst_PlantNr.NewPredicate(grmi.Equal, task.PmService.PlantNr), meta.ServiceAttrLst_MainServiceNr.NewPredicate(grmi.Equal, task.PmService.MainServiceNr)}, nil)
|
|
if err != nil {
|
|
glog.InfoExtln("维护工单B", "err:", err)
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
//生成属性
|
|
for _, v := range data {
|
|
at := new(model.WorkOrderAttrLst)
|
|
at.PlantNr = v.PlantNr
|
|
at.Descr = v.Descr
|
|
at.MainServiceNr = v.MainServiceNr
|
|
at.MaintWorkOrderId = workOrderId
|
|
at.Pos = v.Pos
|
|
at.Parameter = v.Parameter
|
|
at.ParaValue = v.ParaValue
|
|
at.AttrNr = v.AttrNr
|
|
err := dao_workorderattrlst.InsertOne(at)
|
|
if err != nil {
|
|
glog.InfoExtln("维护工单B", "err:", err)
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
session.Commit()
|
|
case "C":
|
|
today := utils.TimeFormat(time.Now(), "yyyyMMdd")
|
|
//查询当天是否是工作日,如果是跳过
|
|
engine := db.Eloquent.Master()
|
|
session := engine.NewSession()
|
|
defer session.Close()
|
|
dao := dal.NewWorkCalendarLstDAO(session, task.PmAsset.PlantNr, "PM_Service")
|
|
ok := dao.IsWorkDate(today)
|
|
if !ok {
|
|
continue
|
|
}
|
|
//逻辑：仪表值
|
|
//第一步：查询资产阈值表，判断是否是触发状态
|
|
info, err := dao_AssetKpi.Select([]grmi.Predicate{meta.AssetKpi_PlantNr.NewPredicate(grmi.Equal, task.PmService.PlantNr), meta.AssetKpi_MainServiceNr.NewPredicate(grmi.Equal, task.PmService.MainServiceNr)}, nil)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
for _, pmaInfo := range info {
|
|
switch pmaInfo.KpiType {
|
|
case 1:
|
|
if pmaInfo.TriggerStatus == 1 {
|
|
continue
|
|
}
|
|
if pmaInfo.ThresholdVal < pmaInfo.ActualVal {
|
|
continue
|
|
}
|
|
|
|
//第二步：生成维护工单，
|
|
//逻辑：根据调度时间维护
|
|
workOrderId, err := snrDao.GetNextSnr("WorkOrder")
|
|
if err != nil {
|
|
continue
|
|
}
|
|
log.Printf("流水号id:%v", workOrderId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
//符合逻辑生成维护工单
|
|
pm := new(model.WorkOrder)
|
|
pm.PlantNr = task.PmService.PlantNr
|
|
pm.MaintWorkOrderId = workOrderId
|
|
pm.MainServiceNr = strconv.Itoa(task.PmService.MainServiceNr)
|
|
pm.Descr = task.PmService.Descr
|
|
pm.Status = 26
|
|
pm.Priority = task.PmService.Priority
|
|
pm.AssetNr = task.PmAsset.AssetNr
|
|
pm.PlBegDat = grmi.Date(time.Now())
|
|
pm.SchedBegTime = grmi.DateTime(time.Now())
|
|
timenow := utils.ValueToString(task.PmService.MainTimeLen, "")
|
|
m, _ := time.ParseDuration(timenow + "h")
|
|
pm.SchedEndTime = grmi.DateTime(time.Now().Add(m))
|
|
pm.ActBegTime = pm.SchedBegTime
|
|
pm.ActEndTime = pm.SchedEndTime
|
|
pm.MaintType = task.PmService.MaintType
|
|
err = dao_workorder.InsertOne(pm)
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
data, err := dao_serviceattrlst.Select([]grmi.Predicate{meta.ServiceAttrLst_PlantNr.NewPredicate(grmi.Equal, task.PmService.PlantNr), meta.ServiceAttrLst_MainServiceNr.NewPredicate(grmi.Equal, task.PmService.MainServiceNr)}, nil)
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
//生成属性
|
|
for _, v := range data {
|
|
at := new(model.WorkOrderAttrLst)
|
|
at.PlantNr = v.PlantNr
|
|
at.Descr = v.Descr
|
|
at.MainServiceNr = v.MainServiceNr
|
|
at.MaintWorkOrderId = workOrderId
|
|
at.Pos = v.Pos
|
|
at.Parameter = v.Parameter
|
|
at.ParaValue = v.ParaValue
|
|
at.AttrNr = v.AttrNr
|
|
err := dao_workorderattrlst.InsertOne(at)
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
}
|
|
//第三步：锁定触发器状态
|
|
pmaInfo.TriggerStatus = 1
|
|
err = dao_AssetKpi.UpdateOne(&pmaInfo)
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
|
|
case 2:
|
|
if pmaInfo.CounterVal < pmaInfo.CounterCycleVal {
|
|
continue
|
|
}
|
|
//第二步：生成维护工单，
|
|
//逻辑：根据调度时间维护
|
|
workOrderId, err := snrDao.GetNextSnr("WorkOrder")
|
|
if err != nil {
|
|
continue
|
|
}
|
|
log.Printf("流水号id:%v", workOrderId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
//符合逻辑生成维护工单
|
|
pm := new(model.WorkOrder)
|
|
pm.PlantNr = task.PmService.PlantNr
|
|
pm.MaintWorkOrderId = workOrderId
|
|
pm.MainServiceNr = strconv.Itoa(task.PmService.MainServiceNr)
|
|
pm.Descr = task.PmService.Descr
|
|
pm.Status = 26
|
|
pm.Priority = task.PmService.Priority
|
|
pm.AssetNr = task.PmAsset.AssetNr
|
|
pm.PlBegDat = grmi.Date(time.Now())
|
|
pm.SchedBegTime = grmi.DateTime(time.Now())
|
|
timenow := utils.ValueToString(task.PmService.MainTimeLen, "")
|
|
m, _ := time.ParseDuration(timenow + "h")
|
|
pm.SchedEndTime = grmi.DateTime(time.Now().Add(m))
|
|
pm.ActBegTime = pm.SchedBegTime
|
|
pm.ActEndTime = pm.SchedEndTime
|
|
pm.MaintType = task.PmService.MaintType
|
|
|
|
dao_workorder.InsertOne(pm)
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
data, err := dao_serviceattrlst.Select([]grmi.Predicate{meta.ServiceAttrLst_PlantNr.NewPredicate(grmi.Equal, task.PmService.PlantNr), meta.ServiceAttrLst_MainServiceNr.NewPredicate(grmi.Equal, task.PmService.MainServiceNr)}, nil)
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
//生成属性
|
|
for _, v := range data {
|
|
at := new(model.WorkOrderAttrLst)
|
|
at.PlantNr = v.PlantNr
|
|
at.Descr = v.Descr
|
|
at.MainServiceNr = v.MainServiceNr
|
|
at.MaintWorkOrderId = workOrderId
|
|
at.Pos = v.Pos
|
|
at.Parameter = v.Parameter
|
|
at.ParaValue = v.ParaValue
|
|
at.AttrNr = v.AttrNr
|
|
err := dao_workorderattrlst.InsertOne(at)
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
}
|
|
//第三步：计数清零
|
|
pmaInfo.CounterCycleVal = 1
|
|
err = dao_AssetKpi.UpdateOne(&pmaInfo)
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
session.Commit()
|
|
case "D":
|
|
today := utils.TimeFormat(time.Now(), "yyyyMMdd")
|
|
//查询当天是否是工作日,如果是跳过
|
|
engine := db.Eloquent.Master()
|
|
session := engine.NewSession()
|
|
defer session.Close()
|
|
|
|
ok := dao_workcalendarlst.IsWorkDate(today)
|
|
if !ok {
|
|
continue
|
|
}
|
|
//逻辑：起始时间+间隔时间，
|
|
//判断是否已经生成了维护工单，如果生成了，跳过
|
|
tem, err := dao_workorder.SelectLastOne(task.PmService.PlantNr,task.PmService.MainServiceNr,task.PmAsset.AssetNr)
|
|
if err != nil {
|
|
glog.InfoExtln("维护工单D", "err:", err)
|
|
continue
|
|
}
|
|
time2, _ := utils.TimeParse(tem.ActBegTime.ToString())
|
|
time1, _ := utils.TimeParseyyyyMMdd(today)
|
|
timelen := int(time1.Unix()) - int(time2.Unix())
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if timelen >= 0 {
|
|
//逻辑：根据调度时间维护
|
|
workOrderId, err := snrDao.GetNextSnr("WorkOrder")
|
|
log.Printf("流水号id:%v", workOrderId)
|
|
if err != nil {
|
|
return
|
|
}
|
|
//符合逻辑生成维护工单
|
|
pm := new(model.WorkOrder)
|
|
pm.PlantNr = task.PmService.PlantNr
|
|
pm.MaintWorkOrderId = workOrderId
|
|
pm.MainServiceNr = strconv.Itoa(task.PmService.MainServiceNr)
|
|
pm.Descr = task.PmService.Descr
|
|
pm.Status = 26
|
|
pm.Priority = task.PmService.Priority
|
|
pm.AssetNr = task.PmAsset.AssetNr
|
|
pm.PlBegDat = grmi.Date(time.Now())
|
|
pm.SchedBegTime = grmi.DateTime(time.Now())
|
|
timenow := utils.ValueToString(task.PmService.MainTimeLen, "")
|
|
m, _ := time.ParseDuration(timenow + "h")
|
|
pm.SchedEndTime = grmi.DateTime(time.Now().Add(m))
|
|
pm.ActBegTime = pm.SchedBegTime
|
|
pm.ActEndTime = pm.SchedEndTime
|
|
pm.MaintType = task.PmService.MaintType
|
|
err = dao_workorder.InsertOne(pm)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
data, err := dao_serviceattrlst.Select([]grmi.Predicate{meta.ServiceAttrLst_PlantNr.NewPredicate(grmi.Equal, task.PmService.PlantNr), meta.ServiceAttrLst_MainServiceNr.NewPredicate(grmi.Equal, task.PmService.MainServiceNr)}, nil)
|
|
if err != nil {
|
|
_ = session.Rollback()
|
|
continue
|
|
}
|
|
//生成属性
|
|
for _, v := range data {
|
|
at := new(model.WorkOrderAttrLst)
|
|
at.PlantNr = v.PlantNr
|
|
at.Descr = v.Descr
|
|
at.MainServiceNr = v.MainServiceNr
|
|
at.MaintWorkOrderId = workOrderId
|
|
at.Pos = v.Pos
|
|
at.Parameter = v.Parameter
|
|
at.ParaValue = v.ParaValue
|
|
at.AttrNr = v.AttrNr
|
|
err := dao_workorderattrlst.InsertOne(at)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
default:
|
|
//进行非抢占式任务
|
|
}
|
|
}
|
|
}
|
|
}
|