public async Task <IResponseOutput> GetPassWordEncryptKeyAsync()
{
//写入Redis
var guid = Guid.NewGuid().ToString("N");
var key = string.Format(CacheKey.PassWordEncryptKey, guid);
var encyptKey = StringHelper.GenerateRandom(8);
await _cache.SetAsync(key, encyptKey, TimeSpan.FromMinutes(5));
var data = new { key = guid, encyptKey };
return(ResponseOutput.Ok(data));
}
public async Task <IResponseOutput> UploadAvatarAsync([FromServices] ICurrentUser _user, [FromServices] UploadHelper _uploadHelper, [FromForm] IFormFile file)
{
var config = Configs.UploadConfig.Avatar;
var res = await _uploadHelper.UploadAsync(file, config, new { _user.Id });
if (res.Success)
{
return(ResponseOutput.Ok(res.Data.FileRelativePath));
}
return(ResponseOutput.NotOk("上传失败！"));
}
async public Task <IResponseOutput> Create([FromBody] UserCreateRequestDto requestDto)
{
Department department = await _fsql.Select <Department>().Where(d => d.Id == requestDto.DepartmentId).FirstAsync();
if (department == null)
{
throw new ArgumentException("无该部门");
}
/* Role role = await _fsql.Select<Role>().Where(r => r.Id == requestDto.RoleId).FirstAsync();
* if (role == null)
* {
* throw new ArgumentException("无该职位");
* }*/
if (await _fsql.Select <User>().Where(u => u.UserName == requestDto.UserName).CountAsync() > 0)
{
throw new ArgumentException($"用户{requestDto.UserName}已经存在");
}
using (var uow = _fsql.CreateUnitOfWork()) //使用 UnitOfWork 事务
{
User user = _mapper.Map <User>(requestDto);
user.CreatedAt = DateTime.Now;
var ret = await _fsql.Insert(user).WithTransaction(uow.GetOrBeginTransaction()).ExecuteInsertedAsync();
user = ret.FirstOrDefault();
/* var userRole = await _fsql.Insert(new UserRole { UserId = user.Id, RoleId = role.Id, CreatedAt = DateTime.Now })
* .WithTransaction(uow.GetOrBeginTransaction()).ExecuteInsertedAsync();*/
if (!(user?.Id > 0))
{
return(ResponseOutput.NotOk());
}
if (requestDto.RoleIds != null && requestDto.RoleIds.Any())
{
var userRoles = requestDto.RoleIds.Select(r => new UserRole {
UserId = user.Id, RoleId = r
});
var userRolesRet = await _fsql.Insert(userRoles).WithTransaction(uow.GetOrBeginTransaction()).ExecuteInsertedAsync();
}
var responseDto = _mapper.Map <UserResponseDto>(user);
uow.Commit();
/* responseDto.RoleId = role.Id;
* responseDto.RoleName = role.Name;*/
responseDto.DepartmentName = department.Name;
return(ResponseOutput.Ok(responseDto));
}
}
public async Task <IResponseOutput> List([FromQuery] string name, int parentId, int page = 1, int size = 30)
{
var departmentList = await _fsql.Select <Department>()
.WhereIf(parentId != 0, d => d.ParentId == parentId)
.WhereIf(name != null, d => d.Name.Contains(name))
.Count(out var total)
.Page(page, size)
.ToListAsync();
return(ResponseOutput.Ok(new Pagenation <Department> {
Total = total, List = departmentList, Page = page, Size = size
}));
}
async public Task <IResponseOutput> Create([FromBody] ProcedureCreateRequestDto requestDto)
{
var workType = await _fsql.Select <WorkType>().Where(w => w.Id == requestDto.WorkTypeId).FirstAsync();
if (workType == null)
{
return(ResponseOutput.NotOk($"worktype with id(${requestDto.WorkTypeId}) does not exsit"));
}
var ret = await _fsql.Insert(_mapper.Map <Procedure>(requestDto)).ExecuteInsertedAsync();
return(ResponseOutput.Ok(ret.FirstOrDefault()));
}
public async Task <IResponseOutput> UpdateApiAsync(PermissionUpdateApiInput input)
{
if (!string.IsNullOrWhiteSpace(input.Id))
{
var entity = await _permissionRepo.FindByIdAsync(input.Id);
entity = ObjectMapper.Map(input, entity);
await _permissionRepo.UpdateAsync(entity);
return(ResponseOutput.Ok());
}
return(ResponseOutput.NotOk());
}
public async Task <IResponseOutput> List([FromQuery] string key, [FromQuery] int page = 1, [FromQuery] int size = 20)
{
var list = await _fsql.Select <User>().IncludeMany(u => u.Roles)
.Include(a => a.Department)
.WhereIf(!string.IsNullOrEmpty(key), (u) => u.UserName.Contains(key))
.Page(page, size)
.Count(out var total)
.ToListAsync();
return(ResponseOutput.Ok(new Pagenation <User> {
Page = page, Size = size, Total = total, List = list
}));
}
public async Task <ResponseOutput <AuthLoginOutput> > GetLoginUserAsync(long id)
{
var output = new ResponseOutput <AuthLoginOutput>();
var entityDto = await _userRepository.Select.DisableGlobalFilter("Tenant").WhereDynamic(id).ToOneAsync <AuthLoginOutput>();
if (_appConfig.Tenant)
{
var tenant = await _tenantRepository.Select.DisableGlobalFilter("Tenant").WhereDynamic(entityDto.TenantId).ToOneAsync(a => new { a.TenantType, a.DataIsolationType });
output.Data.TenantType = tenant.TenantType;
output.Data.DataIsolationType = tenant.DataIsolationType;
}
return(output.Ok(entityDto));
}
public async Task <IResponseOutput> AddAsync(UserSaveInput input)
{
if (input.Password.IsNull())
{
input.Password = "******";
}
input.Password = MD5Encrypt.Encrypt32(input.Password);
var entity = _mapper.Map <UserEntity>(input);
entity.CreatedTime = DateTime.Now;
await _userRepo.InsertAsync(entity);
return(ResponseOutput.Ok());
}
async public Task <IResponseOutput> Delete([FromRoute] int id)
{
using (var uow = _fsql.CreateUnitOfWork()) //使用 UnitOfWork 事务
{
//删除用户角色关系
await _fsql.Delete <UserRole>().Where(ur => ur.RoleId == id).ExecuteDeletedAsync();
//删除角色关系
var ret = await _fsql.Delete <Role>().Where(a => a.Id == id).ExecuteDeletedAsync();
uow.Commit();
return(ResponseOutput.Ok(_mapper.Map <RoleResponseDto>(ret.FirstOrDefault())));
}
}
async public Task <IResponseOutput> Create([FromBody] ManuOrderFeedbackCreateRequestDto requestDto)
{
//检查工序, 其他大类等
//检查用户是否存在
var user = await _fsql.Select <User>().Where(u => u.Id == requestDto.UserId).FirstAsync();
if (user == null)
{
return(ResponseOutput.NotOk("用户不存在"));
}
//检查工作类型
var workType = await _fsql.Select <WorkType>().Where(w => w.Id == requestDto.WorkTypeId).FirstAsync();
if (workType == null)
{
return(ResponseOutput.NotOk("工作类型不存在"));
}
//工作类型
if (requestDto.ProcedureId != 0)
{
var procedure = await _fsql.Select <Procedure>().Where(p => p.Id == requestDto.ProcedureId).FirstAsync();
if (procedure == null)
{
return(ResponseOutput.NotOk("工序不存在"));
}
}
//检查线材类型
if (requestDto.WireRodTypeId != 0)
{
var wireRodType = await _fsql.Select <WireRodType>().Where(w => w.Id == requestDto.WireRodTypeId).FirstAsync();
if (wireRodType == null)
{
return(ResponseOutput.NotOk("线材类型不存在"));
}
}
var feedBack = _mapper.Map <ManuOrderFeedback>(requestDto);
feedBack.StartAt = DateTime.Now;
feedBack.Status = 1;
var ret = await _fsql.Insert(feedBack).ExecuteInsertedAsync();
return(ResponseOutput.Ok(ret.FirstOrDefault()));
}
public async Task <IResponseOutput> AvatarUpload([FromServices] IWebHostEnvironment environment, IFormFile file)
{
if (file == null || file.Length < 1)
{
if (Request.Form.Files != null && Request.Form.Files.Any())
{
file = Request.Form.Files[0];
}
}
if (file == null || file.Length < 1)
{
return(ResponseOutput.NotOk("请上传头像！"));
}
var avatar = _uploadConfig.Avatar;
//格式限制
if (!avatar.ContentType.Contains(file.ContentType))
{
return(ResponseOutput.NotOk("图片格式错误"));
}
//大小限制
if (!(file.Length <= avatar.Size))
{
return(ResponseOutput.NotOk("图片过大"));
}
var dateTimeFormat = avatar.DateTimeFormat.NotNull() ? DateTime.Now.ToString(avatar.DateTimeFormat) : "";
var format = avatar.Format.NotNull() ? string.Format(avatar.Format, _user.Id) : "";
var savePath = Path.Combine(dateTimeFormat, format);
var fullDirectory = Path.Combine(avatar.Path, savePath);
if (!Directory.Exists(fullDirectory))
{
Directory.CreateDirectory(fullDirectory);
}
var saveFileName = $"{new Snowfake(0).nextId()}{Path.GetExtension(file.FileName)}";
var fullPath = Path.Combine(fullDirectory, saveFileName);
using (var stream = new FileStream(fullPath, FileMode.Create))
{
await file.CopyToAsync(stream);
}
return(ResponseOutput.Ok(Path.Combine(savePath, saveFileName)));
}
public async Task <ResponseOutput <UserGetOutput> > GetAsync(long id)
{
var res = new ResponseOutput <UserGetOutput>();
var entity = await _userRepository.Select
.WhereDynamic(id)
.IncludeMany(a => a.Roles.Select(b => new RoleEntity {
Id = b.Id
}))
.ToOneAsync();
var entityDto = _mapper.Map <UserGetOutput>(entity);
return(res.Ok(entityDto));
}
async public Task <IResponseOutput> List([FromQuery] int page, int size)
{
var list = await _fsql.Select <ExceptionType>()
.Count(out var total)
.Page(page, size)
.ToListAsync();
return(ResponseOutput.Ok(new Pagenation <ExceptionType>
{
Page = page,
Total = total,
Size = size,
List = list,
}));
}
async public Task <IResponseOutput> List([FromQuery] int workTypeId, int page, int size)
{
var list = await _fsql.Select <Procedure>()
.WhereIf(workTypeId != 0, p => p.WorkTypeId == workTypeId)
.Count(out var total)
.Page(page, size)
.ToListAsync();
return(ResponseOutput.Ok(new Pagenation <Procedure> {
Page = page,
Total = total,
Size = size,
List = list,
}));
}
/// <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> GetById([FromRoute] int id)
{
WorkType workType = await _fsql.Select <WorkType>()
.Where(w => w.Id == id)
.IncludeMany(w => w.Childs)
.Include(w => w.Parent)
//.AsTreeCte()
.FirstAsync();
if (workType == null)
{
return(ResponseOutput.NotOk($"未找到ID为{id}的工作类型"));
}
return(ResponseOutput.Ok(_mapper.Map <WorkTypeResponseDto>(workType)));
}
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"));
}
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));
}
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> 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 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 }));
}
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 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> 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 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> 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());
}
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> 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));
}