public async Task <IResponseOutput> Ip2RegionAsync(string ip)
{
if (ip.IsNullOrEmpty())
{
ip = _httpContextAccessor.HttpContext.Request.Headers["X-Real-IP"].FirstOrDefault() ??
_httpContextAccessor.HttpContext.Request.Headers["X-Forwarded-For"].FirstOrDefault() ??
_httpContextAccessor.HttpContext.Connection.RemoteIpAddress.MapToIPv4().ToString();
}
else
{
if (!ip.IsIp())
{
return(ResponseOutput.NotOk("The ip address error."));
}
}
var path = Path.Combine(Directory.GetCurrentDirectory(), "Resources/ip2region.db");
using var _search = new DbSearcher(path);
var block = await _search.BinarySearchAsync(ip);
var region = block.Region.Split("|").Distinct().Where(x => x != "0").ToList();
region.AddFirst(ip);
return(ResponseOutput.Ok(region));
}
public async Task <IResponseOutput> UpdateAsync(UserUpdateInput input)
{
if (!(input?.Id > 0))
{
return(ResponseOutput.NotOk());
}
var user = await _userRepository.GetAsync(input.Id);
if (!(user?.Id > 0))
{
return(ResponseOutput.NotOk("用户不存在！"));
}
_mapper.Map(input, user);
await _userRepository.UpdateAsync(user);
await _userRoleRepository.DeleteAsync(a => a.UserId == user.Id);
if (input.RoleIds != null && input.RoleIds.Any())
{
var roles = input.RoleIds.Select(a => new UserRoleEntity {
UserId = user.Id, RoleId = a
});
await _userRoleRepository.InsertAsync(roles);
}
return(ResponseOutput.Ok());
}
public async Task <IResponseOutput> Refresh([BindRequired] string token)
{
var userClaims = _userToken.Decode(token);
if (userClaims == null || userClaims.Length == 0)
{
return(ResponseOutput.NotOk());
}
var refreshExpires = userClaims.FirstOrDefault(a => a.Type == ClaimAttributes.RefreshExpires)?.Value;
if (refreshExpires.IsNull())
{
return(ResponseOutput.NotOk());
}
if (refreshExpires.ToLong() <= DateTime.Now.ToTimestamp())
{
return(ResponseOutput.NotOk("登录信息已过期"));
}
var userId = userClaims.FirstOrDefault(a => a.Type == ClaimAttributes.UserId)?.Value;
if (userId.IsNull())
{
return(ResponseOutput.NotOk());
}
var output = await _userServices.GetLoginUserAsync(userId.ToLong());
return(GetToken(output));
}
public async Task <IResponseOutput> UpdateAsync(UserUpdateInput input)
{
if (!(input?.Id > 0))
{
return(ResponseOutput.NotOk());
}
var entity = await _userRepository.GetAsync(input.Id);
if (!(entity?.Id > 0))
{
return(ResponseOutput.NotOk("用户不存在！"));
}
_mapper.Map(input, entity);
await _userRepository.UpdateAsync(entity);
await _userRoleRepository.Where(m => m.UserId == entity.Id).ToDelete().ExecuteAffrowsAsync();
if (input.RoleIds != null && input.RoleIds.Any())
{
var roles = input.RoleIds.Select(d => new UserRoleEntity(entity.Id, d));
await _userRoleRepository.InsertAsync(roles);
}
return(ResponseOutput.Ok());
}
public void OnException(ExceptionContext context)
{
var message = context.Exception.Message;
//if (context.Exception.GetType() == typeof(DiyException))
//{
// //如果是自定义异常\
//}
//日志入库
//向负责人发报警邮件，异步
//向负责人发送报警短信或者报警电话，异步
//这里获取服务器ip时，需要考虑如果是使用nginx做了负载，这里要兼容负载后的ip，
//监控了ip方便定位到底是那台服务器出故障了
//string ip = context.HttpContext.Connection.RemoteIpAddress.ToString();
//message = $"IP:{ip}{message}";
_logger.LogError(context.Exception, message);
message += $"|{context.Exception.StackTrace}";
context.Result = new InternalServerErrorResult(ResponseOutput.NotOk(message));
if (_env.IsProduction())
{
//context.Result = new InternalServerErrorResult(new ResultData { Msg = message, Code = 0 });
//标记异常已处理
context.ExceptionHandled = true;
}
}
/// <summary>
/// 暂停/删除 指定的计划
/// </summary>
/// <param name="jobGroup">任务分组</param>
/// <param name="jobName">任务名称</param>
/// <param name="isDelete">停止并删除任务</param>
/// <returns></returns>
public async Task <IResponseOutput> StopOrDelScheduleJobAsync(string jobGroup, string jobName, bool isDelete = false)
{
IResponseOutput result;
try
{
await scheduler.PauseJob(new JobKey(jobName, jobGroup));
if (isDelete)
{
await scheduler.DeleteJob(new JobKey(jobName, jobGroup));
result = ResponseOutput.Ok("删除任务计划成功！");
}
else
{
result = ResponseOutput.Ok("停止任务计划成功！");
}
}
catch (Exception ex)
{
result = ResponseOutput.NotOk("停止任务计划失败！");
}
return(result);
}
async public Task <IResponseOutput> Finish([FromRoute] int id, [FromBody] ManuOrderFeedbackFinishUpdateDto updateDto)
{
var feedback = await _fsql.Select <ManuOrderFeedback>().Where(m => m.Id == id).FirstAsync();
if (feedback == null)
{
return(ResponseOutput.NotOk("报工单不存在"));
}
//检查异常类型
if (updateDto.ExceptionTypeId != 0)
{
var exceptionType = await _fsql.Select <ExceptionType>().Where(e => e.Id == updateDto.ExceptionTypeId).FirstAsync();
if (exceptionType == null)
{
return(ResponseOutput.NotOk("异常类型不存在"));
}
}
_mapper.Map(updateDto, feedback);
feedback.Status = 2;
var ret = await _fsql.Update <ManuOrderFeedback>().SetSource(feedback).ExecuteUpdatedAsync();
return(ResponseOutput.Ok(ret.FirstOrDefault()));
}
public async Task <IResponseOutput> AddAsync(UserAddInput input)
{
if (input.Password.IsNull())
{
input.Password = "******";
}
input.Password = MD5Encrypt.Encrypt32(input.Password);
var entity = _mapper.Map <UserEntity>(input);
var user = await _userRepository.InsertAsync(entity);
if (!(user?.Id > 0))
{
return(ResponseOutput.NotOk());
}
if (input.RoleIds != null && input.RoleIds.Any())
{
var roles = input.RoleIds.Select(d => new UserRoleEntity(user.Id, d));
await _userRoleRepository.InsertAsync(roles);
}
return(ResponseOutput.Ok());
}
public async Task <IResponseOutput> Upload([FromServices] IWebHostEnvironment environment)
{
string path = string.Empty;
string foldername = "images";
IFormFileCollection files = null;
try
{
files = Request.Form.Files;
}
catch (Exception)
{
files = null;
}
if (files == null || !files.Any())
{
return(ResponseOutput.NotOk("请选择上传的文件。"));
}
//格式限制
var allowType = new string[] { "image/jpg", "image/png", "image/jpeg" };
string folderpath = Path.Combine(environment.WebRootPath, foldername);
if (!Directory.Exists(folderpath))
{
Directory.CreateDirectory(folderpath);
}
if (files.Any(c => allowType.Contains(c.ContentType)))
{
if (files.Sum(c => c.Length) <= 1024 * 1024 * 4)
{
//foreach (var file in files)
var file = files.FirstOrDefault();
string strpath = Path.Combine(foldername, DateTime.Now.ToString("MMddHHmmss") + file.FileName);
path = Path.Combine(environment.WebRootPath, strpath);
using (var stream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
await file.CopyToAsync(stream);
}
return(ResponseOutput.Ok(strpath));
}
else
{
return(ResponseOutput.NotOk("图片过大"));
}
}
else
{
return(ResponseOutput.NotOk("图片格式错误"));
}
}
/// <summary>
/// 获取个人信息
/// </summary>
/// <returns></returns>
public async Task <IResponseOutput> GetBasicAsync()
{
if (string.IsNullOrWhiteSpace(_user?.Id))
{
return(ResponseOutput.NotOk("未登录！"));
}
var data = await _userRepo.FindByIdAsync(_user.Id);
return(ResponseOutput.Ok(data));
}
public async Task<IResponseOutput> GetBasicAsync()
{
if (!(_user?.Id > 0))
{
return ResponseOutput.NotOk("未登录！");
}
var data = await _userRepository.GetAsync<UserUpdateBasicInput>(_user.Id);
return ResponseOutput.Ok(data);
}
/// <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));
}
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 =>
_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
{
a.Id,
a.ParentId,
a.Path,
ViewPath = a.View.Path,
a.Label,
a.Icon,
a.Opened,
a.Closable,
a.Hidden,
a.NewWindow,
a.External
});
//用户权限点
var 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(ResponseOutput.Ok(new { user, menus, permissions }));
}
public async Task <IResponseOutput> GetBasicAsync()
{
if (!(_user?.Id > 0))
{
return(ResponseOutput.NotOk("未登录！"));
}
var data = await _userRepository.Select.WhereDynamic(_user.Id).ToOneAsync <UserUpdateBasicInput>();
return(ResponseOutput.Ok(data));
}
public async Task <IResponseOutput> AvatarUpload([FromForm] IFormFile file)
{
var config = _uploadConfig.Avatar;
var res = await _uploadHelper.UploadAsync(file, config, new { _user.Id });
if (res.Success)
{
return(ResponseOutput.Ok(res.Data.FileRelativePath));
}
return(ResponseOutput.NotOk(res.Msg ?? "上传失败！"));
}
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("上传失败！"));
}
protected override async Task HandleForbiddenAsync(AuthenticationProperties properties)
{
Response.ContentType = "application/json";
Response.StatusCode = Microsoft.AspNetCore.Http.StatusCodes.Status403Forbidden;
await Response.WriteAsync(JsonConvert.SerializeObject(
ResponseOutput.NotOk(ResultCodes.Forbidden.ToDescription()),
new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}
));
}
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));
}
}
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 override void OnResultExecuting(ResultExecutingContext context)
{
if (!context.ModelState.IsValid)
{
try
{
context.Result = new JsonResult(ResponseOutput.NotOk(context.ModelState.Values.First().Errors[0].ErrorMessage));
}
catch
{
context.Result = new StatusCodeResult(StatusCodes.Status500InternalServerError);
}
}
}
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 <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)));
}
/// <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"));
}
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));
}
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);
}
}
}
/// <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 });
}