/// <summary>
/// 发送消息
/// </summary>
/// <param name="topic">主题</param>
/// <param name="message"></param>
/// <returns>是否发送成功，true/false</returns>
public static Task <Boolean> Send(string topic, MessageBody message)
{
return(Task.Run(() => {
if (string.IsNullOrWhiteSpace(message.SysCode))
{
message.SysCode = GuidUtil.NewGuid();
}
// 发送之前先持久化
MessageColl messageCollection = new MessageColl
{
SysCode = message.SysCode,
From = message.From,
To = message.To,
ChannelType = (int)message.ChannelType,
MsgType = (int)message.MessageType,
Payload = message.Payload,
SendTime = DateUtil.CurrentTimeMillis,
Delivered = (int)EnumDeliverType.UNDELIVERED,
Read = (int)EnumReadType.UNREAD
};
MongodbHelper <MessageColl> .Add(ServiceFactory.MongoDatabase, messageCollection);
var dr = producer.ProduceAsync(topic, null, JsonConvert.SerializeObject(message));
if (dr.Result.Error.HasError)
{
LOG.Error($" 发送失败，详情[{dr.Result.Error.Reason}]");
return false;
}
messageCollection.Delivered = (int)EnumDeliverType.DELIVERED;
MongodbHelper <MessageColl> .Update(ServiceFactory.MongoDatabase, messageCollection, messageCollection._id);
LOG.Info($"成功发送 '{dr.Result.Value}' to: {dr.Result.TopicPartitionOffset}");
return true;
}));
}
public async Task <object> AddModelTypesAsync(string[] types)
{
if (0 == types?.Length)
{
LOG.Warn("传入的模型类型数据为空");
return(null);
}
List <DmeModelType> modelTypes = new List <DmeModelType>();
foreach (var item in types)
{
DmeModelType modelType = base.Db.Queryable <DmeModelType>().Single(mt => mt.Name == item);
if (modelType != null)
{
continue;
}
modelType = new DmeModelType
{
Name = item,
SysCode = GuidUtil.NewGuid(),
CreateTime = DateUtil.CurrentTimeMillis,
LastTime = DateUtil.CurrentTimeMillis
};
modelType = await base.Db.Insertable <DmeModelType>(modelType).ExecuteReturnEntityAsync();
modelTypes.Add(modelType);
}
return(modelTypes);
}
public Result UploadModelImg(string modelVersionCode, [FromForm] IFormFile file)
{
if (file?.Length > 0)
{
string suffix = file.FileName.Substring(file.FileName.LastIndexOf("."));
string localFileName = GuidUtil.NewGuid() + suffix;
GridFSUploadOptions options = new GridFSUploadOptions
{
Metadata = new BsonDocument(new Dictionary <string, object>()
{
["ContentType"] = file.ContentType
})
};
ObjectId objectId = MongodbHelper <object> .UploadFileFromStream(ServiceFactory.MongoDatabase, localFileName, file.OpenReadStream(), options);
try
{
return(base.Success(base.modelService.AddModelImg(modelVersionCode, file.FileName, suffix, file.ContentType, objectId.ToString())));
}
catch (Exception ex)
{
LOG.Error(ex, "模型图片数据库持久化失败，详情：" + ex.Message);
if (objectId != null)
{
LOG.Warn($"文件[{objectId}]撤销保存");
MongodbHelper <object> .DeleteFileById(ServiceFactory.MongoDatabase, objectId);
}
}
}
return(base.Fail("上传失败，没有获取到图片数据"));
}
public object AddDataSource(DatasourceAddDTO datasourceAddDTO)
{
DmeDataSource dataSource = ClassValueCopier <DmeDataSource> .Copy(datasourceAddDTO);
dataSource.CreateTime = DateUtil.CurrentTimeMillis;
dataSource.SysCode = GuidUtil.NewGuid();
return(base.Repository.GetDbContext().Insertable <DmeDataSource>(dataSource).ExecuteReturnEntity());
}
/// <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 AddModelVersion(ModelVersionSimpleAddDTO dto)
{
DmeModelVersion dmeModelVersion = new DmeModelVersion
{
SysCode = GuidUtil.NewGuid(),
ModelId = dto.ModelId,
Name = dto.Name,
CreateTime = DateUtil.CurrentTimeMillis,
Status = 1
};
return(base.Db.Insertable <DmeModelVersion>(dmeModelVersion).ExecuteReturnEntity());
}
public void TestNewGuid()
{
//SortedSet<string> guids = new SortedSet<string>();
DateTime begin = DateTime.Now;
for (var index = 0; index < 100000; index++)
{
string newguid = GuidUtil.NewGuid();
// Assert.IsFalse(guids.Contains(newguid));
// guids.Add(newguid);
}
Assert.IsTrue((DateTime.Now - begin).TotalSeconds < 1.0);
}
public object AddModel(ModelAddReqDTO dto)
{
if (string.IsNullOrEmpty(dto.SysCode))
{
// 自动赋予一个唯一编码
dto.SysCode = GuidUtil.NewGuid();
}
// 使用事务
DbResult <ModelRegisterRespDTO> dbResult = base.Db.Ado.UseTran <ModelRegisterRespDTO>(() =>
{
// 查询单条没有数据返回NULL, Single超过1条会报错，First不会
// base.DmeModelDb.GetContext().Queryable<DmeModel>().Single(m => m.SysCode == dto.SysCode);
DmeModel model = base.Db.Queryable <DmeModel>().Where(m => m.SysCode == dto.SysCode).Single();
if (null == model)
{
model = new DmeModel
{
SysCode = dto.SysCode,
Name = dto.Name,
Remark = dto.Remark,
CreateTime = DateUtil.CurrentTimeMillis,
IsPublish = 1,
PublishTime = DateUtil.CurrentTimeMillis,
Status = 1
};
// 模型类型
DmeModelType modelType = base.Db.Queryable <DmeModelType>().Single(mt => mt.SysCode == dto.TypeCode);
if (modelType != null)
{
model.ModelTypeId = modelType.Id;
model.ModelTypeCode = modelType.SysCode;
}
model = base.Db.Insertable <DmeModel>(model).ExecuteReturnEntity();
if (null == model)
{
throw new Exception(String.Format("创建模型失败，原因未明，编码：[{0}]，名称：[{1}]。", dto.SysCode, dto.Name));
}
}
else
{
LOG.Info($"模型[{dto.SysCode}]已存在，作为新增版本信息");
}
ModelRegisterRespDTO respDTO = ClassValueCopier <ModelRegisterRespDTO> .Copy(model);
// 处理版本
respDTO.VersionCodes = this.HandleVersions(base.Db, model, dto);
return(respDTO);
});
return(dbResult.Data);
}
/// <summary>
/// 通过微信接口获取关注场景和场景对应的Url;
/// </summary>
/// <returns></returns>
private SceneAndMarkurl InternalGetMarkUrl(int index, int totalCount)
{
string guid = scenePrefix + GuidUtil.NewGuid();
/* return new SceneAndMarkurl { Url = "http://www.max-media.cc", Scene = guid, ExpiredDateTime = DateTime.Now.AddDays(30) };
*/
DateTime expire = DateTime.Now.AddDays(30);
var markImageUrl = app.GetQrCodeUrl(guid, 2591999); //二维码有效日期 30天
var markUrl = QrcodeUtil.Scan(markImageUrl);
log?.Invoke(string.Format("获取公众号:{4} 扫码场景:{2}/{3}, 场景:{0},Url:{1}", guid, markUrl, index, totalCount, app.Config.Name));
return(new SceneAndMarkurl {
Url = markUrl, Scene = guid, ExpiredDateTime = expire
});
}
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 object AddDmeFileSystemSource(string name, IList <DmeFileSystemMeta> metas)
{
DmeDataSource dmeDataSource = new DmeDataSource
{
SysCode = GuidUtil.NewGuid(),
Name = name,
Type = nameof(EnumDataSourceType.DME_FILESYSTEM),
CreateTime = DateUtil.CurrentTimeMillis,
Remark = "dme文件系统来源"
};
if (metas?.Count > 0)
{
dmeDataSource.Connection = JsonConvert.SerializeObject(metas);
}
base.Db.Insertable <DmeDataSource>(dmeDataSource).ExecuteCommandIdentityIntoEntity();
return(dmeDataSource);
}
/// <summary>
/// 构造函数，设置 Guid 为一个新的Guid；
/// </summary>
public IdAndGuidEntity() : base()
{
Guid = GuidUtil.NewGuid(); // System.Guid.NewGuid().ToString().Replace("-", "");
}
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;
}));
}
public override Result Execute()
{
if (!base.InitComplete)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL_INIT, "初始化工作未完成");
}
DMEWorkspaceBridge <IWorkspace, IFeatureClass> dmeWorkspaceBridge = new DMEWorkspaceBridge <IWorkspace, IFeatureClass>();
dmeWorkspaceBridge.SetWorkspace(new EsriWorkspace());
// 目前先以ORACLE和MDB为数据源类型
// 获取source feature class
this.SourceFeatureClass = dmeWorkspaceBridge.GetFeatureClass(this.sourceFeatureClassDTO);
// 获取target feature class
this.TargetFeatureClass = dmeWorkspaceBridge.GetFeatureClass(this.targetFeatureClassDTO);
if (AnalysisType.COVER == this.AnalysisType)
{
OverlayCommonTool.GetTopounionGeometryByQuery(this.SourceFeatureClass, null, null, esriSpatialRelEnum.esriSpatialRelUndefined,
out IGeometry sourceGeom, out IList <string> oidList);
//找出touch的要素oid，排除掉touch的图形
OverlayCommonTool.GetTopounionGeometryByQuery(this.TargetFeatureClass, null, sourceGeom, esriSpatialRelEnum.esriSpatialRelTouches, out IGeometry touchGeom, out IList <string> touchOIDList);
//通过intersect查找压盖部分的要素
string queryClause = null;
if (touchOIDList != null && touchOIDList.Count > 0)
{
queryClause = $"OBJECTID NOT in ({string.Join(",", ((List<string>)touchOIDList).ToArray())})";
}
// 求取空间相交的部分
OverlayCommonTool.GetIntersectFeaturesByQuery(this.TargetFeatureClass, queryClause, sourceGeom,
out IList <IntersectFeatureDTO> intersectFeatureDTOs, out double sumIntersectArea);
if (intersectFeatureDTOs?.Count > 0)
{
OverlayRespDTO overlayRespDTO = new OverlayRespDTO
{
SumArea = sumIntersectArea
};
foreach (var item in intersectFeatureDTOs)
{
FeatureRespDTO intersectFeatureRespDTO = new FeatureRespDTO
{
OID = item.OID,
Area = item.Area,
Coordinates = item.Coordinates,
GeoType = item.GeoType
};
overlayRespDTO.Features.Add(intersectFeatureRespDTO);
}
Property resultProp = base.OutputParametersMeta[nameof(Result)];
resultProp.Value = overlayRespDTO;
return(new Result(EnumSystemStatusCode.DME_SUCCESS, "运行完成", EnumSystemStatusCode.DME_SUCCESS, null));
}
}
else if (AnalysisType.OVERTOP == this.AnalysisType)
{
// 先拷贝一份mdb模板
string sTemplate = System.AppDomain.CurrentDomain.BaseDirectory + GlobalSystemConfig.PATH_TEMPLATE_PGDB;// @"\template\pgdb.mdb";
string sPath = System.AppDomain.CurrentDomain.BaseDirectory + GlobalSystemConfig.DIR_TEMP + "/" + GuidUtil.NewGuid() + ".mdb";
File.Copy(sTemplate, sPath);
IWorkspace mdbWorkspace = WorkspaceUtil.OpenMdbWorspace(sPath);
if (FeatureClassUtil.ExportToWorkspace(this.SourceFeatureClass, mdbWorkspace))
{
// 获取导出的临时要素类信息
IFeatureClass tempExpFeatureClass = WorkspaceUtil.GetFeatureClass(mdbWorkspace, this.sourceFeatureClassDTO.Name);
// 进行擦除操作
OverlayCommonTool.Erase(tempExpFeatureClass, this.TargetFeatureClass);
// 计算完保存结果，如何保存？
if (tempExpFeatureClass != null)
{
OverlayRespDTO overlayRespDTO = new OverlayRespDTO();
// 总面积
double sumArea = 0;
IFeatureCursor pFeatureCursor = tempExpFeatureClass.Search(null, false);
IFeature pFeature = null;
//获得“Area”字段
//IFields fields = pFeatureCursor.Fields;
//int areaIndex = fields.FindField("Area");
while ((pFeature = pFeatureCursor.NextFeature()) != null)
{
double area = ((IArea)pFeature.Shape).Area;// (double)pFeature.get_Value(areaIndex);
sumArea += area;
FeatureRespDTO featureRespDTO = new FeatureRespDTO
{
OID = pFeature.OID,
Area = area,
Coordinates = GeometryUtil.ConvertGeometryToJson(pFeature.Shape, out string msg)
};
overlayRespDTO.Features.Add(featureRespDTO);
pFeature = pFeatureCursor.NextFeature();
}
overlayRespDTO.SumArea = sumArea;
Property resultProp = base.OutputParametersMeta[nameof(Result)];
resultProp.Value = overlayRespDTO;
return(new Result(EnumSystemStatusCode.DME_SUCCESS, "运行完成", EnumSystemStatusCode.DME_SUCCESS, null));
}
}
// 删除临时文件
if (IsClearTemp && File.Exists(sPath))
{
File.Delete(sPath);
}
}
else
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, "分析类型不匹配");
}
return(new Result(EnumSystemStatusCode.DME_SUCCESS, "运行完成，但没有运算结果", EnumSystemStatusCode.DME_SUCCESS, null));
}
/// <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 async Task <DmeTask> CreateTaskAsync(NewTaskReqDTO dto)
{
// 验证数据库是否存在指定模型版本信息
SqlSugarClient db = base.Repository.GetDbContext();
// 查询模型版本
DmeModelVersion modelVersion = db.Queryable <DmeModelVersion>().Single(mv => mv.SysCode == dto.ModelVersionCode);
if (null == modelVersion)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"模型的版本[{dto.ModelVersionCode}]不存在");
}
// Single方法，如果查询数据库多条数据，会抛出异常
DmeModel model = db.Queryable <DmeModel>().Single(m => m.Id == modelVersion.ModelId);
if (null == model)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"模型[{modelVersion.ModelId}]不存在");
}
// 获取模型类型
DmeModelType modelType = db.Queryable <DmeModelType>().InSingle(model.ModelTypeId);
// 查找关联的算法信息
IList <DmeRuleStep> ruleSteps = db.Queryable <DmeRuleStep>().Where(rs => rs.ModelId == model.Id && rs.VersionId == modelVersion.Id).ToList();
if (0 == ruleSteps?.Count)
{
LOG.Warn($"模型[{model.SysCode}]的版本[{dto.ModelVersionCode}]下没有可执行步骤，停止运行");
return(null);
}
DmeTask newTask = db.Ado.UseTran <DmeTask>(() =>
{
// 每执行一次模型，生成一次任务
newTask = new DmeTask
{
SysCode = GuidUtil.NewGuid(),
CreateTime = DateUtil.CurrentTimeMillis,
Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_WAITTING),
ModelId = model.Id,
VersionId = modelVersion.Id,
Remark = dto.Remark,
NodeServer = NetAssist.GetLocalHost()
};
if (string.IsNullOrWhiteSpace(dto.Name))
{
newTask.Name = "task-" + newTask.CreateTime;
}
else
{
newTask.Name = dto.Name;
}
newTask.LastTime = newTask.CreateTime;
newTask = db.Insertable <DmeTask>(newTask).ExecuteReturnEntity();
return(newTask);
}).Data;
// 创建job
await DmeQuartzScheduler <TaskRunnerJob> .NewJob(
newTask.SysCode,
modelType.SysCode,
dto.CronExpression,
new Dictionary <string, object> {
{ TaskRunnerJob.TASK_CODE_KEY, newTask.SysCode }
},
1 == dto.StartNow,
DateTimeOffset.Now.AddSeconds(dto.InSeconds),
dto.Remark);
return(newTask);
}
