/// <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 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);
}
/// <summary>
/// 运行步骤节点
/// </summary>
/// <param name="db"></param>
/// <param name="task"></param>
/// <param name="node"></param>
private void RunRuleStepNode(SqlSugarClient db, DmeTask task, RuleStepLinkedListNode <DmeRuleStep> node)
{
// 先计算前置节点
if (node.Previous?.Count > 0)
{
foreach (var item in node.Previous)
{
RunRuleStepNode(db, task, item);
}
}
DmeTaskRuleStep dmeTaskRuleStep = null;
try
{
// 先判断任务的状态，是否被停止
DmeTask taskStatus = db.Queryable <DmeTask>().Single(t => t.SysCode == task.SysCode);
if (null == taskStatus || taskStatus.Status.Equals(EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_STOP)))
{
LOG.Info($"任务[{task.SysCode}]不存在或者已被停止");
return;
}
dmeTaskRuleStep = this.GetTaskRuleStep(db, task, node.Value, out string cacheKey);
if (dmeTaskRuleStep != null && EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_SUCCESS).Equals(dmeTaskRuleStep.Status))
{
// 释放
dmeTaskRuleStep = null;
LOG.Info($"任务[{task.SysCode}]下的步骤[{node.Value.SysCode}]已被计算过，并且状态为[success]");
return;
}
// 如果前置节点没有了，则计算当前节点内容
DmeRuleStepType ruleStepTypeTemp = db.Queryable <DmeRuleStepType>().Single(rst => rst.Id == node.Value.StepTypeId);
IRuleStepData ruleStepData = RuleStepFactory.GetRuleStepData(ruleStepTypeTemp.Code, this.Repository, task, node.Value);
if (null == ruleStepData)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"步骤工厂无法创建编码为[{ruleStepTypeTemp.Code}]的流程实例节点");
}
dmeTaskRuleStep = new DmeTaskRuleStep
{
SysCode = GuidUtil.NewGuid(),
TaskId = task.Id,
RuleStepId = node.Value.Id,
Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_RUNNING),
CreateTime = DateUtil.CurrentTimeMillis,
LastTime = DateUtil.CurrentTimeMillis
};
dmeTaskRuleStep = db.Insertable <DmeTaskRuleStep>(dmeTaskRuleStep).ExecuteReturnEntity();
// 任务步骤创建成功后，把相关信息记录在缓存中
ServiceFactory.CacheService.AddAsync(cacheKey, dmeTaskRuleStep, 60);
Result stepResult = ruleStepData.Run();
UpdateRuleStep(db, dmeTaskRuleStep, cacheKey, stepResult);
// 然后计算下一个步骤
if (node?.Next.Count > 0)
{
foreach (var item in node.Next)
{
RunRuleStepNode(db, task, item);
}
}
}
catch (Exception ex)
{
dmeTaskRuleStep.Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_ERROR);
dmeTaskRuleStep.LastTime = DateUtil.CurrentTimeMillis;
// 只更新状态和最后时间
db.Updateable <DmeTaskRuleStep>(dmeTaskRuleStep).UpdateColumns(ts => new { ts.Status, ts.LastTime }).ExecuteCommand();
this.LogService.AddLogAsync(Base.Common.Log.EnumLogType.ENTITY, EnumLogLevel.ERROR, nameof(DmeTaskRuleStep), dmeTaskRuleStep.SysCode, "", ex, "", NetAssist.GetLocalHost());
}
}
public Property GetStepAttributeValue(string otherStepName, string attributeCode)
{
//
var db = repository.GetDbContext();
DmeRuleStep otherStep = db.Queryable <DmeRuleStep>().Single(rs => rs.ModelId == step.ModelId && rs.VersionId == step.VersionId && rs.Name == otherStepName);
if (null == otherStep)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, $"步骤[{otherStepName}]在模型[{step.ModelId}]版本[{step.VersionId}]下不存在");
}
DmeRuleStepType otherStepType = db.Queryable <DmeRuleStepType>().Single(rst => rst.Id == otherStep.StepTypeId);
if (null == otherStepType)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, $"步骤类型id[{otherStep.StepTypeId}]不存在");
}
IRuleStepData ruleStepData = RuleStepFactory.GetRuleStepData(otherStepType.Name, repository, this.task, otherStep);
IDictionary <string, Property> inputParameters = ruleStepData.RuleStepMeta.InParams;
IDictionary <string, Property> outputParameters = ruleStepData.RuleStepMeta.OutParams;
Property property = null;
if (inputParameters.ContainsKey(attributeCode))
{
// 从步骤属性表查找
property = inputParameters[attributeCode];
DmeRuleStepAttribute dmeRuleStepAttribute = db.Queryable <DmeRuleStepAttribute>().Single(rsa => rsa.RuleStepId == otherStep.Id && rsa.RowIndex == 0 && rsa.AttributeCode == attributeCode);
property.Value = dmeRuleStepAttribute.AttributeValue;
}
else if (outputParameters.ContainsKey(attributeCode))
{
// 从步骤结果表查找
property = outputParameters[attributeCode];
DmeTaskResult dmeTaskResult = db.Queryable <DmeTaskResult>().Single(tr => tr.TaskId == this.taskId && tr.RuleStepId == otherStep.Id && tr.ResultCode == attributeCode);
EnumValueMetaType @enum = EnumUtil.GetEnumObjByName <EnumValueMetaType>(property.DataTypeCode);
switch (@enum)
{
case EnumValueMetaType.TYPE_UNKNOWN:
case EnumValueMetaType.TYPE_NUMBER:
case EnumValueMetaType.TYPE_STRING:
case EnumValueMetaType.TYPE_INTEGER:
case EnumValueMetaType.TYPE_BIGNUMBER:
case EnumValueMetaType.TYPE_TIMESTAMP:
case EnumValueMetaType.TYPE_INET:
case EnumValueMetaType.TYPE_LOCAL_FILE:
case EnumValueMetaType.TYPE_GDB_PATH:
case EnumValueMetaType.TYPE_FOLDER:
property.Value = dmeTaskResult.ResultValue;
break;
case EnumValueMetaType.TYPE_DATE:
// 要求格式：yyyy-MM-dd hh:mm:ss
property.Value = Convert.ToDateTime(dmeTaskResult.ResultValue?.ToString());
break;
case EnumValueMetaType.TYPE_BOOLEAN:
property.Value = Boolean.Parse(dmeTaskResult.ResultValue?.ToString());
break;
case EnumValueMetaType.TYPE_SERIALIZABLE:
break;
case EnumValueMetaType.TYPE_BINARY:
break;
case EnumValueMetaType.TYPE_MDB_FEATURECLASS:
break;
case EnumValueMetaType.TYPE_STRING_LIST:
property.Value = dmeTaskResult.ResultValue?.ToString().Split(";");
break;
case EnumValueMetaType.TYPE_SDE_FEATURECLASS:
break;
case EnumValueMetaType.TYPE_FEATURECLASS:
break;
case EnumValueMetaType.TYPE_JSON:
// 从mongo中获取
var filter = Builders <TaskResultColl> .Filter.And(
Builders <TaskResultColl> .Filter.Eq("TaskCode", this.task.SysCode),
Builders <TaskResultColl> .Filter.Eq("RuleStepCode", otherStep.SysCode),
Builders <TaskResultColl> .Filter.Eq("Code", attributeCode));
IList <TaskResultColl> colls = MongodbHelper <TaskResultColl> .FindList(ServiceFactory.MongoDatabase, filter);
if (colls != null && colls.Count > 0)
{
property.Value = colls[0].Value;
}
break;
default:
break;
}
}
else
{
LOG.Error($"属性编码[{attributeCode}]无效");
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, $"属性编码[{attributeCode}]无效");
}
return(property);
}
