public async Task <IResponseEntity> UpdateAsync(UserEditRequest req)
{
if (req == null || req?.Id == "")
{
return(ResponseEntity.Error("更新的实体主键丢失"));
}
var entity = await _sysUserRepository.GetAsync(req.Id);
if (entity == null || entity.Id == "")
{
return(ResponseEntity.Error("用户不存在!"));
}
if (entity.PermissionId != req.PermissionId)
{
//清除权限模板的资源缓存
await _cache.RemoveByPatternAsync(CacheKeyTemplate.PermissionResourceList);
//清除权限模板的API缓存
await _cache.RemoveByPatternAsync(CacheKeyTemplate.PermissionApiList);
}
_mapper.Map(req, entity);
//var entity = _mapper.Map<SysUserEntity>(req);
await _sysUserRepository.UpdateAsync(entity);
return(ResponseEntity.Ok("更新成功"));
}
public async Task <IResponseEntity> UpdateAsync(TaskQzEditRequest req)
{
if (req == null || req?.Id == "")
{
return(ResponseEntity.Error("更新的实体主键丢失"));
}
var entity = _mapper.Map <SysTaskQzEntity>(req);
if (entity.IsDefaultDatabase)
{
DbInfo dbInfo = _authUser.Tenant.DbOptions.Where(x => x.Key == Constants.SystemDbKey).FirstOrDefault();
DbConnectionString connectionString = dbInfo.ConnectionStrings.Where(x => x.UseType == DbUseType.Master).FirstOrDefault();
entity.ConnectionParam = JsonConvert.SerializeObject(new
{
ConnectionString = connectionString.ConnectionString,
DbType = Convert.ToInt32(dbInfo.DbType)
});
}
await _SysTaskQzRepository.UpdateAsync(entity);
if (entity.IsStart)
{
var res = await _schedulerCenter.AddScheduleJobAsync(entity);
}
return(ResponseEntity.Ok("更新成功"));
}
public async Task <IResponseEntity> GetResourcesAsync()
{
var resources = await _sysResourceRepository.Select
.Where(a => a.IsDisabled == false)
//.OrderBy(a => a.ParentId)
.OrderBy(a => a.OrderIndex)
.ToListAsync(a => new { a.Id, a.ParentId, a.Title, a.ResourceType, a.Icon, a.OrderIndex });
var funcs = resources
.Where(a => a.ResourceType == ResourceType.Func)
.OrderBy(a => a.OrderIndex)
.Select(a => new { a.Id, a.ParentId, a.Title });
var result = resources
.Where(a => (new[] { ResourceType.Group, ResourceType.Menu }).Contains(a.ResourceType))
.OrderBy(a => a.OrderIndex)
.Select(a => new
{
a.Id,
a.ParentId,
a.Icon,
a.Title,
funcs = funcs.Where(b => b.ParentId == a.Id).Select(b => new { b.Id, b.Title })
});
return(ResponseEntity.Ok(result));
}
public async Task<IResponseEntity> GetItemAsync(string id)
{
var result = await _sysPermissionRepository.GetAsync(id);
var data = _mapper.Map<PermissionForItemResponse>(result);
return ResponseEntity.Ok(data);
}
public async Task<IResponseEntity> GetRoleIdsByPermissionIdAsync(string permissionId) {
var roleIds = await _sysRPermissionRoleRepository
.Select.Where(d => d.PermissionId == permissionId)
.ToListAsync(a => a.RoleId);
return ResponseEntity.Ok(roleIds);
}
/// <summary>
/// 得到当前用户信息（主要用于前端F5刷新）
/// </summary>
/// <returns></returns>
public async Task <IResponseEntity> GetUserInfoAsync()
{
var user = _userRepository.Get(_authUser.Id);
var res = await getUserItem(user);
return(ResponseEntity.Ok(res));
}
public IResponseEntity Get()
{
var ti = HttpContext.GetMultiTenantContext()?.TenantInfo;
Logger.LogInformation($"{typeof(DemoController)}.Get 执行完成");
return(ResponseEntity.Ok(ti));
}
/// <summary>
/// 更新当前用户基本信息
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public async Task <IResponseEntity> UpdateUserInfo(UserEditRequest req)
{
if (req == null)
{
return(ResponseEntity.Error("更新的实体丢失"));
}
//req.Id = _authUser.Id;
var entity = await _sysUserRepository.GetAsync(_authUser.Id);
if (entity == null || entity.Id == "")
{
return(ResponseEntity.Error("用户不存在!"));
}
entity.DisplayName = req.DisplayName;
entity.Mobile = req.Mobile;
entity.Mail = req.Mail;
entity.Description = req.Description;
await _sysUserRepository.UpdateAsync(entity);
return(ResponseEntity.Ok(entity));
}
public async Task <IResponseEntity> ClearAsync(string cacheKey)
{
_logger.LogWarning($"清除缓存[{cacheKey}]，操作人：{_authUser.Id}.{_authUser.UserName}");
await _cache.RemoveByPatternAsync(cacheKey);
return(ResponseEntity.Ok());
}
/// <summary>
/// 得到查询条件的分页列表数据
/// </summary>
/// <param name="req">带分页属性的DTO查询对象</param>
/// <returns></returns>
public async Task <IResponseEntity> GetListAsync(RequestEntity <DictionaryHeaderFilterRequest> req)
{
// 得到权限模板配置的数据条件
var condition = await _permissionDomain.GetPermissionDynamicFilterAsync(_authUser.PermissionId, "DICTIONARY_HEADER");
var key = req.Filter?.Key;
var withDisable = req.Filter != null ? req.Filter.WithDisable : false;
var list = await _dictionaryRepository.Select
.WhereDynamicFilter(condition)
.WhereIf(key.IsNotNull(), a => (a.Title.Contains(key) || a.Code.Contains(key) || a.Description.Contains(key)))
.WhereIf(!withDisable, a => a.IsDisabled == false)
.Count(out var total)
.OrderBy(true, a => a.OrderIndex)
.Page(req.CurrentPage, req.PageSize)
.ToListAsync();
var data = new ResponsePageEntity <DictionaryHeaderForListResponse>()
{
List = _mapper.Map <List <DictionaryHeaderForListResponse> >(list),
Total = total
};
return(ResponseEntity.Ok(data));
}
/// <summary>
/// 停止任务
/// </summary>
/// <param name="sysSchedule"></param>
/// <returns></returns>
public async Task <IResponseEntity> StopScheduleJobAsync(SysTaskQzEntity sysSchedule)
{
try
{
JobKey jobKey = new JobKey(sysSchedule.Id.ToString(), sysSchedule.JobGroup);
if (!await _scheduler.Result.CheckExists(jobKey))
{
await Console.Out.WriteLineAsync($"未找到要停止的任务:【{sysSchedule.Name}】");
return(ResponseEntity.Error($"未找到要停止的任务:【{sysSchedule.Name}】"));
}
else
{
await _scheduler.Result.DeleteJob(jobKey);
await Console.Out.WriteLineAsync($"停止任务:【{sysSchedule.Name}】成功");
return(ResponseEntity.Ok($"停止任务:【{sysSchedule.Name}】成功"));
}
}
catch (Exception)
{
throw;
}
}
public async Task <IResponseEntity> GetResourceIdsByIdAsync(string roleId)
{
var resourceIds = await _sysRRoleResourceRepository
.Select.Where(d => d.RoleId == roleId)
.ToListAsync(a => a.ResourceId);
return(ResponseEntity.Ok(resourceIds));
}
public async Task <IResponseEntity> GetConditionIdsByPermissionIdAsync(string permissionId)
{
var conditionIds = await _sysRPermissionConditionRepository
.Select.Where(d => d.PermissionId == permissionId)
.ToListAsync(a => a.ConditionId);
return(ResponseEntity.Ok(conditionIds));
}
/// <summary>
/// 得到实体
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
public async Task <IResponseEntity> GetItemAsync(string id)
{
var result = await _dictionaryEntryRepository.GetAsync(id);
var data = _mapper.Map <DictionaryHeaderForItemResponse>(result);
return(ResponseEntity.Ok(data));
}
public async Task <IResponseEntity> GetItemAsync(string id)
{
var result = await _sysConfigRepository.GetAsync(id);
var data = _mapper.Map <RoleForItemResponse>(result);
return(ResponseEntity.Ok(data));
}
public async Task <IResponseEntity> GetResourceApisByIdAsync(string resourceId)
{
var apis = await _sysRResourceApiRepository.Select
.Where(a => a.ResourceId == resourceId)
.Include(a => a.Api)
.ToListAsync(a => a.Api);
return(ResponseEntity.Ok(apis));
}
public async Task <IResponseEntity> GetSystemConfig()
{
var res = await _settingService.GetSystemSettingsAsync();
if (res != null)
{
return(ResponseEntity.Ok(res));
}
return(ResponseEntity.Error("没取到任何数据"));
}
public async Task <IResponseEntity> UploadAvatar([FromForm] IFormFile file)
{
var res = await _sysUserService.UploadAvatarAsync(file);
if (res.Success)
{
return(ResponseEntity.Ok(res.Data.FileRelativePath));
}
return(ResponseEntity.Error("上传失败！"));
}
/// <summary>
/// 更新
/// </summary>
/// <param name="req">DTO:编辑实体</param>
/// <returns></returns>
public async Task <IResponseEntity> UpdateAsync(DictionaryEntryEditRequest req)
{
if (req == null || req?.Id == "")
{
return(ResponseEntity.Error("更新的实体主键丢失"));
}
var entity = _mapper.Map <DictionaryEntryEntity>(req);
await _dictionaryEntryRepository.UpdateAsync(entity);
return(ResponseEntity.Ok("更新成功"));
}
public async Task <IResponseEntity> InitDb(DbConnectItem req)
{
StringBuilder sb = new StringBuilder();
sb.Append("<ul>");
sb.Append("<li>创建数据连接对象 开始</li>");
var dbType = (FreeSql.DataType)Enum.Parse(typeof(FreeSql.DataType), req.DbType);
var connStr = req.ConnectionString;
IFreeSql fsql = new FreeSqlBuilder()
.UseConnectionString(dbType, connStr)
.UseAutoSyncStructure(true) //自动同步实体结构【开发环境必备】
.Build();
DbConnection dbConnection = fsql.Ado.MasterPool.Get().Value; // 这儿验证 连接是否成功，这句代码可以不要，如果连接字符不变正确，为了提早发现（报异常）
fsql.Aop.AuditValue += SyncDataAuditValue;
sb.Append("<li>创建数据连接对象 结束</li>");
sb.Append("<li>创建数据库结构及初始化数据 开始</li>");
using (var uow = fsql.CreateUnitOfWork())
using (var tran = uow.GetOrBeginTransaction())
{
SeedDataEntity data = (new SeedData()).GetSeedData();
sb.Append("<ul>");
await InitDtData(fsql, data.SysApiEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysConditionEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysDictionaryEntryEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysDictionaryHeaderEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysConfigEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysGroupEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysPermissionEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysResourceEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysRoleEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysRPermissionConditionEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysRPermissionRoleEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysRResourceApiEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysRRoleResourceEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysSettingEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysUserEntities.ToArray(), tran, sb);
await InitDtData(fsql, data.SysLoginLogEntities?.ToArray(), tran, sb);
await InitDtData(fsql, data.SysOperationLogEntities?.ToArray(), tran, sb);
sb.Append("</ul>");
uow.Commit();
}
sb.Append("<li>创建数据库结构及初始化数据 结束</li>");
sb.Append("</ul>");
fsql.Dispose();
return(ResponseEntity.Ok("初始化成功", msg: sb.ToString()));
}
public async Task <IResponseEntity> GetTenantList()
{
var res = await _settingService.GetTenantListAsync();
if (res != null)
{
var obj = res.OrderBy(x => x.Id);
return(ResponseEntity.Ok(obj));
}
return(ResponseEntity.Error("没取到任何数据"));
}
public IResponseEntity GetList()
{
var tenants = _tenants.CurrentValue;
ArrayList data = new ArrayList();
foreach (var tenant in tenants.OrderBy(x => x.Id))
{
data.Add(new { id = tenant.Id, code = tenant.Code, name = tenant.Name });
}
return(ResponseEntity.Ok(data));
}
public IResponseEntity GenerateSeedData(DbConnectItem req)
{
var dbType = (FreeSql.DataType)Enum.Parse(typeof(FreeSql.DataType), req.DbType);
var connStr = req.ConnectionString;
IFreeSql fsql = new FreeSqlBuilder()
.UseConnectionString(dbType, connStr)
.Build();
var seedData = new SeedData();
seedData.GenerateSeedData(fsql);
return(ResponseEntity.Ok("种子数据生成成功"));
}
public async Task <IResponseEntity> UpdateAsync(ConfigEditRequest req)
{
if (req == null || req?.Id == "")
{
return(ResponseEntity.Error("更新的实体主键丢失"));
}
var entity = _mapper.Map <SysConfigEntity>(req);
await _sysConfigRepository.UpdateAsync(entity);
return(ResponseEntity.Ok("更新成功"));
}
public async Task<IResponseEntity> GetAllAsync(PermissionFilterRequest req)
{
var key = req?.Key;
var withDisable = req != null ? req.WithDisable : false;
var list = await _sysPermissionRepository.Select
.WhereIf(key.IsNotNull(), a => (a.Title.Contains(key) || a.Code.Contains(key) || a.Description.Contains(key)))
.WhereIf(!withDisable, a => a.IsDisabled == false)
.OrderBy(true, a => a.OrderIndex)
.ToListAsync();
var result = _mapper.Map<List<PermissionForListResponse>>(list);
return ResponseEntity.Ok(result);
}
public async Task <IResponseEntity> GetAllAsync(ApiFilterRequest req)
{
var key = req?.Key;
var withDisable = req != null ? req.WithDisable : false;
var list = await _sysApiRepository.Select
.WhereIf(key.IsNotNull(), a => (a.Title.Contains(key) || a.Category.Contains(key) || a.Url.Contains(key) || a.HttpMethod.Contains(key)))
.WhereIf(!withDisable, a => a.IsDisabled == false)
.ToListAsync();
var result = _mapper.Map <List <ApiForListResponse> >(list);
return(ResponseEntity.Ok(result));
}
public async Task <IResponseEntity> GetAllAsync(UserFilterRequest req)
{
var key = req?.Key;
var withDisable = req != null ? req.WithDisable : false;
var list = await _sysUserRepository.Select
.WhereIf(key.IsNotNull(), a => (a.UserName.Contains(key) || a.DisplayName.Contains(key)))
.WhereIf(!withDisable, a => a.IsDisabled == false)
.Include(a => a.Permission)
.ToListAsync();
var result = _mapper.Map <List <UserForListResponse> >(list);
return(ResponseEntity.Ok(result));
}
public async Task <IResponseEntity> GetAllAsync(TaskQzFilterRequest req)
{
var key = req?.Key;
var withDisable = req != null ? req.WithDisable : false;
var list = await _SysTaskQzRepository.Select
.WhereIf(key.IsNotNull(), a => (a.Name.Contains(key) || a.Remark.Contains(key) || a.JobGroup.Contains(key)))
.WhereIf(!withDisable, a => a.IsDisabled == false)
.OrderBy(true, a => a.CreatedTime)
.ToListAsync();
var result = _mapper.Map <List <TaskQzForListResponse> >(list);
return(ResponseEntity.Ok(result));
}
/// <summary>
/// 上传单文件
/// </summary>
/// <param name="file"></param>
/// <param name="config"></param>
/// <param name="args"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <IResponseEntity <FileInfo> > UploadFileAsync(IFormFile file, FileUploadConfig config, object args, CancellationToken cancellationToken = default)
{
var res = new ResponseEntity <FileInfo>();
if (file == null || file.Length < 1)
{
return(res.Error("请上传文件！"));
}
//格式限制
if (!config.ContentType.Contains(file.ContentType))
{
return(res.Error("文件格式错误"));
}
//大小限制
if (!(file.Length <= config.MaxSize))
{
return(res.Error("文件过大"));
}
var fileInfo = new File.FileInfo(file.FileName, file.Length)
{
UploadPath = config.UploadPath,
RequestPath = config.RequestPath
};
var dateTimeFormat = config.DateTimeFormat.IsNotNull() ? DateTime.Now.ToString(config.DateTimeFormat) : "";
var format = config.Format.IsNotNull() ? StringHelper.Format(config.Format, args) : "";
fileInfo.RelativePath = Path.Combine(dateTimeFormat, format).ToPath();
if (!Directory.Exists(fileInfo.FileDirectory))
{
Directory.CreateDirectory(fileInfo.FileDirectory);
}
var dataCenterId = _systemConfig.CurrentValue?.DataCenterId ?? 5;
var workId = _systemConfig.CurrentValue?.WorkId ?? 20;
fileInfo.SaveName = $"{IdHelper.GenSnowflakeId(dataCenterId, workId)}.{fileInfo.Extension}";
await SaveAsync(file, fileInfo.FilePath, cancellationToken);
return(res.Ok(fileInfo));
}
/// <summary>
/// 更新
/// </summary>
/// <param name="req">DTO:编辑实体</param>
/// <returns></returns>
public async Task <IResponseEntity> UpdateAsync(ConditionEditRequest req)
{
if (req.Id == "" || req.Code == "")
{
return(ResponseEntity.Error("更新的实体主键丢失"));
}
//var count = _sysConditionRepository.Select.Where(x => x.Code == req.Code && x.Id != req.Id).Count();
//if (count > 0)
//{
// return ResponseEntity.Error("已存在相同字典编码，请更换");
//}
var entity = _mapper.Map <SysConditionEntity>(req);
await _sysConditionRepository.UpdateAsync(entity);
return(ResponseEntity.Ok("更新成功"));
}
