public object AddModelImg(string modelVersionCode, string sourceName, string suffix, string contentType, string objectId)
{
var db = Repository.GetDbContext();
DmeModelVersion modelVersion = db.Queryable <DmeModelVersion>().Single(mv => mv.SysCode == modelVersionCode);
if (null == modelVersion)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, $"模型版本[{modelVersionCode}]不存在");
}
DmeModelImg modelImg = db.Queryable <DmeModelImg>().Single(mi => mi.ModelId == modelVersion.ModelId && mi.VersionId == modelVersion.Id);
if (null == modelImg)
{
modelImg = new DmeModelImg
{
ModelId = modelVersion.ModelId,
VersionId = modelVersion.Id,
Suffix = suffix,
SourceName = sourceName,
ContentType = contentType,
ImgCode = objectId
};
modelImg = db.Insertable <DmeModelImg>(modelImg).ExecuteReturnEntity();
}
else
{
modelImg.ImgCode = objectId;
modelImg.Suffix = suffix;
modelImg.ContentType = contentType;
modelImg.SourceName = sourceName;
db.Updateable <DmeModelImg>(modelImg).ExecuteCommand();
}
return(modelImg);
}
/// <summary>
/// 处理版本信息
/// </summary>
/// <param name="db"></param>
/// <param name="model"></param>
/// <param name="dto"></param>
/// <returns>返回版本编码数组</returns>
private IList <string> HandleVersions(SqlSugarClient db, DmeModel model, ModelAddReqDTO dto)
{
IList <ModelVersionAddDTO> versions = dto.Versions;
if (versions?.Count == 0)
{
throw new BusinessException("注册模型时，缺失版本信息。");
}
IList <string> versionCodes = new List <string>();
foreach (var subVersion in versions)
{
DmeModelVersion mv = new DmeModelVersion
{
SysCode = GuidUtil.NewGuid(),
Name = subVersion.Name,
ModelId = model.Id,
CreateTime = DateUtil.CurrentTimeMillis
};
mv = db.Insertable <DmeModelVersion>(mv).ExecuteReturnEntity();
versionCodes.Add(mv.SysCode);
// 添加步骤信息
IList <RuleStepAddDTO> stepsAdd = subVersion.Steps;
if (stepsAdd?.Count == 0)
{
continue;
}
// 步骤名称与步骤实体的映射
IDictionary <string, DmeRuleStep> ruleStepMap = new Dictionary <string, DmeRuleStep>();
foreach (var subStepAdd in stepsAdd)
{
RuleStepTypeDTO ruleStepTypeDTO = subStepAdd.StepType;
if (null == ruleStepTypeDTO)
{
throw new BusinessException("注册模型，缺失步骤类型元数据。");
}
DmeRuleStepType dmeRuleStepType = db.Queryable <DmeRuleStepType>().Single(rst => rst.Code == ruleStepTypeDTO.Code);
DmeRuleStep step = new DmeRuleStep
{
SysCode = GuidUtil.NewGuid(),
ModelId = model.Id,
VersionId = mv.Id,
X = subStepAdd.X,
Y = subStepAdd.Y,
Name = subStepAdd.Name,
Remark = subStepAdd.Remark,
StepTypeId = dmeRuleStepType.Id
};
step = db.Insertable <DmeRuleStep>(step).ExecuteReturnEntity();
ruleStepMap[subStepAdd.Name] = step;
// 处理步骤属性
this.HandleAttributes(db, model, mv, subStepAdd, step);
}
// 处理步骤之间的连接关系
this.HandleHop(db, subVersion, model, mv, ruleStepMap);
}
return(versionCodes);
}
public DmeModelImg GetModelImg(string modelVersionCode)
{
var db = Repository.GetDbContext();
DmeModelVersion modelVersion = db.Queryable <DmeModelVersion>().Single(mv => mv.SysCode == modelVersionCode);
if (null == modelVersion)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, $"模型版本[{modelVersionCode}]不存在");
}
return(db.Queryable <DmeModelImg>().Single(mi => mi.ModelId == modelVersion.ModelId && mi.VersionId == modelVersion.Id));
}
private Task RunTaskAsyncEx(SqlSugarClient db, DmeModel model, DmeModelVersion modelVersion, DmeTask task, IList <DmeRuleStep> ruleSteps)
{
return(Task.Run(() =>
{
return db.Ado.UseTran <DmeTask>(() =>
{
try
{
// 查询步骤前后依赖关系
// 形成链表
IList <DmeRuleStepHop> hops = db.Queryable <DmeRuleStepHop>().Where(rsh => rsh.ModelId == model.Id && rsh.VersionId == modelVersion.Id).OrderBy("STEP_FROM_ID").ToList();
IList <RuleStepLinkedListNode <DmeRuleStep> > rulestepLinkedList = this.GetRuleStepNodeLinkedList(db, model, modelVersion, ruleSteps);
foreach (var item in rulestepLinkedList)
{
// 开始计算步骤
this.RunRuleStepNode(db, task, item);
}
// 完成模型计算
task.Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_SUCCESS);
task.LastTime = DateUtil.CurrentTimeMillis;
db.Updateable <DmeTask>(task).ExecuteCommand();
// @TODO 发送模型计算成功的消息
KafkaProducer.Send(nameof(EnumMessageType.TASK), new MessageBody()
{
// 创建者一致
From = "123",
To = "123",
ChannelType = EnumChannelType.P2P,
MessageType = EnumMessageType.TASK,
Payload = $"模型[{task.SysCode}]计算完成，状态[{task.Status}]"
});
return task;
}
catch (Exception ex)
{
// 更改任务执行的状态
if (ex is BusinessException)
{
task.Status = EnumUtil.GetEnumDisplayName(EnumUtil.GetEnumObjByValue <EnumSystemStatusCode>(((BusinessException)ex).Code));
}
else
{
task.Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_ERROR);
}
task.LastTime = DateUtil.CurrentTimeMillis;
db.Updateable <DmeTask>(task).ExecuteCommand();
// 添加日志
this.LogService.AddLogAsync(Base.Common.Log.EnumLogType.ENTITY, Base.Common.Log.EnumLogLevel.ERROR, nameof(DmeTask), task.SysCode, "", ex, "", NetAssist.GetLocalHost());
throw ex;
}
});
}));
}
public object AddModelVersion(ModelVersionSimpleAddDTO dto)
{
DmeModelVersion dmeModelVersion = new DmeModelVersion
{
SysCode = GuidUtil.NewGuid(),
ModelId = dto.ModelId,
Name = dto.Name,
CreateTime = DateUtil.CurrentTimeMillis,
Status = 1
};
return(base.Db.Insertable <DmeModelVersion>(dmeModelVersion).ExecuteReturnEntity());
}
public object CopyFromModelVersion(string modelVersionCode)
{
// 开始事务
return(base.Repository.GetDbContext().Ado.UseTran <DmeModelVersion>(() =>
{
// 根据模型版本号，获取模型版本信息
DmeModelVersion modelVersion = base.Repository.GetDbContext().Queryable <DmeModelVersion>().Single(mv => mv.SysCode == modelVersionCode);
DmeModelVersion newVersion = new DmeModelVersion
{
CreateTime = DateUtil.CurrentTimeMillis,
ModelId = modelVersion.ModelId
};
newVersion.Name = $"版本-{newVersion.CreateTime}";
newVersion.SysCode = GuidUtil.NewGuid();
newVersion.Id = base.Repository.GetDbContext().Insertable <DmeModelVersion>(newVersion).ExecuteReturnIdentity();
// 获取被复制的版本的步骤信息
IList <DmeRuleStep> oldRuleSteps = base.Repository.GetDbContext().Queryable <DmeRuleStep>().Where(rs => rs.ModelId == modelVersion.ModelId && rs.VersionId == modelVersion.Id).ToList();
if (oldRuleSteps?.Count > 0)
{
foreach (var step in oldRuleSteps)
{
DmeRuleStep newRuleStep = ClassValueCopier <DmeRuleStep> .Copy(step, new String[] { "Id", "SysCode", "VersionId" });
newRuleStep.SysCode = GuidUtil.NewGuid();
newRuleStep.VersionId = newVersion.Id;
newRuleStep.Id = base.Repository.GetDbContext().Insertable <DmeRuleStep>(newRuleStep).ExecuteReturnIdentity();
// 获取步骤的属性信息
IList <DmeRuleStepAttribute> oldRuleStepAttributes = base.Repository.GetDbContext().Queryable <DmeRuleStepAttribute>().Where(rsa => rsa.ModelId == modelVersion.ModelId && rsa.VersionId == modelVersion.Id).ToList();
if (oldRuleStepAttributes?.Count > 0)
{
List <DmeRuleStepAttribute> newRuleStepAtts = new List <DmeRuleStepAttribute>();
foreach (var att in oldRuleStepAttributes)
{
DmeRuleStepAttribute newRuleStepAtt = ClassValueCopier <DmeRuleStepAttribute> .Copy(att, new String[] { "Id", "RuleStepId", "VersionId" });
newRuleStepAtt.RuleStepId = newRuleStep.Id;
newRuleStepAtt.VersionId = newVersion.Id;
newRuleStepAtts.Add(newRuleStepAtt);
}
base.Repository.GetDbContext().Insertable <DmeRuleStepAttribute>(newRuleStepAtts.ToArray()).ExecuteCommand();
}
}
}
return newVersion;
}).Data);
}
/// <summary>
/// 处理步骤属性信息
/// </summary>
/// <param name="db"></param>
/// <param name="model"></param>
/// <param name="version"></param>
/// <param name="subStepAdd"></param>
/// <param name="step"></param>
private void HandleAttributes(SqlSugarClient db, DmeModel model, DmeModelVersion version, RuleStepAddDTO subStepAdd, DmeRuleStep step)
{
IList <AttributeReqDTO> properties = subStepAdd.Attributes;
if (properties?.Count == 0)
{
LOG.Warn("没有可处理的步骤属性信息");
return;
}
if (Register.RuleStepPluginsMap.ContainsKey(subStepAdd.StepType.Code))
{
RuleStepPluginRegisterDTO ruleStepPluginRegisterDTO = Register.RuleStepPluginsMap[subStepAdd.StepType.Code];
String baseDir = AppDomain.CurrentDomain.BaseDirectory;
string assemblyPath = Path.Combine(baseDir, ruleStepPluginRegisterDTO.Assembly);
Assembly assembly = Assembly.LoadFile(assemblyPath);
IRuleStepData ruleStepData = (IRuleStepData)assembly.CreateInstance(ruleStepPluginRegisterDTO.ClassId, true, BindingFlags.CreateInstance, null
, new object[] { Repository, null, step }, null, null);
if (null == ruleStepData)
{
LOG.Warn($"无法创建步骤实体[{ruleStepPluginRegisterDTO.ClassId}]");
return;
}
IDictionary <string, Property> attributes = new Dictionary <string, Property>();
// DmeRuleStepAttribute dmeRuleStepAttribute = null;
foreach (var p in properties)
{
EnumValueMetaType enumValueMetaType = new EnumValueMetaType();
if (string.IsNullOrEmpty(p.DataTypeCode))
{
enumValueMetaType = EnumValueMetaType.TYPE_UNKNOWN;
}
else
{
enumValueMetaType = EnumUtil.GetEnumObjByName <EnumValueMetaType>(p.DataTypeCode);
}
attributes[p.Name] = new Property(p.Name, p.Name, enumValueMetaType, p.Value,
null, null, null, 1, 0, 1, p.DataSourceCode, p.IsNeedPrecursor, p.Type);
}
ruleStepData.SaveAttributes(attributes);
}
}
public object GetRuntimeAttributes(string modelVersionCode)
{
DmeModelVersion dmeModelVersion = base.Db.Queryable <DmeModelVersion>().Single(mv => mv.SysCode == modelVersionCode);
if (null == dmeModelVersion)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"模型版本[{modelVersionCode}]不存在");
}
// 查找模型版本下步骤信息
List <DmeRuleStep> steps = base.Db.Queryable <DmeRuleStep>().Where(rs => rs.ModelId == dmeModelVersion.ModelId && rs.VersionId == dmeModelVersion.Id).ToList();
if (0 == steps?.Count)
{
LOG.Warn($"模型版本[{modelVersionCode}]下没有找到步骤信息");
return(null);
}
IList <AttributeRuntimeRespDTO> ruleStepRuntimeAttributes = new List <AttributeRuntimeRespDTO>();
IList <AttributeRuntimeDTO> runtimeAttriRespDTOs = null;
foreach (var step in steps)
{
LOG.Info($"模型版本[{modelVersionCode}]，步骤编码[{step.SysCode}]，步骤名称[{step.Name}]");
// 查找运行时参数
List <DmeRuleStepAttribute> runtimeAtts = base.Db.Queryable <DmeRuleStepAttribute>().Where(rsa => rsa.RuleStepId == step.Id && rsa.AttributeType == (int)EnumAttributeType.RUNTIME).ToList();
if (0 == runtimeAtts?.Count)
{
LOG.Warn($"步骤[{step.Name}]下没有设置属性");
continue;
}
// 查找步骤类型
DmeRuleStepType ruleStepType = base.Db.Queryable <DmeRuleStepType>().InSingle(step.StepTypeId);
if (null == ruleStepType)
{
LOG.Warn($"步骤类型id[{step.StepTypeId}]不存在");
continue;
}
IRuleStepData ruleStepData = RuleStepFactory.GetRuleStepData(ruleStepType.Code, base.Repository, null, step);
IDictionary <string, Property> inParams = ruleStepData.RuleStepMeta.InParams;
if (null == inParams)
{
LOG.Warn($"步骤编码[{step.SysCode}]，步骤名称[{step.Name}]，获取不到步骤元数据的输入参数");
continue;
}
runtimeAttriRespDTOs = new List <AttributeRuntimeDTO>();
foreach (var item in runtimeAtts)
{
if (inParams.ContainsKey(item.AttributeCode))
{
Property property = inParams[item.AttributeCode];
runtimeAttriRespDTOs.Add(new AttributeRuntimeDTO()
{
ModelId = step.ModelId,
VersionId = step.VersionId,
RuleStepId = step.Id,
Name = item.AttributeCode,
Alias = property.Alias,
DataTypeCode = property.DataTypeCode,
DataTypeDesc = property.DataTypeDesc
});
}
}
if (0 == runtimeAttriRespDTOs.Count)
{
continue;
}
ruleStepRuntimeAttributes.Add(new AttributeRuntimeRespDTO()
{
RuleStep = new RuleStepRespDTO()
{
SysCode = step.SysCode,
Name = step.Name,
Remark = step.Remark,
ModelId = step.ModelId,
VersionId = step.VersionId
},
RuntimeAtts = runtimeAttriRespDTOs
});
}
return(ruleStepRuntimeAttributes);
}
public object SaveRuleStepInfos(ModelRuleStepInfoDTO info)
{
var db = base.Repository.GetDbContext();
// 开始事务
return(db.Ado.UseTran <object>(() =>
{
// 根据模型版本号，获取模型版本信息
DmeModelVersion modelVersion = base.Repository.GetDbContext().Queryable <DmeModelVersion>().Single(mv => mv.SysCode == info.ModelVersionCode);
// 清除模型的步骤信息
db.Deleteable <DmeRuleStep>(rs => rs.ModelId == modelVersion.ModelId && rs.VersionId == modelVersion.Id).ExecuteCommand();
// 清除步骤属性信息
db.Deleteable <DmeRuleStepAttribute>(rsa => rsa.ModelId == modelVersion.ModelId && rsa.VersionId == modelVersion.Id).ExecuteCommand();
// 根据key建立起关系
if (info.RuleSteps?.Count > 0)
{
// 客户端传过来的key和业务id映射关系
IDictionary <string, int> key2BizId = new Dictionary <string, int>();
foreach (var step in info.RuleSteps)
{
DmeRuleStep stepEntity = new DmeRuleStep
{
SysCode = GuidUtil.NewGuid(),
ModelId = modelVersion.ModelId,
VersionId = modelVersion.Id
};
stepEntity.Id = db.Insertable <DmeRuleStep>(stepEntity).ExecuteReturnIdentity();
key2BizId[step.Key] = stepEntity.Id;
// 处理步骤属性
if (step.Attributes?.Count > 0)
{
IRuleStepData ruleStepData = RuleStepFactory.GetRuleStepData(step.TypeCode, base.Repository, null, stepEntity);
ruleStepData.SaveAttributes(step.Attributes);
//IList<DmeRuleStepAttribute> attributeEntities = new List<DmeRuleStepAttribute>();
//foreach (var att in step.Attributes)
//{
// attributeEntities.Add(new DmeRuleStepAttribute
// {
// RuleStepId = stepEntity.Id,
// ModelId = stepEntity.ModelId,
// VersionId = stepEntity.VersionId,
// AttributeCode = att.Key,
// AttributeValue = att.Value
// });
//}
//db.Insertable<DmeRuleStepAttribute>(attributeEntities).ExecuteCommand();
}
}
// 处理步骤的向量关系
if (info.Vectors?.Count > 0)
{
IList <DmeRuleStepHop> ruleStepHops = new List <DmeRuleStepHop>();
foreach (var vector in info.Vectors)
{
// 只要向量的信息不完整，都不需要保存连接信息
if (!key2BizId.ContainsKey(vector.StepFromName) || !key2BizId.ContainsKey(vector.StepToName))
{
continue;
}
ruleStepHops.Add(new DmeRuleStepHop
{
ModelId = modelVersion.ModelId,
VersionId = modelVersion.Id,
StepFromId = key2BizId[vector.StepFromName],
StepToId = key2BizId[vector.StepToName],
Enabled = vector.Enabled
});
}
db.Insertable <DmeRuleStepHop>(ruleStepHops).ExecuteCommandAsync();
}
}
return true;
}).Data);
}
public object CopyModelVersion(string versionCode)
{
DmeModelVersion modelVersion = base.Repository.GetDbContext().Queryable <DmeModelVersion>().Where(mv => mv.SysCode == versionCode).Single();
if (null == modelVersion)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, $"模型版本[{versionCode}]不存在，或模型版本编码无效");
}
var db = base.Repository.GetDbContext();
return(db.Ado.UseTran <DmeModelVersion>(() =>
{
// 复制为新版本
DmeModelVersion newVersion = new DmeModelVersion
{
SysCode = GuidUtil.NewGuid(),
ModelId = modelVersion.ModelId,
CreateTime = DateUtil.CurrentTimeMillis
};
newVersion.Name = $"版本-{DateUtil.CurrentTimeMillis}";
newVersion = db.Insertable <DmeModelVersion>(newVersion).ExecuteReturnEntity();
// 复制步骤信息
IList <DmeRuleStep> steps = db.Queryable <DmeRuleStep>().Where(rs => rs.ModelId == modelVersion.ModelId && rs.VersionId == modelVersion.Id).ToList();
if (steps?.Count > 0)
{
// List<DmeRuleStep> copiedSteps = new List<DmeRuleStep>();
DmeRuleStep newTempStep = null;
DmeRuleStepAttribute newTempStepAttr = null;
foreach (var subStep in steps)
{
newTempStep = ClassValueCopier <DmeRuleStep> .Copy(subStep, new String[] { "Id", "SysCode", "VersionId" });
newTempStep.SysCode = GuidUtil.NewGuid();
newTempStep.VersionId = newVersion.Id;
newTempStep = db.Insertable <DmeRuleStep>(newTempStep).ExecuteReturnEntity();
// copiedSteps.Add(copiedTempStep);
// 复制步骤的参数属性信息
IList <DmeRuleStepAttribute> oldAttributes = db.Queryable <DmeRuleStepAttribute>().Where(rsa => rsa.RuleStepId == subStep.Id && rsa.VersionId == modelVersion.Id).ToList();
if (oldAttributes?.Count > 0)
{
List <DmeRuleStepAttribute> newStepAttrs = new List <DmeRuleStepAttribute>();
foreach (var subAttr in oldAttributes)
{
newTempStepAttr = ClassValueCopier <DmeRuleStepAttribute> .Copy(subAttr,
new string[] { "Id", "RuleStepId", "VersionId" });
newTempStepAttr.RuleStepId = newTempStep.Id;
newTempStepAttr.VersionId = newVersion.Id;
newStepAttrs.Add(newTempStepAttr);
}
int insertCount = db.Insertable <DmeRuleStepAttribute>(newStepAttrs).ExecuteCommand();
LOG.Info($"成功复制[{insertCount}]个步骤[{subStep.Id}]的参数信息");
}
// 复制步骤关联的数据源引用信息
IList <DmeRuleStepDataSource> rsDataSources = db.Queryable <DmeRuleStepDataSource>().
Where(rsds => rsds.RuleStepId == subStep.Id && rsds.ModelId == modelVersion.ModelId && rsds.VersionId == modelVersion.Id).ToList();
if (rsDataSources?.Count > 0)
{
List <DmeRuleStepDataSource> newRuleStepDataSources = new List <DmeRuleStepDataSource>();
foreach (var subDs in rsDataSources)
{
newRuleStepDataSources.Add(new DmeRuleStepDataSource()
{
RuleStepId = newTempStep.Id,
ModelId = subDs.ModelId,
VersionId = newVersion.Id,
DataSourceId = subDs.DataSourceId
});
}
db.Insertable <DmeRuleStepDataSource>(newRuleStepDataSources).ExecuteCommand();
}
}
}
return newVersion;
}));
}
/// <summary>
/// 处理步骤连线信息
/// </summary>
/// <param name="db"></param>
/// <param name="versionDTO"></param>
/// <param name="model"></param>
/// <param name="version"></param>
/// <param name="ruleStepMap"></param>
private void HandleHop(SqlSugarClient db, ModelVersionAddDTO versionDTO, DmeModel model, DmeModelVersion version, IDictionary <string, DmeRuleStep> ruleStepMap)
{
IList <RuleStepHopDTO> ruleStepHopDTOs = versionDTO.Hops;
if (ruleStepHopDTOs?.Count == 0)
{
return;
}
List <DmeRuleStepHop> hops = new List <DmeRuleStepHop>();
foreach (var hopDTO in ruleStepHopDTOs)
{
DmeRuleStepHop hop = new DmeRuleStepHop
{
ModelId = model.Id,
VersionId = version.Id,
StepFromId = ruleStepMap[hopDTO.StepFromName].Id,
StepToId = ruleStepMap[hopDTO.StepToName].Id,
Enabled = hopDTO.Enabled,
Name = hopDTO.Name
};
hops.Add(hop);
}
db.Insertable <DmeRuleStepHop>(hops).ExecuteCommand();
}
public async Task RunTaskScheduleAsync(string taskCode)
{
var db = Repository.GetDbContext();
DmeTask task = db.Queryable <DmeTask>().Single(t => t.SysCode == taskCode);
if (null == task)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, $"任务[{taskCode}]不存在");
}
// 查询模型版本
DmeModelVersion modelVersion = db.Queryable <DmeModelVersion>().InSingle(task.VersionId);//.Single(mv => mv.SysCode == dto.ModelVersionCode);
if (null == modelVersion)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"模型的版本[{task.VersionId}]不存在");
}
// Single方法，如果查询数据库多条数据，会抛出异常
DmeModel model = db.Queryable <DmeModel>().InSingle(task.ModelId);
if (null == model)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"模型[{task.ModelId}]不存在");
}
// 查找关联的算法信息
IList <DmeRuleStep> ruleSteps = db.Queryable <DmeRuleStep>().Where(rs => rs.ModelId == model.Id && rs.VersionId == modelVersion.Id).ToList();
if (0 == ruleSteps?.Count)
{
LOG.Warn($"模型[{model.SysCode}]的版本[{modelVersion.SysCode}]下没有可执行步骤，停止运行");
return;
}
try
{
// 清理掉任务之前的过程结果
// 包括DME_TASK_RESULT、DME_TASK_RULESTEP和mongo TaskResultColl
db.Ado.UseTran(() => {
int count = db.Deleteable <DmeTaskRuleStep>().Where(trs => trs.TaskId == task.Id).ExecuteCommand();
LOG.Info($"删除任务关联的步骤记录[{count}]条");
db.Deleteable <DmeTaskResult>().Where(tr => tr.TaskId == task.Id).ExecuteCommand();
LOG.Info($"删除任务结果记录[{count}]条");
var filter = Builders <TaskResultColl> .Filter.And(
Builders <TaskResultColl> .Filter.Eq("TaskCode", task.SysCode));
DeleteResult deleteResult = MongodbHelper <TaskResultColl> .DeleteMany(ServiceFactory.MongoDatabase, filter);
LOG.Info($"删除mongo记录[{deleteResult.DeletedCount}]条");
LOG.Info($"清理缓存计算数据");
IList <string> cacheKeys = new List <string>();
foreach (var item in ruleSteps)
{
cacheKeys.Add(HashUtil.Hash_2_MD5_32($"{task.SysCode}_{item.SysCode}"));
}
ServiceFactory.CacheService.RemoveAllAsync(cacheKeys);
// 修改任务状态为running
task.Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_RUNNING);
db.Updateable <DmeTask>(task).UpdateColumns(t => t.Status).ExecuteCommand();
});
// 此时不阻塞，返回类型为Task，为了能捕获到线程异常信息
await RunTaskAsyncEx(db, model, modelVersion, task, ruleSteps);
}
catch (Exception ex)
{
LOG.Error(ex, ex.Message);
// 更改任务状态
task.Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_ERROR);
task.LastTime = DateUtil.CurrentTimeMillis;
db.Updateable <DmeTask>(task).UpdateColumns(t => new { task.Status, task.LastTime }).ExecuteCommand();
}
}
/// <summary>
/// 构建步骤的链表信息
/// </summary>
/// <param name="db"></param>
/// <param name="ruleSteps"></param>
/// <returns>多个链表</returns>
private IList <RuleStepLinkedListNode <DmeRuleStep> > GetRuleStepNodeLinkedList(SqlSugarClient db, DmeModel model, DmeModelVersion modelVersion, IList <DmeRuleStep> ruleSteps)
{
IList <RuleStepLinkedListNode <DmeRuleStep> > newLinkedSteps = new List <RuleStepLinkedListNode <DmeRuleStep> >();
// 一次性构建步骤实体字典
IDictionary <int, RuleStepLinkedListNode <DmeRuleStep> > ruleStepDic = new Dictionary <int, RuleStepLinkedListNode <DmeRuleStep> >();
foreach (var subStep in ruleSteps)
{
ruleStepDic[subStep.Id] = new RuleStepLinkedListNode <DmeRuleStep>(subStep);
newLinkedSteps.Add(ruleStepDic[subStep.Id]);
}
//IList<RuleStepLinkedListNode<DmeRuleStep>> multiLinkedList = new List<RuleStepLinkedListNode<DmeRuleStep>>();
IList <DmeRuleStepHop> hops = db.Queryable <DmeRuleStepHop>().Where(rsh => rsh.ModelId == model.Id && rsh.VersionId == modelVersion.Id).OrderBy(rsh => rsh.StepFromId).ToList();
if (0 == hops?.Count)
{
return(newLinkedSteps);
}
IDictionary <int, RuleStepLinkedListNode <DmeRuleStep> > newRuleStepLinkedNodeDic = new Dictionary <int, RuleStepLinkedListNode <DmeRuleStep> >();
// 已经使用的步骤id集合
IList <int> usedStepIds = new List <int>();
RuleStepLinkedListNode <DmeRuleStep> linkedStepFromNode = null;
RuleStepLinkedListNode <DmeRuleStep> linkedStepToNode = null;
// 反过来构建？
foreach (var hop in hops)
{
if (!ruleStepDic.ContainsKey(hop.StepFromId) || !ruleStepDic.ContainsKey(hop.StepToId) || 0 == hop.Enabled)
{
continue;
}
linkedStepFromNode = ruleStepDic[hop.StepFromId];
linkedStepToNode = ruleStepDic[hop.StepToId];
linkedStepFromNode.Next.Add(linkedStepToNode);
linkedStepToNode.Previous.Add(linkedStepFromNode);
}
return(newLinkedSteps);
}
public async Task <DmeTask> CreateTaskAsync(NewTaskReqDTO dto)
{
// 验证数据库是否存在指定模型版本信息
SqlSugarClient db = base.Repository.GetDbContext();
// 查询模型版本
DmeModelVersion modelVersion = db.Queryable <DmeModelVersion>().Single(mv => mv.SysCode == dto.ModelVersionCode);
if (null == modelVersion)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"模型的版本[{dto.ModelVersionCode}]不存在");
}
// Single方法，如果查询数据库多条数据，会抛出异常
DmeModel model = db.Queryable <DmeModel>().Single(m => m.Id == modelVersion.ModelId);
if (null == model)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"模型[{modelVersion.ModelId}]不存在");
}
// 获取模型类型
DmeModelType modelType = db.Queryable <DmeModelType>().InSingle(model.ModelTypeId);
// 查找关联的算法信息
IList <DmeRuleStep> ruleSteps = db.Queryable <DmeRuleStep>().Where(rs => rs.ModelId == model.Id && rs.VersionId == modelVersion.Id).ToList();
if (0 == ruleSteps?.Count)
{
LOG.Warn($"模型[{model.SysCode}]的版本[{dto.ModelVersionCode}]下没有可执行步骤，停止运行");
return(null);
}
DmeTask newTask = db.Ado.UseTran <DmeTask>(() =>
{
// 每执行一次模型，生成一次任务
newTask = new DmeTask
{
SysCode = GuidUtil.NewGuid(),
CreateTime = DateUtil.CurrentTimeMillis,
Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_WAITTING),
ModelId = model.Id,
VersionId = modelVersion.Id,
Remark = dto.Remark,
NodeServer = NetAssist.GetLocalHost()
};
if (string.IsNullOrWhiteSpace(dto.Name))
{
newTask.Name = "task-" + newTask.CreateTime;
}
else
{
newTask.Name = dto.Name;
}
newTask.LastTime = newTask.CreateTime;
newTask = db.Insertable <DmeTask>(newTask).ExecuteReturnEntity();
return(newTask);
}).Data;
// 创建job
await DmeQuartzScheduler <TaskRunnerJob> .NewJob(
newTask.SysCode,
modelType.SysCode,
dto.CronExpression,
new Dictionary <string, object> {
{ TaskRunnerJob.TASK_CODE_KEY, newTask.SysCode }
},
1 == dto.StartNow,
DateTimeOffset.Now.AddSeconds(dto.InSeconds),
dto.Remark);
return(newTask);
}
