private DmeRuleStepAttribute ReadSingleAttribute(IDictionary <string, Property> atts, SqlSugarClient db, string attributeCode, string desc)
{
DmeRuleStepAttribute att = db.Queryable <DmeRuleStepAttribute>().Single(rsa => rsa.ModelId == step.ModelId && rsa.VersionId == step.VersionId && rsa.RuleStepId == step.Id && rsa.AttributeCode == attributeCode);
if (att != null)
{
atts[attributeCode] = new Property(attributeCode, desc, EnumValueMetaType.TYPE_STRING, att.AttributeValue, "", "", null, 1, 0, 1);
}
else
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"缺失配置项[{attributeCode}]");
}
return(att);
}
private void SaveStepAttribute(SqlSugarClient db, int i, string fieldName, object fieldValue, int isNeedPrecursor)
{
DmeRuleStepAttribute attribute = new DmeRuleStepAttribute
{
ModelId = step.ModelId,
VersionId = step.VersionId,
RuleStepId = step.Id,
RowIndex = i,
IsNeedPrecursor = isNeedPrecursor,
AttributeCode = fieldName,
AttributeValue = fieldValue
};
db.Insertable <DmeRuleStepAttribute>(attribute).ExecuteCommand();
}
/// <summary>
/// 获取算法实体
/// </summary>
/// <returns></returns>
private DmeAlgorithm GetAlgorithmEntity()
{
var db = base.repository.GetDbContext();
DmeRuleStepAttribute dmeRuleStepAttribute = db.Queryable <DmeRuleStepAttribute>().Single(rsa => rsa.RuleStepId == this.step.Id && rsa.AttributeCode == nameof(this.AlgorithmCode));
if (null == dmeRuleStepAttribute)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, "没有找到步骤关联的算法属性值");
}
string algorithmCode = dmeRuleStepAttribute.AttributeValue.ToString();
DmeAlgorithm dmeAlgorithm = db.Queryable <DmeAlgorithm>().Single(alg => alg.SysCode == algorithmCode);
if (null == dmeAlgorithm)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, $"没有找到步骤关联的算法，编码[{algorithmCode}]");
}
return(dmeAlgorithm);
}
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);
}
public Result Run()
{
// 找到算法输入依赖的算法实体
AlgorithmDTO dto = this.ruleStepMeta.GetAlgorithm();
// 找到这个步骤注入的参数值
var db = base.repository.GetDbContext();
List <DmeRuleStepAttribute> stepAttributes = db.Queryable <DmeRuleStepAttribute>().Where(rsa => rsa.RuleStepId == this.step.Id).ToList();
if (0 == stepAttributes?.Count)
{
LOG.Warn("没有找到步骤关联的参数设置，停止执行");
return(new Result(EnumSystemStatusCode.DME_FAIL, "没有找到步骤关联的参数设置，停止执行", null));
}
IDictionary <string, Property> inputParams = dto.AlgorithmInstance.InParams;
// 载入参数值
IDictionary <string, Property> paraValues = new Dictionary <string, Property>();
foreach (var item in stepAttributes)
{
if (!inputParams.ContainsKey(item.AttributeCode))
{
continue;
}
Property inputParaProperty = inputParams[item.AttributeCode];
if (1 == item.IsNeedPrecursor)
{
// 前驱参数
if (null == item.AttributeValue ||
string.IsNullOrEmpty(item.AttributeValue.ToString()) ||
!item.AttributeValue.ToString().Contains(":"))
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"步骤[{step.SysCode}]的参数[{item.AttributeCode}]无效，值[{inputParaProperty.Value}]");
}
string preStepName = item.AttributeValue.ToString().Split(":")[0];
string preAttributeName = item.AttributeValue.ToString().Split(":")[1];
DmeRuleStepAttribute preRuleStepAttribute = db.Queryable <DmeRuleStepAttribute, DmeRuleStep> ((rsa, rs) => new object[] { rs.Id == rsa.RuleStepId })
.Where((rsa, rs) => rs.ModelId == step.ModelId && rs.Name == preStepName && rsa.AttributeCode == preAttributeName)
.Single();
if (null == preRuleStepAttribute)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"步骤[{step.SysCode}]的参数[{item.AttributeCode}]无效，找不到前驱参数信息");
}
paraValues[item.AttributeCode] = base.GetStepAttributeValue(preStepName, preAttributeName);// new Property(item.AttributeCode, item.AttributeCode, EnumValueMetaType.TYPE_UNKNOWN, preRuleStepAttribute.AttributeValue);
}
else
{
if (inputParaProperty.DataType == (int)EnumValueMetaType.TYPE_FEATURECLASS)
{
// 这种类型，要注意解析数据源
JObject featureClassJson = JObject.Parse(item.AttributeValue.ToString());
string featureClassName = featureClassJson.GetValue("name").Value <string>();
string sourceId = featureClassJson.GetValue("source").Value <string>();
// 根据sourceId查找数据源实体
DmeDataSource dataSource = base.repository.GetDbContext().Queryable <DmeDataSource>().Single(ds => ds.SysCode == sourceId);
InputFeatureClassDTO inputFeatureClassDTO = new InputFeatureClassDTO
{
Name = featureClassName,
Source = ClassValueCopier <DataSourceDTO> .Copy(dataSource)
};
paraValues[item.AttributeCode] = new Property(item.AttributeCode, item.AttributeCode, EnumValueMetaType.TYPE_OBJECT, inputFeatureClassDTO);
}
else
{
paraValues[item.AttributeCode] = new Property(item.AttributeCode, item.AttributeCode, EnumValueMetaType.TYPE_UNKNOWN, item.AttributeValue);
}
}
}
dto.AlgorithmInstance.Init(paraValues);
Result result = dto.AlgorithmInstance.Execute();
// 保存输出
if (result != null && EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_SUCCESS).Equals(result.Status))
{
base.SaveOutput(dto.AlgorithmInstance.OutParams);
return(new Result(EnumSystemStatusCode.DME_SUCCESS, "执行完毕", true));
}
return(new Result(EnumSystemStatusCode.DME_FAIL, "执行失败，无异常信息", false));
}
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;
}));
}
public bool SaveAttributes(IDictionary <string, Property> attributes)
{
if (attributes?.Count == 0)
{
LOG.Info("属性个数为 0，不再执行后面的操作。");
return(true);
}
var db = repository.GetDbContext();
if (0 == attributes?.Count)
{
return(false);
}
// 先删除这个步骤的属性，再重新添加
// 删除的影响条目
int deleteCount = db.Deleteable <DmeRuleStepAttribute>().Where(rsa => rsa.RuleStepId == this.step.Id).ExecuteCommand();
LOG.Info($"删除规则[{this.step.Id}]下的{deleteCount} 条属性记录");
// 不使用接口IList，Insertable<>批量插入存在问题
List <DmeRuleStepAttribute> attributeEntities = new List <DmeRuleStepAttribute>();
// 去重
ISet <string> datasources = new HashSet <string>();
foreach (var item in attributes)
{
if (nameof(Source).Equals(item.Value.Name) && !string.IsNullOrEmpty(item.Value.DataSourceCode))
{
// 不需要在实体[DmeRuleStepAttribute]添加数据源
datasources.Add(item.Value.DataSourceCode);
continue;
}
DmeRuleStepAttribute dmeRuleStepAttribute = new DmeRuleStepAttribute
{
RuleStepId = this.step.Id,
ModelId = this.step.ModelId,
VersionId = this.step.VersionId,
AttributeCode = item.Key,
AttributeValue = item.Value.Value,
AttributeType = (int)item.Value.Type
};
if (nameof(EnumValueMetaType.TYPE_FEATURECLASS).Equals(item.Value.DataTypeCode) ||
nameof(EnumValueMetaType.TYPE_MDB_FEATURECLASS).Equals(item.Value.DataTypeCode) ||
nameof(EnumValueMetaType.TYPE_SDE_FEATURECLASS).Equals(item.Value.DataTypeCode))
{
// 要素图层需要处理一下
dmeRuleStepAttribute.AttributeValue = "{\"name\":\"" + item.Value.Value + "\",\"source\":\"" + item.Value.DataSourceCode + "\"}";
}
attributeEntities.Add(dmeRuleStepAttribute);
}
if (attributeEntities.Count > 0)
{
db.Insertable <DmeRuleStepAttribute>(attributeEntities).ExecuteCommand();
}
if (datasources.Count > 0)
{
this.SaveDataSourceAttribute(db, datasources);
}
//Boolean result = db.Ado.UseTran<Boolean>(() =>
//{
// return true;
//}).Data;
return(true);
}
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);
}
