/// <summary>
/// 添加角色
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <IResponseOutput> AddRoleAsync(RoleSaveDto dto)
{
var list = await _roleRepo.FindListAsync(_ => _.Name == dto.Name);
if (list.Count > 0)
{
return(ResponseOutput.NotOk("名称重复"));
}
var data = ObjectMapper.Map <RoleEntity>(dto);
data.CreatedTime = DateTime.Now;
await _roleRepo.InsertAsync(data);
return(ResponseOutput.Ok());
}
public async Task <IResponseOutput> GenerateTokenAsync(string type, string code, string state)
{
if (!StateManager.IsExist(state))
{
return(ResponseOutput.NotOk("Request failed"));
}
StateManager.Remove(state);
var token = type switch
{
"github" => GenerateToken(await _githubService.GetUserByOAuthAsync(type, code, state)),
_ => throw new NotImplementedException($"Not implemented {type}")
};
return(ResponseOutput.Ok(token));
}
public IResponseOutput RequestToken([FromBody] LoginRequestDto request)
{
if (!ModelState.IsValid)
{
return(ResponseOutput.NotOk("Invalid Request"));
}
string token;
if (_authService.IsAuthenticated(request, out token))
{
return(ResponseOutput.Ok(token));
}
return(ResponseOutput.NotOk("Invalid Request"));
}
/// <summary>
/// 异常处理
/// </summary>
/// <param name="context"></param>
public void OnException(ExceptionContext context)
{
Log.Logger = new LoggerConfiguration().CreateLogger();
if (context.Exception != null)
{
context.Result = new ContentResult()
{
Content = ResponseOutput.Error(context.Exception.Message, context.Exception).SerializeToJson(),
StatusCode = StatusCodes.Status200OK
};
context.ExceptionHandled = true;
Log.Error(context.Exception, $"{context.HttpContext.Request.Path}|{context.Exception.Message}");
}
}
public async Task <IResponseOutput> GetListAsync(string key, DateTime?start, DateTime?end)
{
if (end.HasValue)
{
end = end.Value.AddDays(1);
}
var data = await _DocumentRepository
.WhereIf(key.NotNull(), a => a.Name.Contains(key) || a.Label.Contains(key))
.WhereIf(start.HasValue && end.HasValue, a => a.CreatedTime.Value.BetweenEnd(start.Value, end.Value))
.OrderBy(a => a.ParentId)
.OrderBy(a => a.Sort)
.ToListAsync <DocumentListOutput>();
return(ResponseOutput.Ok(data));
}
async public Task <IResponseOutput> List([FromQuery] int workTypeId, int page, int size)
{
var list = await _fsql.Select <WireRodType>()
.WhereIf(workTypeId != 0, p => p.WorkTypeId == workTypeId)
.Count(out var total)
.Page(page, size)
.ToListAsync();
return(ResponseOutput.Ok(new Pagenation <WireRodType>
{
Page = page,
Total = total,
Size = size,
List = list,
}));
}
public async Task <IResponseOutput> GetById([FromRoute] int id)
{
var user = await _fsql.Select <User>().From <Department, UserRole, Role>((u, d, ur, r) => u
.LeftJoin(a => a.DepartmentId == d.Id)
.LeftJoin(a => a.Id == ur.UserId)
.LeftJoin(a => ur.RoleId == r.Id))
.WhereIf(id > 0, (u, d, ur, r) => u.Id == id)
.FirstAsync((u, d, ur, r) => new UserResponseDto
{
Id = u.Id,
DepartmentName = d.Name,
RoleName = r.Name,
});
return(ResponseOutput.Ok(user));
}
public async Task <IResponseOutput> GetUserInfoAsync()
{
if (!(User?.Id > 0))
{
return(ResponseOutput.NotOk("未登录！"));
}
var key = string.Format(CacheKey.UserInfo, User.Id);
var output = await Cache.GetOrSetAsync(key, async() =>
{
var authUserInfoOutput = new AuthUserInfoOutput {
};
//用户信息
authUserInfoOutput.User = await _userRepository.GetAsync <AuthUserProfileDto>(User.Id);
//用户菜单
authUserInfoOutput.Menus = await _permissionRepository.Select
.Where(a => new[] { PermissionType.Group, PermissionType.Menu }.Contains(a.Type))
.Where(a =>
_permissionRepository.Orm.Select <RolePermissionEntity>()
.InnerJoin <UserRoleEntity>((b, c) => b.RoleId == c.RoleId && c.UserId == User.Id)
.Where(b => b.PermissionId == a.Id)
.Any()
)
.OrderBy(a => a.ParentId)
.OrderBy(a => a.Sort)
.ToListAsync(a => new AuthUserMenuDto {
ViewPath = a.View.Path
});
//用户权限点
authUserInfoOutput.Permissions = await _permissionRepository.Select
.Where(a => new[] { PermissionType.Api, PermissionType.Dot }.Contains(a.Type))
.Where(a =>
_permissionRepository.Orm.Select <RolePermissionEntity>()
.InnerJoin <UserRoleEntity>((b, c) => b.RoleId == c.RoleId && c.UserId == User.Id)
.Where(b => b.PermissionId == a.Id)
.Any()
)
.ToListAsync(a => a.Code);
return(authUserInfoOutput);
});
return(ResponseOutput.Ok(output));
}
/// <summary>
/// 获得token
/// </summary>
/// <param name="output"></param>
/// <returns></returns>
private IResponseOutput GetToken(ResponseOutput<AuthLoginOutput> output)
{
if (!output.Success)
{
return ResponseOutput.NotOk(output.Msg);
}
var user = output.Data;
var token = _userToken.Build(new[]
{
new Claim(ClaimAttributes.UserId, user.Id.ToString()),
new Claim(ClaimAttributes.UserName, user.UserName),
new Claim(ClaimAttributes.UserNickName, user.NickName)
});
return ResponseOutput.Ok(new { token });
}
public override void OnResultExecuting(ResultExecutingContext context)
{
if (!context.ModelState.IsValid)
{
try
{
var logger = (ILogger <ValidateInputAttribute>)context.HttpContext.RequestServices.GetService(typeof(ILogger <ValidateInputAttribute>));
var errorMessages = context.ModelState.Values.First().Errors.Select(a => a.ErrorMessage);
logger.LogError(string.Join(",", errorMessages));
context.Result = new JsonResult(ResponseOutput.NotOk(errorMessages.First()));
}
catch
{
context.Result = new StatusCodeResult(StatusCodes.Status500InternalServerError);
}
}
}
public async Task <IResponseOutput> Login(AuthLoginInput input)
{
var sw = new Stopwatch();
sw.Start();
var res = (await _authService.LoginAsync(input)) as IResponseOutput;
sw.Stop();
#region 添加登录日志
var loginLogAddInput = new LoginLogAddInput()
{
CreatedUserName = input.UserName,
ElapsedMilliseconds = sw.ElapsedMilliseconds,
Status = res.Success,
Msg = res.Msg
};
AuthLoginOutput user = null;
if (res.Success)
{
user = (res as IResponseOutput <AuthLoginOutput>).Data;
loginLogAddInput.CreatedUserId = user.Id;
loginLogAddInput.RealName = user.Name;
}
await _loginLogService.AddAsync(loginLogAddInput);
#endregion
if (!res.Success)
{
return(res);
}
#region 生成token信息
var token = _userToken.Build(new[]
{
new Claim(ClaimAttributes.UserId, user.Id.ToString()),
new Claim(ClaimAttributes.UserName, user.UserName),
new Claim(ClaimAttributes.UserRealName, user.Name)
});
#endregion
return(ResponseOutput.Ok(new { token }));
}
private Payment UpdatePaymentFromResponse(ResponseOutput response)
{
var payment = _context.Payment.Where(x => x.TxnId == response.TxnId).First();
payment.Success = int.Parse(response.Success);
//payment.TxnId = response.TxnId;
payment.ClientInfo = response.ClientInfo;
payment.ResponseText = response.ResponseText;
payment.AmountSettlemen = response.AmountSettlement;
payment.cardName = response.CardName;
payment.cardNumber = response.CardNumber;
payment.dateExpiry = response.DateExpiry;
payment.cardHolderName = response.CardHolderName;
payment.currencySettlement = response.CurrencySettlement;
payment.currencyInput = response.CurrencyInput;
payment.txnMac = response.TxnMac;
return(payment);
}
public async Task<IResponseOutput> PageAsync(PageInput<UserEntity> input)
{
var list = await _userRepository.Select
.WhereDynamicFilter(input.DynamicFilter)
.Count(out var total)
.OrderByDescending(true, a => a.Id)
.IncludeMany(a => a.Roles.Select(b => new RoleEntity{ Name = b.Name }))
.Page(input.CurrentPage, input.PageSize)
.ToListAsync();
var data = new PageOutput<UserListOutput>()
{
List = _mapper.Map<List<UserListOutput>>(list),
Total = total
};
return ResponseOutput.Ok(data);
}
public void OnException(ExceptionContext context)
{
string message;
if (_env.IsProduction())
{
message = Enums.StatusCodes.Status500InternalServerError.ToDescription();
}
else
{
message = context.Exception.Message;
}
_logger.LogError(context.Exception, "");
var data = ResponseOutput.NotOk(message);
context.Result = new InternalServerErrorResult(data);
}
public async Task <IResponseOutput> ListAsync(string key, DateTime?start, DateTime?end)
{
if (end.HasValue)
{
end = end.Value.AddDays(1);
}
var data = await _permissionRepository
.WhereIf(key.NotNull(), a => a.Path.Contains(key) || a.Label.Contains(key))
.WhereIf(start.HasValue && end.HasValue, a => a.CreatedTime.Value.BetweenEnd(start.Value, end.Value))
.OrderBy(a => a.ParentId)
.OrderBy(a => a.Sort)
.ToListAsync(a => new PermissionListOutput {
ApiPath = a.Api.Path
});
return(ResponseOutput.Ok(data));
}
public async Task <IResponseOutput> GetUserInfoAsync()
{
if (string.IsNullOrEmpty(User?.Id))
{
return(ResponseOutput.NotOk("未登录！"));
}
//用户信息
var user = await _userRepo.FindByIdAsync(User.Id);
var rolePerList = _rolePermissionRepo.Query.Where(c => c.RoleId == user.RoleId);
var rolePerIds = rolePerList.Select(x => x.PermissionId);
//用户菜单
var menus = await _permissionRepo.Query
.Where(a => new[] { PermissionType.Group, PermissionType.Menu }.Contains(a.Type))
.Where(a => rolePerIds.Contains(a.Id)
)
.OrderBy(a => a.ParentId)
.OrderBy(a => a.Sort)
.Select(a => new
{
a.Id,
a.ParentId,
a.Path,
ViewPath = a.ViewPath,
a.Label,
a.Icon,
a.Opened,
a.Closable,
a.Hidden,
a.NewWindow,
a.External
}).ToListAsync();
//用户权限点
var permissions = await _permissionRepo.Query
.Where(a => new[] { PermissionType.Api, PermissionType.Dot }.Contains(a.Type))
.Where(a => rolePerIds.Contains(a.Id)
)
.Select(a => a.Code).ToListAsync();
return(ResponseOutput.Ok(new { user, menus, permissions }));
}
public async Task <IResponseOutput> GetVerifyCodeAsync(string lastKey)
{
var img = VerifyCodeHelper.GetBase64String(out string code);
//删除上次缓存的验证码
if (lastKey.NotNull())
{
await _cache.DelAsync(lastKey);
}
//写入Redis
var guid = Guid.NewGuid().ToString("N");
var key = string.Format(CacheKey.VerifyCodeKey, guid);
await _cache.SetAsync(key, code, TimeSpan.FromMinutes(5));
var data = new { key = guid, img };
return(ResponseOutput.Ok(data));
}
public ResponseOutput AddQuestion(ICollection <QuestionViewModel> qtions)
{
if (qtions == null || qtions.Count == 0)
{
return(new ResponseOutput
{
Success = false,
Message = "Object null"
});
}
var response = new ResponseOutput();
try
{
var questions = new List <Qtions>();
foreach (var qtion in qtions)
{
var temp = new Qtions
{
Id = 0,
ContentQ = qtion.ContentQ,
Answer1 = qtion.Answer1,
Answer2 = qtion.Answer2,
Answer3 = qtion.Answer3,
Answer4 = qtion.Answer4,
Part = qtion.Part,
TopicId = qtion.TopicId
};
questions.Add(temp);
}
_repository.InsertRange(questions);
UnitOfWork.SaveChanges();
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <IResponseOutput> DeleteAsync(long id)
{
//删除角色权限
await _rolePermissionRepository.Where(a => a.Role.TenantId == id).DisableGlobalFilter("Tenant").ToDelete().ExecuteAffrowsAsync();
//删除用户角色
await _userRoleRepository.Where(a => a.User.TenantId == id).DisableGlobalFilter("Tenant").ToDelete().ExecuteAffrowsAsync();
//删除用户
await _userRepository.Where(a => a.TenantId == id).DisableGlobalFilter("Tenant").ToDelete().ExecuteAffrowsAsync();
//删除角色
await _roleRepository.Where(a => a.TenantId == id).DisableGlobalFilter("Tenant").ToDelete().ExecuteAffrowsAsync();
//删除租户
await _tenantRepository.DeleteAsync(id);
return(ResponseOutput.Ok());
}
public async Task <IResponseOutput> UpdateAsync(DictionaryUpdateInput input)
{
if (!(input?.Id > 0))
{
return(ResponseOutput.NotOk());
}
var entity = await _dictionaryRepository.GetAsync(input.Id);
if (!(entity?.Id > 0))
{
return(ResponseOutput.NotOk("Êý¾Ý×ֵ䲻´æÔÚ£¡"));
}
_mapper.Map(input, entity);
await _dictionaryRepository.UpdateAsync(entity);
return(ResponseOutput.Ok());
}
public async Task <IResponseOutput> UpdateAsync(string id, UserUpdateInput input)
{
if (string.IsNullOrEmpty(id))
{
return(ResponseOutput.NotOk());
}
var user = await _userRepo.FindByIdAsync(id);
if (string.IsNullOrWhiteSpace(id))
{
return(ResponseOutput.NotOk("用户不存在！"));
}
_mapper.Map(input, user);
await _userRepo.UpdateAsync(user);
return(ResponseOutput.Ok());
}
public async Task <IResponseOutput> AssignAsync(PermissionAssignInput input)
{
//分配权限的时候判断角色是否存在
var exists = await _roleRepository.Select.WhereDynamic(input.RoleId).AnyAsync();
if (!exists)
{
return(ResponseOutput.NotOk("该角色不存在或已被删除，请刷新角色列表"));
}
//查询角色权限
var permissionIds = await _rolePermissionRepository.Select.Where(d => d.RoleId == input.RoleId).ToListAsync(m => m.PermissionId);
//批量删除权限
var deleteIds = permissionIds.Where(d => !input.PermissionIds.Contains(d));
if (deleteIds.Count() > 0)
{
await _rolePermissionRepository.DeleteAsync(m => m.RoleId == input.RoleId && deleteIds.Contains(m.PermissionId));
}
//批量插入权限
var insertRolePermissions = new List <RolePermissionEntity>();
var insertPermissionIds = input.PermissionIds.Where(d => !permissionIds.Contains(d));
if (insertPermissionIds.Count() > 0)
{
foreach (var permissionId in insertPermissionIds)
{
insertRolePermissions.Add(new RolePermissionEntity()
{
RoleId = input.RoleId,
PermissionId = permissionId,
});
}
await _rolePermissionRepository.InsertAsync(insertRolePermissions);
}
//清除权限
await _cache.DelByPatternAsync(CacheKey.UserPermissions);
return(ResponseOutput.Ok());
}
public async Task <IResponseOutput> PageAsync(PageInput <OprationLogEntity> input)
{
var userName = input.Filter?.CreatedUserName;
var list = await _oprationLogRepository.Select
.WhereIf(userName.NotNull(), a => a.CreatedUserName.Contains(userName))
.Count(out var total)
.OrderByDescending(true, c => c.Id)
.Page(input.CurrentPage, input.PageSize)
.ToListAsync <OprationLogListOutput>();
var data = new PageOutput <OprationLogListOutput>()
{
List = list,
Total = total
};
return(ResponseOutput.Ok(data));
}
/// <summary>
/// 更新角色
/// </summary>
/// <param name="id"></param>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <IResponseOutput> UpdateRoleAsync(string id, RoleSaveDto dto)
{
if (string.IsNullOrEmpty(id))
{
return(ResponseOutput.NotOk("无数据"));
}
var data = await _roleRepo.FindByIdAsync(id);
if (string.IsNullOrWhiteSpace(id))
{
return(ResponseOutput.NotOk("用户不存在！"));
}
ObjectMapper.Map(dto, data);
await _roleRepo.UpdateAsync(data);
return(ResponseOutput.Ok());
}
public async Task <IResponseOutput> PageAsync(PageInput <LoginLogEntity> input)
{
var userName = input.Filter?.CreatedUserName;
var list = _loginLogRepository.Query
.Where(a => a.CreatedUserName.Contains(userName))
.OrderByDescending(c => c.Id)
.Skip((input.CurrentPage.GetValueOrDefault() - 1) * input.PageSize.GetValueOrDefault()).Take(input.PageSize.GetValueOrDefault());
var data = new PageOutput <LoginLogListOutput>()
{
List = ObjectMapper.MapList <LoginLogEntity, LoginLogListOutput>(list.ToList()), //list.ToList().MapTo<List<LoginLogEntity>, List<LoginLogListOutput>>(),
Total = list.Count()
};
return(ResponseOutput.Ok(data));
}
public async Task <IResponseOutput> UpdateAsync(TenantUpdateInput input)
{
if (!(input?.Id > 0))
{
return(ResponseOutput.NotOk());
}
var entity = await _tenantRepository.GetAsync(input.Id);
if (!(entity?.Id > 0))
{
return(ResponseOutput.NotOk("租户不存在！"));
}
Mapper.Map(input, entity);
await _tenantRepository.UpdateAsync(entity);
return(ResponseOutput.Ok());
}
public async Task <IResponseOutput> PageAsync(PageInput <RoleEntity> input)
{
var key = input.Filter?.Name;
var list = await _roleRepository.Select
.WhereIf(key.NotNull(), a => a.Name.Contains(key))
.Count(out var total)
.OrderByDescending(true, c => c.Id)
.Page(input.CurrentPage, input.PageSize)
.ToListAsync <RoleListOutput>();
var data = new PageOutput <RoleListOutput>()
{
List = list,
Total = total
};
return(ResponseOutput.Ok(data));
}
public async Task <IResponseOutput> GetUserInfoAsync()
{
if (!(_user?.Id > 0))
{
return(ResponseOutput.NotOk("未登录！"));
}
var user = await _userRepository.Select.WhereDynamic(_user.Id)
.ToOneAsync(m => new {
m.NickName,
m.UserName,
m.Avatar
});
//获取菜单
var menus = await _permissionRepository.Select
.Where(a => new[] { PermissionType.Group, PermissionType.Menu }.Contains(a.Type))
.Where(a =>
_rolePermissionRepository.Select
.InnerJoin <UserRoleEntity>((b, c) => b.RoleId == c.RoleId && c.UserId == _user.Id)
.Where(b => b.PermissionId == a.Id)
.Any()
)
.OrderBy(a => a.ParentId)
.OrderBy(a => a.Sort)
.ToListAsync(a => new
{
a.Id,
a.ParentId,
a.Path,
ViewPath = a.View.Path,
a.Label,
a.Icon,
a.Opened,
a.Closable,
a.Hidden,
a.NewWindow,
a.External
});
return(ResponseOutput.Ok(new { user, menus }));
}
public async Task <IResponseOutput> UpdateAsync(RoleUpdateInput input)
{
if (!(input?.Id > 0))
{
return(ResponseOutput.NotOk());
}
var entity = await _roleRepository.GetAsync(input.Id);
if (!(entity?.Id > 0))
{
return(ResponseOutput.NotOk("½ÇÉ«²»´æÔÚ£¡"));
}
_mapper.Map(input, entity);
await _roleRepository.UpdateAsync(entity);
return(ResponseOutput.Ok());
}
/// <summary>
/// 上传单文件
/// </summary>
/// <param name="file"></param>
/// <param name="config"></param>
/// <param name="args"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <IResponseOutput <FileInfo> > UploadAsync(IFormFile file, FileUploadConfig config, object args, CancellationToken cancellationToken = default)
{
var res = new ResponseOutput <FileInfo>();
if (file == null || file.Length < 1)
{
return(res.NotOk("请上传文件！"));
}
//格式限制
if (!config.ContentType.Contains(file.ContentType))
{
return(res.NotOk("文件格式错误"));
}
//大小限制
if (!(file.Length <= config.MaxSize))
{
return(res.NotOk("文件过大"));
}
var fileInfo = new FileInfo(file.FileName, file.Length)
{
UploadPath = config.UploadPath,
RequestPath = config.RequestPath
};
var dateTimeFormat = config.DateTimeFormat.NotNull() ? DateTime.Now.ToString(config.DateTimeFormat) : "";
var format = config.Format.NotNull() ? StringHelper.Format(config.Format, args) : "";
fileInfo.RelativePath = Path.Combine(dateTimeFormat, format).ToPath();
if (!Directory.Exists(fileInfo.FileDirectory))
{
Directory.CreateDirectory(fileInfo.FileDirectory);
}
fileInfo.SaveName = $"{IdWorkerHelper.GenId64()}.{fileInfo.Extension}";
await SaveAsync(file, fileInfo.FilePath, cancellationToken);
return(res.Ok(fileInfo));
}
