public AlgorithmRespDTO GetAlgorithmByCode(String code, bool hasMeta)
{
// single，如果找不到实体，则抛出异常
DmeAlgorithm alg = base.Repository.GetDbContext().Queryable <DmeAlgorithm>().Single(a => a.SysCode == code);
AlgorithmRespDTO algorithmDTO = ClassValueCopier <AlgorithmRespDTO> .Copy(alg);
IList <DmeAlgorithmMeta> metas = base.Repository.GetDbContext().Queryable <DmeAlgorithmMeta>().Where(meta => meta.AlgorithmId == alg.Id).ToList();
if (metas?.Count > 0)
{
foreach (var item in metas)
{
EnumValueMetaType enumValueMetaType = EnumUtil.GetEnumObjByName <EnumValueMetaType>(item.DataType);
algorithmDTO.Metas.Add(new AlgorithmMetaDTO()
{
Name = item.Name,
DataType = (int)enumValueMetaType,
DataTypeCode = item.DataType,
DataTypeDesc = EnumUtil.GetEnumDescription(enumValueMetaType),
Inout = item.Inout,
AlgorithmId = item.AlgorithmId,
IsVisible = item.IsVisible,
Remark = item.Remark,
Alias = item.Alias,
ReadOnly = item.ReadOnly,
Required = item.Required
});
}
}
return(algorithmDTO);
}
public object ListAlgorithms(bool needMeta)
{
var db = base.Repository.GetDbContext();
List <DmeAlgorithm> algs = db.Queryable <DmeAlgorithm>().OrderBy(alg => alg.CreateTime, OrderByType.Desc).ToList();
if (null == algs || 0 == algs.Count)
{
return(algs);
}
if (needMeta)
{
IList <AlgorithmRespDTO> algDTOs = new List <AlgorithmRespDTO>();
AlgorithmRespDTO algorithmDTO = null;
IList <DmeAlgorithmMeta> metas = null;
IList <AlgorithmMetaDTO> metasDTO = null;
foreach (var alg in algs)
{
algorithmDTO = ClassValueCopier <AlgorithmRespDTO> .Copy(alg);
if (alg.Extension != null && !string.IsNullOrEmpty(alg.Extension.ToString()))
{
algorithmDTO.Extension = alg.Extension;// JsonConvert.DeserializeObject(.ToString());
}
algDTOs.Add(algorithmDTO);
metas = db.Queryable <DmeAlgorithmMeta>().Where(meta => meta.AlgorithmId == alg.Id).ToList();
if (null == metas || 0 == metas.Count)
{
continue;
}
metasDTO = new List <AlgorithmMetaDTO>();
foreach (var item in metas)
{
EnumValueMetaType enumValueMetaType = EnumUtil.GetEnumObjByName <EnumValueMetaType>(item.DataType);
metasDTO.Add(new AlgorithmMetaDTO()
{
Name = item.Name,
DataType = (int)enumValueMetaType,
DataTypeCode = item.DataType,
DataTypeDesc = EnumUtil.GetEnumDescription(enumValueMetaType),
Inout = item.Inout,
AlgorithmId = item.AlgorithmId,
IsVisible = item.IsVisible,
Remark = item.Remark,
Alias = item.Alias,
ReadOnly = item.ReadOnly,
Required = item.Required
});
}
algorithmDTO.Metas = metasDTO;
}
return(algDTOs);
}
return(algs);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="name">名称</param>
/// <param name="alias">别名</param>
/// <param name="dataType">数据类型</param>
/// <param name="value">值</param>
/// <param name="defaultValue">默认值</param>
/// <param name="remark">备注</param>
/// <param name="valueSet">值的可选集</param>
/// <param name="isVisible">是否可见</param>
/// <param name="readOnly">是否只读</param>
/// <param name="dataSourceCode">数据源编码</param>
/// <param name="isNeedPrecursor">是否需要前驱依赖，0和1</param>
/// <param name="attributeType">属性类别，枚举：EnumAttributeType：一般属性和运行时属性</param>
public Property(string name, string alias, EnumValueMetaType dataType, object value = null,
object defaultValue = null, string remark = "", object[] valueSet = null, int isVisible = 1, int readOnly = 0,
int required = 1, string dataSourceCode = "", int isNeedPrecursor = 0, EnumAttributeType attributeType = EnumAttributeType.NORMAL)
{
this.Name = name;
this.Alias = alias;
this.DataType = (int)dataType;
this.DataTypeDesc = EnumUtil.GetEnumDescription(dataType);
this.DataTypeCode = EnumUtil.GetEnumName <EnumValueMetaType>(this.DataType);
this.Value = value;
this.DefaultValue = defaultValue;
this.ValueSet = valueSet;
this.IsVisible = isVisible;
this.Remark = remark;
this.ReadOnly = readOnly;
this.Required = required;
this.DataSourceCode = dataSourceCode;
this.IsNeedPrecursor = isNeedPrecursor;
this.Type = attributeType;
}
/// <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 AddAlgorithm(AlgorithmAddReqDTO dto)
{
DbResult <AlgorithmRespDTO> result = base.Repository.GetDbContext().Ado.UseTran <AlgorithmRespDTO>(() =>
{
DmeAlgorithm alg = base.Repository.GetDbContext().Queryable <DmeAlgorithm>().Where(a => a.SysCode == dto.SysCode).First();
if (null == alg)
{
alg = ClassValueCopier <DmeAlgorithm> .Copy(dto);
alg.CreateTime = DateUtil.CurrentTimeMillis;
alg.Extension = JsonConvert.SerializeObject(dto.Extension);
alg.Id = base.Repository.GetDbContext().Insertable <DmeAlgorithm>(alg).ExecuteReturnIdentity();
}
else
{
// 进行更新操作
alg.Name = dto.Name;
alg.Alias = dto.Alias;
alg.Version = dto.Version;
alg.Remark = dto.Remark;
alg.Type = dto.Type;
alg.Extension = JsonConvert.SerializeObject(dto.Extension);
if (!base.Repository.GetDbContext().Updateable <DmeAlgorithm>().ExecuteCommandHasChange())
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, "更新算法信息失败，无详情信息。");
}
if (dto.Metas != null && dto.Metas.Count > 0)
{
// 删除算法的输入输出参数这些元数据信息，必须ExecuteCommand，否则无效
base.Repository.GetDbContext().Deleteable <DmeAlgorithmMeta>().Where(am => am.AlgorithmId == alg.Id).ExecuteCommand();
}
}
// 重新注册算法参数元数据
AlgorithmRespDTO algorithmRespDTO = ClassValueCopier <AlgorithmRespDTO> .Copy(alg);
if (dto.Metas != null && dto.Metas.Count > 0)
{
algorithmRespDTO.Metas = new List <AlgorithmMetaDTO>();
DmeAlgorithmMeta meta = null;
foreach (var item in dto.Metas)
{
meta = ClassValueCopier <DmeAlgorithmMeta> .Copy(item);
meta.AlgorithmId = alg.Id;
meta.Id = base.Repository.GetDbContext().Insertable <DmeAlgorithmMeta>(meta).ExecuteReturnIdentity();
EnumValueMetaType enumValueMetaType = EnumUtil.GetEnumObjByName <EnumValueMetaType>(item.DataType);
algorithmRespDTO.Metas.Add(new AlgorithmMetaDTO()
{
Name = item.Name,
DataType = (int)enumValueMetaType,
DataTypeCode = item.DataType,
DataTypeDesc = EnumUtil.GetEnumDescription(enumValueMetaType),
Inout = item.Inout,
AlgorithmId = alg.Id,
IsVisible = item.IsVisible,
Remark = item.Remark,
Alias = item.Alias,
ReadOnly = item.ReadOnly,
Required = item.Required
});
}
}
return(algorithmRespDTO);
});
return(result.Data);
}
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);
}
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);
}
