/// <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 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>
/// 从缓存或者db中获取任务步骤信息
/// </summary>
/// <param name="db"></param>
/// <param name="task"></param>
/// <param name="ruleStep"></param>
/// <param name="cacheKey"></param>
/// <returns></returns>
private DmeTaskRuleStep GetTaskRuleStep(SqlSugarClient db, DmeTask task, DmeRuleStep ruleStep, out string cacheKey)
{
// 先从缓存查找
cacheKey = HashUtil.Hash_2_MD5_32($"{task.SysCode}_{ruleStep.SysCode}");
DmeTaskRuleStep dmeTaskRuleStep = null;
try
{
dmeTaskRuleStep = ServiceFactory.CacheService.Get <DmeTaskRuleStep>(cacheKey);
if (dmeTaskRuleStep != null)
{
LOG.Info($"缓存中获取到任务步骤信息，任务id[{dmeTaskRuleStep.TaskId}]，步骤id[{dmeTaskRuleStep.RuleStepId}]");
return(dmeTaskRuleStep);
}
}
catch (Exception ex)
{
LOG.Warn("从缓存中获取任务步骤信息失败，详情：" + ex.Message);
}
// 从数据库中查找
dmeTaskRuleStep = db.Queryable <DmeTaskRuleStep>().Single(tr => tr.TaskId == task.Id && tr.RuleStepId == ruleStep.Id);
return(dmeTaskRuleStep);
}
/// <summary>
/// 内部方法，获取模型元数据
/// </summary>
/// <param name="model"></param>
/// <param name="detail"></param>
/// <returns></returns>
private ModelDTO GetModelMetadata(DmeModel model, Boolean detail)
{
ModelDTO modelDTO = ClassValueCopier <ModelDTO> .Copy(model);
if (!detail)
{
return(modelDTO);
}
var db = base.Repository.GetDbContext();
// 获取模型版本
IList <DmeModelVersion> versions = db.Queryable <DmeModelVersion>().Where(mv => mv.ModelId == model.Id).ToList();
if (null == versions || 0 == versions.Count)
{
return(modelDTO);
}
foreach (var v in versions)
{
ModelVersionDTO versionDTO = ClassValueCopier <ModelVersionDTO> .Copy(v);
modelDTO.Versions.Add(versionDTO);
IList <DmeRuleStep> ruleStepEntities = db.Queryable <DmeRuleStep>().Where(rs => rs.ModelId == model.Id && rs.VersionId == v.Id).ToList();
if (null == ruleStepEntities || 0 == ruleStepEntities.Count)
{
continue;
}
RuleStepDTO ruleStepDTO = null;
foreach (var ruleStep in ruleStepEntities)
{
ruleStepDTO = ClassValueCopier <RuleStepDTO> .Copy(ruleStep);
versionDTO.Steps.Add(ruleStepDTO);
// 获取步骤类型实体
ruleStepDTO.StepType = db.Queryable <DmeRuleStepType>().Where(rst => rst.Id == ruleStep.StepTypeId).Single();
IRuleStepData ruleStepData = RuleStepFactory.GetRuleStepData(ruleStepDTO.StepType.Code, base.Repository, null, ruleStep);
IDictionary <string, Property> attributeDic = ruleStepData.RuleStepMeta.ReadAttributes();
if (attributeDic?.Count > 0)
{
foreach (var item in attributeDic.Values)
{
ruleStepDTO.Attributes.Add(item);
}
}
// 检索步骤的属性值信息
//IList<DmeRuleStepAttribute> attributes = db.Queryable<DmeRuleStepAttribute>().Where(rsa => rsa.RuleStepId == ruleStep.Id).ToList();
//if (null == attributes || 0 == attributes.Count)
//{
// continue;
//}
//foreach (var att in attributes)
//{
// ruleStepDTO.Attributes.Add(new KeyValuePair<string, object>(att.AttributeCode, att.AttributeValue));
//}
}
// 每个模型版本下的数据源（多表关联查询）
// 当不需要用LEFT JOIN或者 RIGHT JOIN 只是单纯的INNER JOIN时我们还提供了更简单的语法实现多表查询
IList <DmeDataSource> datasources = db.Queryable <DmeDataSource, DmeRuleStepDataSource>((ds, rsds) => ds.Id == rsds.DataSourceId).Select(ds =>
new DmeDataSource {
SysCode = ds.SysCode, Connection = ds.Connection, CreateTime = ds.CreateTime, Id = ds.Id, Name = ds.Name, Remark = ds.Remark, Type = ds.Type
}).ToList();
if (datasources?.Count > 0)
{
foreach (var datasourceItem in datasources)
{
if (versionDTO.DataSources.ContainsKey(datasourceItem.SysCode))
{
continue;
}
versionDTO.DataSources[datasourceItem.SysCode] = datasourceItem;
}
}
// 每个模型版本下的节点向量信息
IList <DmeRuleStepHop> hops = db.Queryable <DmeRuleStepHop>()
.Where(rsh => rsh.ModelId == model.Id && rsh.VersionId == v.Id)
.OrderBy(rsh => rsh.StepFromId)
.ToList();
if (hops?.Count > 0)
{
DmeRuleStep stepFromTemp = null;
DmeRuleStep stepToTemp = null;
foreach (var item in hops)
{
stepFromTemp = db.Queryable <DmeRuleStep>().InSingle(item.StepFromId);
stepToTemp = db.Queryable <DmeRuleStep>().InSingle(item.StepToId);
if (null == stepFromTemp || null == stepToTemp)
{
LOG.Warn($"开始步骤[{item.StepFromId}]，或者结束步骤[{item.StepToId}]找不到对应实体信息");
continue;
}
versionDTO.Hops.Add(new RuleStepHopDTO(stepFromTemp.Name, stepToTemp.Name, item.Enabled, item.Name));
}
}
}
return(modelDTO);
}
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="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 MongoDBOutputStepData(IRepository repository, DmeTask task, DmeRuleStep step) :
base(repository, task, step)
{
ruleStepMeta = new MongoDBOutputStepMeta(repository, step);
}
/// <summary>
/// 真正在运行的时候，step才会被使用到
/// </summary>
/// <param name="repository"></param>
/// <param name="step"></param>
public BaseRuleStepMeta(IRepository repository, DmeRuleStep step)
{
this.repository = repository;
this.step = step;
}
/// <summary>
/// 获取规则步骤数据操作类
/// </summary>
/// <param name="stepTypeCode">步骤类型唯一编码</param>
/// <param name="repository"></param>
/// <param name="taskId"></param>
/// <param name="step"></param>
/// <returns></returns>
public static IRuleStepData GetRuleStepData(string stepTypeCode, IRepository repository, DmeTask task, DmeRuleStep step)
{
if (!Register.RuleStepPluginsMap.ContainsKey(stepTypeCode))
{
LOG.Warn($"没有找到步骤类型为[{stepTypeCode}]的插件信息");
return(null);
}
RuleStepPluginRegisterDTO ruleStepPluginRegisterDTO = Register.RuleStepPluginsMap[stepTypeCode];
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, task, step }, null, null);
return(ruleStepData);
}
public object GetTaskResult(string taskCode, int ruleStepId)
{
SqlSugarClient db = base.Repository.GetDbContext();
DmeTask task = db.Queryable <DmeTask>().Single(t => t.SysCode == taskCode);
if (null == task)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, $"任务不存在[{taskCode}]");
}
// 查询任务的结果输出
IList <DmeTaskResult> taskResults = null;
if (-1 == ruleStepId)
{
// 全部步骤
taskResults = db.Queryable <DmeTaskResult>().Where(tr => tr.TaskId == task.Id).ToList();
}
else
{
// 指定步骤
taskResults = db.Queryable <DmeTaskResult>().Where(tr => tr.TaskId == task.Id && tr.RuleStepId == ruleStepId).ToList();
}
if (null == taskResults || 0 == taskResults.Count)
{
return(null);
}
IList <TaskResultRespDTO> taskResultRespDTOs = new List <TaskResultRespDTO>();
TaskResultRespDTO temp = null;
foreach (var item in taskResults)
{
temp = new TaskResultRespDTO
{
RuleStepId = item.RuleStepId,
Code = item.ResultCode,
Type = item.ResultType
};
// 解析步骤类型
DmeRuleStep ruleStep = db.Queryable <DmeRuleStep>().Single(rs => rs.Id == item.RuleStepId);
// Value = item.ResultValue
EnumValueMetaType @enum = EnumUtil.GetEnumObjByName <EnumValueMetaType>(temp.Type);
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:
temp.Value = item.ResultValue;
break;
case EnumValueMetaType.TYPE_DATE:
// 要求格式：yyyy-MM-dd hh:mm:ss
temp.Value = Convert.ToDateTime(item.ResultValue?.ToString());
break;
case EnumValueMetaType.TYPE_BOOLEAN:
temp.Value = Boolean.Parse(item.ResultValue?.ToString());
break;
case EnumValueMetaType.TYPE_SERIALIZABLE:
break;
case EnumValueMetaType.TYPE_BINARY:
break;
case EnumValueMetaType.TYPE_MDB_FEATURECLASS:
break;
case EnumValueMetaType.TYPE_STRING_LIST:
temp.Value = item.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("TaskId", item.TaskId),
Builders <TaskResultColl> .Filter.Eq("RuleStepId", item.RuleStepId),
Builders <TaskResultColl> .Filter.Eq("Code", item.ResultCode));
IList <TaskResultColl> colls = MongodbHelper <TaskResultColl> .FindList(ServiceFactory.MongoDatabase, filter);
if (colls != null && colls.Count > 0)
{
temp.Value = colls[0].Value;
}
break;
default:
break;
}
taskResultRespDTOs.Add(temp);
}
return(taskResultRespDTOs);
}
//protected int modelId;
//protected int versionId;
//protected int ruleStepId;
/// <summary>
/// 真正运行的时候，taskId和step才被使用到
/// </summary>
/// <param name="repository"></param>
/// <param name="taskId"></param>
/// <param name="step"></param>
//public BaseRuleStepData(IRepository repository, int taskId, DmeRuleStep step)
//{
// this.repository = repository;
// this.taskId = taskId;
// this.step = step;
// //this.modelId = modelId;
// //this.versionId = versionId;
// //this.ruleStepId = ruleStepId;
//}
public BaseRuleStepData(IRepository repository, DmeTask task, DmeRuleStep step)
{
this.repository = repository;
this.task = task;
this.step = step;
}
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);
}
public AlgorithmInputStepMeta(IRepository repository, DmeRuleStep step)
: base(repository, step)
{
}
public MongoDBOutputStepMeta(IRepository repository, DmeRuleStep step)
: base(repository, step)
{
}
public DataSourceInputStepData(IRepository repository, DmeTask task, DmeRuleStep step) :
base(repository, task, step)
{
ruleStepMeta = new DataSourceInputStepMeta(repository, step);
}
public AlgorithmInputStepData(IRepository repository, DmeTask task, DmeRuleStep step)
: base(repository, task, step)
{
ruleStepMeta = new AlgorithmInputStepMeta(repository, step);
}
public DataSourceInputStepMeta(IRepository repository, DmeRuleStep step)
: base(repository, step)
{
}
