/// <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="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));
}
/// <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> 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> 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> DeleteAsync(string id)
{
if (id == null || id == "")
{
return ResponseEntity.Error("删除对象的主键获取失败");
}
var result = await _sysPermissionRepository.DeleteAsync(id);
return ResponseEntity.Result(result > 0);
}
public async Task<IResponseEntity> DeleteBatchAsync(string[] ids)
{
if (ids == null || ids.Length == 0)
{
return ResponseEntity.Error("删除对象的主键获取失败");
}
var result = await _sysPermissionRepository.Where(m => ids.Contains(m.Id)).ToDelete().ExecuteAffrowsAsync();
return ResponseEntity.Result(result > 0);
}
public async Task <IResponseEntity> GetSystemConfig()
{
var res = await _settingService.GetSystemSettingsAsync();
if (res != null)
{
return(ResponseEntity.Ok(res));
}
return(ResponseEntity.Error("没取到任何数据"));
}
/// <summary>
/// 删除 - 单条物理删除
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
public async Task <IResponseEntity> DeleteAsync(string id)
{
if (id == null || id == "")
{
return(ResponseEntity.Error("删除对象的主键获取失败"));
}
var result = await _dictionaryEntryRepository.DeleteAsync(id);
return(ResponseEntity.Result(result > 0));
}
/// <summary>
/// 删除 - 单条逻辑删除（软删除）
/// </summary>
/// <param name="id">待删除的ID</param>
/// <returns></returns>
public async Task <IResponseEntity> SoftDeleteAsync(string id)
{
if (id == null || id == "")
{
return(ResponseEntity.Error("删除对象的主键获取失败"));
}
var result = await _sysConditionRepository.SoftDeleteAsync(id);
return(ResponseEntity.Result(result));
}
/// <summary>
/// 删除 - 批量逻辑删除（软删除）
/// </summary>
/// <param name="ids">待删除的ID集合</param>
/// <returns></returns>
public async Task <IResponseEntity> SoftDeleteBatchAsync(string[] ids)
{
if (ids == null || ids.Length == 0)
{
return(ResponseEntity.Error("删除对象的主键获取失败"));
}
var result = await _sysConditionRepository.SoftDeleteAsync(ids);
return(ResponseEntity.Result(result));
}
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("上传失败！"));
}
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("没取到任何数据"));
}
/// <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> 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> DeleteAsync(string id)
{
if (id == null || id == "")
{
return(ResponseEntity.Error("删除对象的主键获取失败"));
}
var result = await _sysResourceRepository.DeleteAsync(id);
//清除缓存
await _cache.RemoveByPatternAsync(CacheKeyTemplate.PermissionResourceList);
return(ResponseEntity.Result(result > 0));
}
public async Task <IResponseEntity> DeleteBatchAsync(string[] ids)
{
if (ids == null || ids.Length == 0)
{
return(ResponseEntity.Error("删除对象的主键获取失败"));
}
var result = await _sysResourceRepository.Where(m => ids.Contains(m.Id)).ToDelete().ExecuteAffrowsAsync();
//清除缓存
await _cache.RemoveByPatternAsync(CacheKeyTemplate.PermissionResourceList);
return(ResponseEntity.Result(result > 0));
}
public async Task <IResponseEntity <FileInfo> > UploadAvatarAsync(IFormFile file, CancellationToken cancellationToken = default)
{
var res = new ResponseEntity <FileInfo>();
var config = _systemConfig.CurrentValue.UploadAvatar;
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);
fileInfo.UploadPath = config.UploadPath;
fileInfo.RequestPath = config.RequestPath;
fileInfo.RelativePath = _authUser.Tenant.Id;
fileInfo.SaveName = $"{_authUser.Id}.{fileInfo.Extension}";
if (!Directory.Exists(fileInfo.FileDirectory))
{
Directory.CreateDirectory(fileInfo.FileDirectory);
}
await SaveAsync(file, fileInfo.FilePath, cancellationToken);
return(res.Ok(fileInfo));
}
public async Task <IResponseEntity> SoftDeleteBatchAsync(string[] ids)
{
if (ids == null || ids.Length == 0)
{
return(ResponseEntity.Error("删除对象的主键获取失败"));
}
var result = await _sysGroupRepository.SoftDeleteAsync(ids);
//清除缓存
await _cache.RemoveByPatternAsync(CacheKeyTemplate.GroupList);
return(ResponseEntity.Result(result));
}
private Task HandleExceptionAsync(HttpContext context, Exception ex)
{
//var code = HttpStatusCode.InternalServerError; // 500 if unexpected
var code = StatusCodes.Status500InternalServerError;
string info = "服务器内部错误，无法完成请求";
switch (context.Response.StatusCode)
{
case 401:
info = "没有权限";
break;
case 404:
info = "未找到服务";
break;
case 403:
info = "服务器理解请求客户端的请求，但是拒绝执行此请求";
break;
case 500:
info = "服务器内部错误，无法完成请求";
break;
case 502:
info = "请求错误";
break;
default:
info = ex.Message;
break;
}
_logger.LogError(info); // todo:可记录日志,如通过注入Nlog等三方日志组件记录
//var result = JsonConvert.SerializeObject(new { Coede= code.ToString(), Message = info });
var result = JsonConvert.SerializeObject(
ResponseEntity.Error(info, code),
Formatting.None,
new JsonSerializerSettings
{
ContractResolver = new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver()
});
context.Response.ContentType = "application/json";
context.Response.StatusCode = code;
return(context.Response.WriteAsync(result));
}
public void OnActionExecuting(ActionExecutingContext context)
{
if (!context.ModelState.IsValid)
{
string message = string.Empty;
foreach (var item in context.ModelState.Values)
{
foreach (var error in item.Errors)
{
message += error.ErrorMessage + "|";
}
}
context.Result = new JsonResult(ResponseEntity.Error(message));
}
}
public async Task <IResponseEntity> SaveTenantConfig(TenantInfo req)
{
var tenants = await _settingService.GetTenantListAsync();
if (req.Code == null || req.Code == "")
{
return(ResponseEntity.Error("租户编码不能为空"));
}
if (req.Id == null || req.Id == "") // 新增租户
{
var item = tenants.Where(x => x.Code == req.Code).FirstOrDefault();
if (item != null)
{
return(ResponseEntity.Error("添加失败，租户编码已经存在"));
}
req.Id = IdHelper.GenSnowflakeId().ToString();
}
else // 编辑租户
{
var item = tenants.Where(x => x.Id == req.Id).FirstOrDefault();
if (item != null)
{
tenants.Remove(item);
}
}
#region 字典里的KEY，大小写问题
var audience = (string)req.Items["audience"];
var expirationMinutes = (string)req.Items["expirationMinutes"];
var issuer = (string)req.Items["issuer"];
var secret = (string)req.Items["secret"];
req.Items.Clear();
req.Items.Add("Audience", audience);
req.Items.Add("Issuer", issuer);
req.Items.Add("ExpirationMinutes", expirationMinutes);
req.Items.Add("Secret", secret);
#endregion
tenants.Add(req);
var updateTenants = tenants.OrderBy(x => x.Id).ToList();
var result = await _settingService.WriteTenantsConfig(updateTenants);
return(ResponseEntity.Result(result));
}
/// <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("更新成功"));
}
/// <summary>
/// 更新
/// </summary>
/// <param name="req">DTO:编辑实体</param>
/// <returns></returns>
public async Task <IResponseEntity> UpdateAsync(DictionaryHeaderEditRequest req)
{
if (req.Id == "" || req.Code == "")
{
return(ResponseEntity.Error("更新的实体主键丢失"));
}
var count = _dictionaryRepository.Select.Where(x => x.Code == req.Code && x.Id != req.Id).Count();
if (count > 0)
{
return(ResponseEntity.Error("已存在相同字典编码，请更换"));
}
var entity = _mapper.Map <DictionaryHeaderEntity>(req);
await _dictionaryRepository.UpdateAsync(entity);
return(ResponseEntity.Ok("更新成功"));
}
/// <summary>
/// 恢复指定的计划任务
/// </summary>
/// <param name="sysSchedule"></param>
/// <returns></returns>
public async Task <IResponseEntity> ResumeJob(SysTaskQzEntity sysSchedule)
{
try
{
JobKey jobKey = new JobKey(sysSchedule.Id.ToString(), sysSchedule.JobGroup);
if (!await _scheduler.Result.CheckExists(jobKey))
{
return(ResponseEntity.Error($"未找到要重新的任务:【{sysSchedule.Name}】,请先选择添加计划！"));
}
await this._scheduler.Result.ResumeJob(jobKey);
return(ResponseEntity.Ok($"恢复计划任务:【{sysSchedule.Name}】成功"));
}
catch (Exception)
{
throw;
}
}
public async Task <IResponseEntity> DeleteTenant(string id)
{
var tenants = await _settingService.GetTenantListAsync();
var item = tenants.Where(x => x.Id == id).FirstOrDefault();
if (item != null)
{
tenants.Remove(item);
}
else
{
return(ResponseEntity.Error("删除失败，没有找到租户信息"));
}
var result = await _settingService.WriteTenantsConfig(tenants);
return(ResponseEntity.Result(result));
}
public async Task <IResponseEntity> UpdateAsync(RoleEditRequest req)
{
if (req == null || req?.Id == "")
{
return(ResponseEntity.Error("更新的实体主键丢失"));
}
//var entity = await _sysRoleRepository.GetAsync(req.Id);
//if (entity == null || entity?.Id == "")
//{
// return ResponseEntity.Error("找不到更新的实体！");
//}
//_mapper.Map(req, entity);
var entity = _mapper.Map <SysRoleEntity>(req);
await _sysRoleRepository.UpdateAsync(entity);
return(ResponseEntity.Ok("更新成功"));
}
/// <summary>
/// 创建
/// </summary>
/// <param name="req">DTO:新增实体</param>
/// <returns></returns>
public async Task <IResponseEntity> CreateAsync(ConditionAddRequest req)
{
var code = req.Code;
if (code == null || code == "")
{
return(ResponseEntity.Error("字典编码不能为空"));
}
//var count = _sysConditionRepository.Select.Where(x => x.Code == code).Count();
//if (count > 0)
//{
// return ResponseEntity.Error("已存在相同字典编码，请更换");
//}
var item = _mapper.Map <SysConditionEntity>(req);
var result = await _sysConditionRepository.InsertAsync(item);
return(ResponseEntity.Result(result != null && result?.Id != ""));
}
public async Task <IResponseEntity> LoginAsync(AuthLoginRequest req)
{
var password = MD5Encrypt.Encrypt32(req.Password);
SysUserEntity user = new SysUserEntity();
using (_userRepository.DataFilter.Disable("Group"))
{
user = await _userRepository.GetAsync(a => a.UserName == req.UserName && a.Password == password);
}
if (user?.Id == "")
{
return(ResponseEntity.Error("账号或密码错误!"));
}
var res = await getUserItem(user);
return(ResponseEntity.Ok(res));
}
/// <summary>
/// 修改当前登录人的密码
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public async Task <IResponseEntity> ChangePasswordAsync(ChangePasswordRequest req)
{
var oldPassword = MD5Encrypt.Encrypt32(req.OldPassword);
var item = _sysUserRepository.Where(a => a.Id == _authUser.Id && a.Password == oldPassword).First();
if (item == null)
{
return(ResponseEntity.Error("旧密码错误，请输入正确的旧密码"));
}
if (req.NewPassword != req.ConfirmPassword)
{
return(ResponseEntity.Error("两次密码不一致，请重新输入"));
}
var newPassword = MD5Encrypt.Encrypt32(req.NewPassword);
item.Password = newPassword;
await _sysUserRepository.UpdateAsync(item);
return(ResponseEntity.Ok("更新成功"));
}