/// <summary>
/// 获取服务器的编辑信息
/// </summary>
/// <param name="servicerID">服务器ID</param>
/// <returns>服务器的编辑信息</returns>
public Task <OperateResult <ServicerModel> > GetServicerModelAsync(int servicerID)
{
return(OperateUtil.ExecuteAsync(async() =>
{
return await _servcerRepository.GetDtoAsync <ServicerModel>(m => m.FID == servicerID && m.FIsDeleted == false, ignoreFields: new string[] { "OperateUserID" });
}, callMemberName: "ServicerApplication-GetServicerModelAsync"));
}
/// <summary>
/// 分页获取服务器列表
/// </summary>
/// <param name="queryWhere">查询条件</param>
/// <returns>服务器列表</returns>
public Task <OperateResult <IPageResult <ServicerListDto> > > GetServiceListAsync(ServicePageQueryWhere queryWhere)
{
return(OperateUtil.ExecuteAsync(() =>
{
return _servcerRepository.GetServiceListAsync(queryWhere);
}, callMemberName: "ServicerApplication-GetServiceListAsync"));
}
/// <summary>
/// 加载全部的数据库信息
/// </summary>
/// <returns></returns>
public Task <OperateResult <IEnumerable <DatabaseListDto> > > LoadDbListAsync()
{
return(OperateUtil.ExecuteAsync(async() =>
{
return await _databaseCache.GetDatabaseListAsync();
}, callMemberName: "DatabaseApplication-LoadDbListAsync"));
}
/// <summary>
/// 获取邮件发送记录
/// </summary>
/// <param name="queryWhere">查询条件</param>
/// <returns></returns>
public Task <OperateResult <IPageResult <EmailSendRecordListDto> > > GetEmailSendRecordListAsync(EmailSendRecordPageQueryWhere queryWhere)
{
return(OperateUtil.ExecuteAsync(() =>
{
return _emailSendedRecordRepository.GetEmailSendRecordListAsync(queryWhere);
}, callMemberName: "EmailSendedRecordApplication-GetEmailSendRecordListAsync"));
}
/// <summary>
/// 分页获取数据库列表
/// </summary>
/// <param name="queryWhere">查询条件</param>
/// <returns>数据库列表</returns>
public Task <OperateResult <IPageResult <DatabaseListDto> > > GetDbListAsync(DatabasePageQueryWhere queryWhere)
{
return(OperateUtil.ExecuteAsync(() =>
{
return _databaseRepository.GetDbListAsync(queryWhere);
}, callMemberName: "DatabaseApplication-GetDbListAsync"));
}
/// <summary>
/// 同步服务器信息
/// </summary>
/// <returns>操作结果</returns>
public Task <OperateResult> SynchroServiceAsync()
{
return(OperateUtil.ExecuteAsync(async() =>
{
await _servicerCache.SynchroServiceAsync();
}, callMemberName: "ServicerApplication-SynchroConfigAsync"));
}
/// <summary>
/// 分页获取项目列表
/// </summary>
/// <param name="queryWhere">查询条件</param>
/// <returns>项目列表</returns>
public Task <OperateResult <IPageResult <ProjectListDto> > > GetProjectListAsync(ProjectPageQueryWhere queryWhere)
{
return(OperateUtil.ExecuteAsync(() =>
{
return _projectRepository.GetProjectListAsync(queryWhere);
}, callMemberName: "ProjectApplication-GetProjectListAsync"));
}
/// <summary>
/// 同步项目信息
/// </summary>
/// <returns>操作结果</returns>
public Task <OperateResult> SynchroProjectAsync()
{
return(OperateUtil.ExecuteAsync(async() =>
{
await _projectCache.SynchroProjectAsync();
}, callMemberName: "ProjectApplication-SynchroConfigAsync"));
}
/// <summary>
/// 获取数据库信息
/// </summary>
/// <param name="dbID">数据库ID</param>
/// <returns>数据库信息</returns>
public Task <OperateResult <DatabaseModel> > GetDatabaseModelAsync(int dbID)
{
return(OperateUtil.ExecuteAsync(async() =>
{
return await _databaseRepository.GetDtoAsync <DatabaseModel>(m => m.FID == dbID && m.FIsDeleted == false, ignoreFields: OperaterUserID);
}, callMemberName: "DatabaseApplication-GetDatabaseModelAsync"));
}
/// <summary>
/// 加载sql运行列表
/// </summary>
/// <param name="queryWhere">查询条件</param>
/// <returns></returns>
public Task <OperateResult <IPageResult <RuntimeSqlListDto> > > GetRuntimSqlListAsync(RuntimeSqlPageQueryWhere queryWhere)
{
return(OperateUtil.ExecuteAsync(async() =>
{
return await _runtimeSqlRepository.GetRuntimSqlListAsync(queryWhere);
}));
}
/// <summary>
/// 获取项目信息
/// </summary>
/// <param name="projectID">项目ID</param>
/// <returns>项目信息</returns>
public Task <OperateResult <ProjectModel> > GetProjectModelAsync(int projectID)
{
return(OperateUtil.ExecuteAsync(async() =>
{
return await _projectRepository.GetDtoAsync <ProjectModel>(m => m.FID == projectID && m.FIsDeleted == false, ignoreFields: OperaterUserID);
}, callMemberName: "ProjectApplication-GetProjectModelAsync"));
}
/// <summary>
/// 获取服务器列表
/// </summary>
/// <returns></returns>
public Task <OperateResult <IEnumerable <ServicerListDto> > > LoadServicerListAsync()
{
return(OperateUtil.ExecuteAsync(async() =>
{
return await _servicerCache.GetServicerListAsync();
}, callMemberName: "ServicerApplication-GetServicerListAsync"));
}
/// <summary>
/// 获取表结构列表
/// </summary>
/// <param name="dbID">数据库ID</param>
/// <returns>表结构列表</returns>
public Task <OperateResult <IEnumerable <TableStructureDto> > > GetTableStructureListAsync(int dbID)
{
return(OperateUtil.ExecuteAsync(async() =>
{
return await _databaseRepository.GetTableStructureListAsync(dbID);
}, callMemberName: "DatabaseApplication-GetTableStructureListAsync"));
}
/// <summary>
/// 获取处理对象
/// </summary>
/// <param name="id">警告日志记录ID</param>
/// <returns></returns>
public Task <OperateResult <WarningDealModel> > GetDealModelAsync(int id)
{
return(OperateUtil.ExecuteAsync(async() =>
{
return await _warningLogRepository.GetWarningLogDealModel(id);
}, callMemberName: "WarningLogApplication-GetDealModelAsync"));
}
public OperateResult <List <DataBaseConfig> > GetDatabaseConfigs()
{
return(OperateUtil.Execute(() =>
{
return ConfigurationHelper.GetAppSettings <List <DataBaseConfig> >(DatabaseKey);
}, callMemberName: "DataBaseConfigRespository-GetDatabaseConfigs"));
}
public OperateResult <IEnumerable <TableStructureDto> > GetDatabaseTableStructure(int dbId)
{
return(OperateUtil.Execute(() =>
{
var dbInfo = GetDatabaseConfigs().Value.Find(x => x.Id == dbId);
if (dbInfo != null && !string.IsNullOrWhiteSpace(dbInfo.ConnectionString) && !string.IsNullOrWhiteSpace(dbInfo.DbType))
{
var dbType = Enum.Parse <DatabaseType>(dbInfo.DbType);
var selectTableListSql = SqlQueryUtil.GetQueryTableListSql(dbType, dbInfo.DbName);
var selectTableColumnListSql = SqlQueryUtil.GetQueryTableColumnListSql(dbType, dbInfo.DbName);
using (var dataAccess = DataAccessFactory.GetDataAccess(dbType, dbInfo.ConnectionString, false))
{
var tableSqlquery = new SqlQuery(selectTableListSql);
var tableList = dataAccess.Query <TableStructureDto>(tableSqlquery);
var tableColumnSqlQuery = new SqlQuery(selectTableColumnListSql);
var tableColumnList = dataAccess.Query <TableColumnStructureDto>(tableColumnSqlQuery);
foreach (var item in tableList)
{
item.ColumnList = tableColumnList.Where(m => m.TableName == item.TableName);
}
return tableList;
}
}
return null;
}, callMemberName: "DataBaseConfigRespository-GetDatabaseTableStructure"));
}
/// <summary>
/// 异步查找警告日志列表
/// </summary>
/// <param name="queryWhere">查询条件</param>
/// <returns>警告日志列表</returns>
public Task <OperateResult <IPageResult <WarningLogListDto> > > GetWarningLogListAsync(WarningLogPageQueryWhere queryWhere)
{
return(OperateUtil.ExecuteAsync(() =>
{
return _warningLogRepository.GetWarningLogListAsync(queryWhere);
}, callMemberName: "WarningLogApplication-GetWarningLogListAsync"));
}
/// <summary>
/// 获取配置编辑信息
/// </summary>
/// <param name="configID">配置ID</param>
/// <returns>配置编辑信息</returns>
public Task <OperateResult <SysConfigModel> > GetSysConfigModelAsync(int configID)
{
return(OperateUtil.ExecuteAsync(async() =>
{
return await _sysConfigRepository.GetDtoAsync <SysConfigModel>(m => m.FID == configID && m.FIsDeleted == false, ignoreFields: OperaterUserID);
}, callMemberName: "SysConfigApplication-GetSysConfigModelAsync"));
}
/// <summary>
/// 获取配置列表
/// </summary>
/// <param name="queryWhere">查询条件</param>
/// <returns>配置列表</returns>
public Task <OperateResult <IPageResult <SysConfigListDto> > > GetConfigListAsync(SysConfigPageQueryWhere queryWhere)
{
return(OperateUtil.ExecuteAsync(() =>
{
return _sysConfigRepository.GetConfigListAsync(queryWhere);
}, callMemberName: "SysConfigApplication-GetConfigListAsync"));
}
public OperateResult <List <DataBaseConfig> > GetDatabaseConfigs()
{
return(OperateUtil.Execute(() =>
{
return ConfigurationHelper.GetAppSettings <List <DataBaseConfig> >(DatabaseKey);
}, callMemberName: "AccessTokenApplication-CheckTokenAvailable"));
}
/// <summary>
/// 加载全部的项目列表
/// </summary>
/// <returns></returns>
public Task <OperateResult <IEnumerable <ProjectListDto> > > LoadProjectListAsync()
{
return(OperateUtil.ExecuteAsync(async() =>
{
return await _projectCache.GetProjectListAsync();
}, callMemberName: "ProjectApplication-LoadProjectListAsync"));
}
/// <summary>
/// 同步数据库信息
/// </summary>
/// <returns>操作结果</returns>
public Task <OperateResult> SynchroDatabaseAsync()
{
return(OperateUtil.ExecuteAsync(async() =>
{
await _databaseCache.SynchroDatabaseAsync();
}, callMemberName: "DatabaseApplication-SynchroDatabaseAsync"));
}
/// <summary>
/// 添加运行sql信息
/// </summary>
/// <param name="runtimeSqlModel"></param>
/// <returns>操作结果</returns>
public Task <OperateResult> AddRuntimeSqlAsync(RuntimeSqlModel runtimeSqlModel)
{
return(OperateUtil.ExecuteAsync(async() =>
{
var runtimeSqlInfo = await _runtimeSqlDomainService.AddRuntimeSqlAsync(runtimeSqlModel);
await _runtimeSqlDomainService.AnalysisRuntimeSqlAsync(runtimeSqlInfo);
}, callMemberName: "RuntimeSqlApplication-AddRuntimeSqlAsync"));
}
/// <summary>
/// 新增运行日志
/// </summary>
/// <param name="runtimeLogModelList">运行日志列表</param>
/// <returns>操作结果</returns>
public OperateResult AddLogList(List <RuntimeLogModel> runtimeLogModelList)
{
return(OperateUtil.Execute(() =>
{
foreach (var item in runtimeLogModelList)
{
AddLogAsync(item).Wait();
}
}, callMemberName: "RuntimeLogApplication-AddLogListAsync"));
}
/// <summary>
/// 新增运行日志
/// </summary>
/// <param name="runtimeLogModel">运行日志信息</param>
/// <returns>操作结果</returns>
public Task <OperateResult> AddLogAsync(RuntimeLogModel runtimeLogModel)
{
return(OperateUtil.ExecuteAsync(async() =>
{
var runtimeLogInfo = await _runtimeLogDomainService.CreateAsync(runtimeLogModel);
var id = (await _runtimeLogRepository.InsertOneAsync(runtimeLogInfo, keyName: "FID", ignoreFields: FID)).ToSafeInt32(0);
runtimeLogInfo.FID = id;
await _runtimeLogDomainService.AnalysisLogAsync(runtimeLogInfo);
}, callMemberName: "RuntimeLogApplication-AddLogAsync"));
}
/// <summary>
/// 用户登录
/// </summary>
/// <param name="model">用户登录信息</param>
/// <returns>登陆成功则返回用户ID</returns>
public Task <OperateResult <int> > LoginAsync(LoginModel model)
{
return(OperateUtil.ExecuteAsync(async() =>
{
model.NotNull("请输入您的信息");
var adminInfo = await _adminDomainService.LoginAsync(model.UserName, model.Pwd);
await _adminDetailDomainService.ChangeLastLoginInfoAsync(adminInfo);
_operateLogDomainService.AddOperateLog(adminInfo.FID, OperateModule.User, OperateModuleNode.Login, "用户登录");
return adminInfo.FID;
}, callMemberName: "AdminApplication-LoginAsync"));
}
/// <summary>
/// 处理警告日志日志
/// </summary>
/// <param name="model">处理信息</param>
/// <returns></returns>
public Task <OperateResult> DealAsync(WarningDealModel model)
{
return(OperateUtil.ExecuteAsync(async() =>
{
model.NotNull("处理信息不能为空");
model.FTreatmentScheme.NotNullAndNotEmptyWhiteSpace("处理方案不能为空");
await _warningLogRepository.UpdateAsync(new
{
FTreatmentScheme = model.FTreatmentScheme,
FDealState = DealState.Dealed,
FLastModifyTime = DateTimeUtil.Now,
FLastModifyUserID = model.OperateUserID.Value
}, m => m.FID == model.FID);
await _warningInfoOperateLogDomainService.AddLogAsync(1, model.FID, model.FTreatmentScheme, model.OperateUserID.Value);
_operateLogDomainService.AddOperateLog(model.OperateUserID.Value, OperateModule.SysConfig, OperateModuleNode.Edit, $"处理警告日志");
}, callMemberName: "WarningLogApplication-DealAsync"));
}
/// <summary>
/// 添加项目信息
/// </summary>
/// <param name="projectModel">项目信息</param>
/// <returns>操作结果</returns>
public Task <OperateResult> AddProjectAsync(ProjectModel projectModel)
{
return(OperateUtil.ExecuteAsync(async() =>
{
var projectInfo = _projectDomainService.Create(projectModel);
int id = await LockUtil.ExecuteWithLockAsync(Lock_ProjectModify, projectInfo.FName, TimeSpan.FromMinutes(2), async() =>
{
await _projectDomainService.CheckAsync(projectInfo);
int projectID = (await _projectRepository.InsertOneAsync(projectInfo, keyName: "FID", ignoreFields: FID)).ToSafeInt32(0);
_operateLogDomainService.AddOperateLog(projectModel.OperateUserID.Value, OperateModule.Project, OperateModuleNode.Add, $"添加:{projectInfo.GetOperateDesc()}");
_projectDomainService.ProjectChanged(OperateType.Add, projectID);
return projectID;
}, defaultValue: -1);
if (id <= 0)
{
throw new BizException("添加失败");
}
}, callMemberName: "ProjectApplication-AddProjectAsync"));
}
/// <summary>
/// 添加数据库信息
/// </summary>
/// <param name="databaseModel">数据库信息</param>
/// <returns>操作结果</returns>
public Task <OperateResult> AddDatabaseAsync(DatabaseModel databaseModel)
{
return(OperateUtil.ExecuteAsync(async() =>
{
var dbInfo = _databaseDomainService.Create(databaseModel);
int id = await LockUtil.ExecuteWithLockAsync(Lock_DatabaseModify, dbInfo.FName, TimeSpan.FromMinutes(2), async() =>
{
await _databaseDomainService.CheckAsync(dbInfo);
int dbID = (await _databaseRepository.InsertOneAsync(dbInfo, keyName: "FID", ignoreFields: FID)).ToSafeInt32(0);
_operateLogDomainService.AddOperateLog(databaseModel.OperateUserID.Value, OperateModule.Database, OperateModuleNode.Add, $"添加:{dbInfo.GetOperateDesc()}");
_databaseDomainService.DatabaseChanged(OperateType.Add, dbID);
return dbID;
}, defaultValue: -1);
if (id <= 0)
{
throw new BizException("添加失败");
}
}, callMemberName: "DatabaseApplication-AddDatabaseAsync"));
}
/// <summary>
/// 修改项目信息
/// </summary>
/// <param name="projectModel">项目信息</param>
/// <returns>操作结果</returns>
public Task <OperateResult> EditProjectAsync(ProjectModel projectModel)
{
return(OperateUtil.ExecuteAsync(async() =>
{
var projectInfo = _projectDomainService.Create(projectModel);
var flag = await LockUtil.ExecuteWithLockAsync(Lock_ProjectModify, projectInfo.FName, TimeSpan.FromMinutes(2), async() =>
{
await _projectDomainService.CheckAsync(projectInfo);
await _projectRepository.UpdateAsync(projectInfo, m => m.FID == projectInfo.FID, ignoreFields: IDAndCreate);
_operateLogDomainService.AddOperateLog(projectModel.OperateUserID.Value, OperateModule.SysConfig, OperateModuleNode.Edit, $"{projectInfo.GetOperateDesc()}");
_projectDomainService.ProjectChanged(OperateType.Modify, projectInfo.FID);
return true;
}, defaultValue: false);
if (!flag)
{
throw new BizException("修改失败");
}
}, callMemberName: "ProjectApplication-EditProjectAsync"));
}
