/// <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) { }