public (bool, string, SysUserDto) CheckLogin(SysUserDto dto)
{
var flag = true;
if (dto.IsNullT())
{
flag = false;
return(flag, PubConst.Login2, null);
}
var sys = _UserRepository.QueryableToEntity(c => c.UserNickname == dto.UserNickname && c.IsDel == 1);
if (sys.IsNullT())
{
flag = false;
return(flag, PubConst.Login4, null);
}
if (sys.IsEabled == 0)
{
flag = false;
return(flag, PubConst.Login3, null);
}
if (sys.Pwd != dto.Pwd.ToMd5())
{
flag = false;
return(flag, PubConst.Login2, null);
}
return(flag, PubConst.Login1, new SysUserDto
{
UserId = sys.UserId,
UserName = sys.UserName,
UserNickname = sys.UserNickname,
RoleId = sys.RoleId,
HeadImg = sys.HeadImg
});
}
public IActionResult EditSysUser([FromBody] SysUserDto sysUserDto)
{
try
{
var sysUserinfo = _context.SysUsers.Where(x => x.SysUserId == sysUserDto.SysUserId).FirstOrDefault();
sysUserinfo.Account = sysUserDto.Account;
sysUserinfo.Addr = sysUserDto.Addr;
sysUserinfo.Comments = sysUserDto.Comments;
sysUserinfo.Name = sysUserDto.Name;
sysUserinfo.Phone = sysUserDto.Phone;
sysUserinfo.Latitude = sysUserDto.Latitude;
sysUserinfo.Longitude = sysUserDto.Longitude;
sysUserinfo.Popenid = sysUserDto.Popenid;
sysUserinfo.Comment1 = sysUserDto.Comment1;
sysUserinfo.Price = sysUserDto.Price;
sysUserinfo.TemIdAccept = sysUserDto.TemIdAccept;
sysUserinfo.TemIdRefuse = sysUserDto.TemIdRefuse;
sysUserinfo.TemIdOrder = sysUserDto.TemIdOrder;
sysUserinfo.TemIdSend = sysUserDto.TemIdSend;
sysUserinfo.IsOpen = sysUserDto.IsOpen;
_context.SaveChanges();
return(Ok("修改成功"));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task <IActionResult> Login([FromBody] SysUserDto userDto)
{
var validateResult = await _accountService.ValidateCredentials(userDto.Account, userDto.Password);
if (!validateResult.Item1)
{
return(new NotFoundObjectResult("用户名或密码错误"));
}
var user = validateResult.Item2;
var claims = new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, user.Account),
new Claim(ClaimTypes.Name, user.Name),
new Claim(JwtRegisteredClaimNames.Email, user.Email),
new Claim(JwtRegisteredClaimNames.Sub, user.ID.ToString()),
new Claim(ClaimTypes.Role, user.RoleId)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtConfig.SymmetricSecurityKey));
var token = new JwtSecurityToken(
issuer: _jwtConfig.Issuer,
audience: null,
claims: claims,
notBefore: DateTime.Now,
expires: DateTime.Now.AddHours(2),
signingCredentials: new SigningCredentials(key, SecurityAlgorithms.HmacSha256)
);
var jwtToken = new JwtSecurityTokenHandler().WriteToken(token);
return(new JsonResult(new { token = jwtToken }));
}
protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, PermissionAuthorizationRequirement requirement)
{
if (context.User != null)
{
//从当前票据获取用户信息
var nameIdentifierClaim = context.User.FindFirst(ClaimTypes.NameIdentifier);
var id = nameIdentifierClaim.Value;
var userDto = new SysUserDto()
{
Id = Guid.Parse(id), LoginName = context.User.Identity.Name
};
//确认是否是管理员
if (context.User.Identity.Name.Equals("admin"))
{
context.Succeed(requirement);
}
else
{
//验证权限
var userFunctionList = await _sysLoginService.GetMenusAndFunctionByUserAsync(userDto);
var serCodeList = from function in userFunctionList select function.Code;
if (userFunctionList != null && userFunctionList.Any())
{
if (serCodeList.Contains(requirement.FunctionCode))
{
context.Succeed(requirement);
}
}
}
}
}
public IActionResult AppLogin([FromBody] SysUserDto sysUserDto)
{
try
{
var sysuserinfo = _context.SysUsers.Where(x => x.Account == sysUserDto.Account).FirstOrDefault();
if (sysuserinfo == null)
{
return(BadRequest("不存在此账号！"));
}
PwdTransition pwdTransition = new PwdTransition();
var Hashpwd = pwdTransition.ToHash(sysUserDto.Pwd, sysuserinfo.Salt);
if (sysuserinfo.Pwd != Hashpwd)
{
return(BadRequest("密码不正确！请重新输入"));
}
var token = Guid.NewGuid().ToString();
sysuserinfo.Token = token;
sysuserinfo.Ip = HttpContext.Connection.RemoteIpAddress.ToString();
_context.SaveChanges();
return(Ok(sysuserinfo));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
/// <summary>
/// 根据用户获取功能菜单并缓存
/// </summary>
/// <param name="userId">用户ID</param>
/// <returns></returns>
public async Task <List <SysMenuDto> > GetMenusAndFunctionByUserAsync(SysUserDto sysUserDto)
{
List <SysMenuDto> ret = new List <SysMenuDto>();
JsonSerializer jsonSerializer = new JsonSerializer();
var checheKey = SysConsts.MENU_CACHEKEY_PREFIX + sysUserDto.Id;
//缓存
if ((await _distributedCache.GetAsync(checheKey)) == null)
{
ret = await this.GetMenusAsync(sysUserDto);
//序列化好麻烦
var stringWriter = new StringWriter();
var jsonWriter = new JsonTextWriter(stringWriter);
jsonSerializer.Serialize(jsonWriter, ret);
await _distributedCache.SetStringAsync(checheKey, stringWriter.ToString(), new DistributedCacheEntryOptions()
{
SlidingExpiration = TimeSpan.FromMinutes(5)
});
}
else
{
var jsonString = await _distributedCache.GetStringAsync(checheKey);
var stringReader = new StringReader(jsonString);
var jsonTextReader = new JsonTextReader(stringReader);
ret = jsonSerializer.Deserialize <List <SysMenuDto> >(jsonTextReader);
}
return(ret);
}
public OperationResult Login(SysUserDto dto)
{
var users = from u in repository.Entities
where u.LoginName == dto.LoginName
//&& u.Available=="1"
select u;
if (users == null)
{
return(new OperationResult(OperationResultType.QueryNull, "该用户不存在"));
}
//MD5加密后的密码
string pwd = GetMD5(dto.Password);
var user = users.First();
if (pwd != user.Password)
{
return(new OperationResult(OperationResultType.QueryNull, "密码错误"));
}
new LoginLogService().InsertAsync(user);
return(new OperationResult(OperationResultType.Success));
}
public IActionResult Login([FromBody] SysUserDto sysUserDto)
{
try
{
var sysuserinfo = _context.SysUsers.Where(x => x.Account == sysUserDto.Account).FirstOrDefault();
if (sysuserinfo == null)
{
return(BadRequest("不存在此账号！"));
}
PwdTransition pwdTransition = new PwdTransition();
var Hashpwd = pwdTransition.ToHash(sysUserDto.Pwd, sysuserinfo.Salt);
if (sysuserinfo.Pwd != Hashpwd)
{
return(BadRequest("密码不正确！请重新输入"));
}
string validateNum = HttpContext.Session.GetString("Code_ValidateNum");
HttpContext.Session.Remove("Code_ValidateNum");
if (validateNum != sysUserDto.Code.ToUpper())
{
return(BadRequest("输入验证码有误!"));
}
var token = Guid.NewGuid().ToString();
sysuserinfo.Token = token;
sysuserinfo.Ip = HttpContext.Connection.RemoteIpAddress.ToString();
_context.SaveChanges();
var loginInfo = sysuserinfo.SysUserId + "&" + token;
return(Ok(loginInfo));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task Create(SysUserDto user)
{
var userContext = _mapper.Map <SysUserDto, SysUser>(user);
_repository.Create <SysUser>(userContext, userContext.CreatedBy);
await _repository.SaveAsync();
}
/// <summary>
/// 根据用户获取功能菜单
/// </summary>
/// <param name="sysUserDto"></param>
/// <returns></returns>
private async Task <List <SysMenuDto> > GetMenusAsync(SysUserDto sysUserDto)
{
//查询出系统所有菜单
List <SysMenuDto> result = new List <SysMenuDto>();
var allMenus = await _sysMenuRepository.GetAllListAsync();
allMenus = allMenus.OrderBy(it => it.SerialNumber).ToList();
if (sysUserDto.LoginName == _webAppOptions.AdminLoginName) //超级管理员
{
return(Mapper.Map <List <SysMenuDto> >(allMenus));
}
//查询当前用户角色
var userRoleIds = await _sysUserRepository.FindUserRoleAsync(sysUserDto.Id);
if (userRoleIds == null)
{
return(result);
}
//根据角色查询角色拥有的菜单ID
List <Guid> menuIds = new List <Guid>();
foreach (var roleId in userRoleIds)
{
menuIds = menuIds.Union(await _sysRoleRepository.GetMenuListByRoleAsync(roleId)).ToList();
}
allMenus = allMenus.Where(it => menuIds.Contains(it.Id)).OrderBy(it => it.SerialNumber).ToList();
return(Mapper.Map <List <SysMenuDto> >(allMenus));
}
public async Task SaveUser(SysUserDto userDto)
{
var user = _mapper.Map <SysUser>(userDto);
if (user.ID < 1)
{
if (await _userRepository.ExistAsync(x => x.Account == user.Account))
{
throw new BusinessException((int)ErrorCode.Forbidden, "用户已存在");
}
user.Salt = SecurityHelper.GenerateRandomCode(5);
user.Password = HashHelper.GetHashedString(HashType.MD5, user.Password, user.Salt);
await _userRepository.InsertAsync(user);
}
else
{
user.ModifyBy = _currentUser.ID;
user.ModifyTime = DateTime.Now;
await _userRepository.UpdateAsync(user,
x => x.Name,
x => x.DeptId,
x => x.Sex,
x => x.Phone,
x => x.Email,
x => x.Birthday,
x => x.Status);
}
}
public override Task <SysUserDto> CreateOrEditSysUser(SysUserDto request, ServerCallContext context)
{
if (request.Id == 1)
{
throw new RpcException(new Status(StatusCode.InvalidArgument, "admin管理员不允许被修改"));
}
Domain.SysUser data = null;
if (request.Id == 0)
{
request.Password = request.Password.Get32MD5One();
data = _sysUser.Insert(_mapper.Map <Domain.SysUser>(request));
}
else
{
data = _sysUser.SingleOrDefault(item => item.Id == request.Id);
if (data == null)
{
throw new RpcException(new Status(StatusCode.InvalidArgument, "系统用户不存在"));
}
data.RoleId = request.RoleId;
data.UserName = request.UserName;
data = _sysUser.Update(data);
}
return(Task.FromResult(_mapper.Map <SysUserDto>(data)));
}
public Task <ApiResult <SysUserDto> > GetModelAsync(long id)
{
IQueryable <SysUser> sysUserQueryable = _sysUserRepository.GetAll();
IQueryable <SysUserGroup> sysUserGroupQueryable = _sysUserGroupRepository.GetAll();
IQueryable <SysGroup> sysGroupQueryable = _sysGroupRepository.GetAll();
var userModel = from u in sysUserQueryable
join uug in sysUserGroupQueryable on u.ID equals uug.UserID
into uuug
from uuugModel in uuug.DefaultIfEmpty()
join ug in sysGroupQueryable on uuugModel.GroupID equals ug.ID
into uug
from uugModel in uug.DefaultIfEmpty()
where u.ID == id
select new SysUserDto()
{
LoginName = u.LoginName,
DepartmentID = u.DepartmentID,
NiceName = u.NiceName,
ContractPhone = u.ContractPhone,
GroupName = uugModel.GroupName
};
SysUserDto sysUserDto = userModel.FirstOrDefault();
if (sysUserDto != null)
{
return(Task.FromResult(ApiResult <SysUserDto> .Ok(sysUserDto)));
}
return(Task.FromResult(ApiResult <SysUserDto> .Error()));
}
public async Task <ApiResult <long> > UpdateAsync(SysUserDto model)
{
SysUser sysUser = AutoMapperHelper.MapTo <SysUser>(model);
sysUser = await _sysUserRepository.UpdateAsync(sysUser);
return(await Task.FromResult(ApiResult <long> .Ok(sysUser.ID)));
}
public IActionResult Form(SysUserDto model)
{
model.UserID = CurrentSysUser.LoginID;
string roleIdList = Request.Form["RoleIdList"];
_userService.Data = model;
return(SuccessJsonResult());
}
public async Task <IActionResult> CheckLoginAsync([FromBody] SysUserDto sys)
{
ClearCache("user");
ClearCache("menu");
var item = _userServices.CheckLogin(sys);
if (item.Item1)
{
await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, item.Item3.UserName),
new Claim(ClaimTypes.Sid, item.Item3.UserId.ToString()),
new Claim(ClaimTypes.Surname, item.Item3.UserNickname),
new Claim(ClaimTypes.Role, item.Item3.RoleId?.ToString()),
new Claim(ClaimTypes.Uri, string.IsNullOrWhiteSpace(item.Item3.HeadImg)?Path.Combine("upload", "head", "4523c812eb2047c39ad91f8c5de3fb31.jpg"):item.Item3.HeadImg)
};
var claimsIdentitys = new ClaimsIdentity(
claims,
CookieAuthenticationDefaults.AuthenticationScheme);
var claimsPrincipal = new ClaimsPrincipal(claimsIdentitys);
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, claimsPrincipal, new AuthenticationProperties
{
IssuedUtc = DateTime.Now,
IsPersistent = true,
ExpiresUtc = DateTime.Now.AddDays(1),
});
}
else
{
await _mediator.Publish(new Sys_log
{
LogId = PubId.SnowflakeId,
Browser = GetBrowser(),
Description = $"{_xss.Filter(sys.UserNickname)}登录失败",
LogIp = GetIp(),
Url = GetUrl(),
LogType = LogType.login.EnumToString()
});
//_logServices.Insert(new Sys_log
//{
// LogId = PubId.SnowflakeId,
// Browser = GetBrowser(),
// Description = $"{_xss.Filter(sys.UserNickname)}登录失败",
// LogIp = GetIp(),
// Url = GetUrl(),
// LogType = LogType.login.EnumToString()
//});
}
item.Item3 = null;
return(Json(item));
}
/// <summary>
/// 添加/编辑用户
/// </summary>
/// <param name="userDto"></param>
/// <returns></returns>
public string AddorEditUser(SysUserDto userDto)
{
var resModel = new ResponseModel();
var userLogin = injection.GetT <Data.UserAccount>().GetUserInfo();
var mModel = injection.GetT <ISysUserBLL>().AddorEditUser(userDto, userLogin.UserId);
resModel.StateCode = mModel.Result ? StatesCode.success : StatesCode.failure;
resModel.Messages = mModel.Message;
resModel.JsonData = mModel.Data;
return(JsonHelper.ObjectToJson(resModel));
}
public IActionResult Login(SysUserInput input)
{
SysUserDto currentUser = _sysUserService.Login(input.LoginName, input.Password, input.TenantName);
if (currentUser != null)
{
HttpContext.Session.Set("CurrentUser", ByteConvertHelper.Object2Bytes(currentUser));
return(Content(true.ToString()));
}
return(Content(false.ToString()));
}
/// <summary>
/// 添加/编辑用户
/// </summary>
/// <param name="userDto"></param>
/// <returns></returns>
public IActionResult AddorEditUser(SysUserDto userDto)
{
var resModel = new ResponseModel();
var userLogin = _userAccount.GetUserInfo();
var handleResult = _sysUserBLL.AddorEditUser(userDto, userLogin.UserId);
resModel.RetCode = handleResult.Result ? StatesCode.success : StatesCode.failure;
resModel.RetMsg = handleResult.Msg;
resModel.Data = handleResult.Data;
return(Ok(resModel));
}
///// <summary>
///// 注册
///// </summary>
///// <param name="user"></param>
///// <returns></returns>
//[AllowAnonymous]
//public async Task<ActionResult> Register()
//{
// ////user
// //var user = new IotUser { Id = Guid.NewGuid().ToString(), UserName = "******", Password = "******" };
// ////Context
// //var OwinContext = HttpContext.GetOwinContext();
// ////用户储存
// //var userStore = new IotUserStore(Ioc.CurrentIoc.Resolve<ISysUserService>());
// ////UserManager
// //var UserManager = new IotUserManager(userStore);
// //var result = await UserManager.CreateAsync(user, user.Password);
// //if (result.Succeeded)
// //{
// // Response.Write("注册成功！");
// //}
// return View();
//}
public async Task <ActionResult> GetRegisterData(SysUserDto user)
{
//users.CreateTime = DateTime.Now;
//users.Status=
//users.LastIP
//var user = _sysUserService.GetAsync(u => u.)
return(Content(""));
await _sysUserService.AddAsync(user); //添加用户到数据库中
}
[NoParametersLogAction]//有敏感信息不记录参数
public IActionResult Edit(SysUserDto model)
{
model.UserID = CurrentSysUser.LoginID;
string roleIdList = Request.Form["RoleIdList"];
model.RoleList = (roleIdList ?? "").Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(c => new RoleDto()
{
RoleId = c.ToInt()
}).ToList();
_userService.Data = model;
return(SuccessJsonResult());
}
public async System.Threading.Tasks.Task <IViewComponentResult> InvokeAsync()
{
var nameIdentifierClaim = HttpContext.User.FindFirst(ClaimTypes.NameIdentifier);
var id = nameIdentifierClaim.Value;
var userDto = new SysUserDto()
{
Id = Guid.Parse(id), LoginName = HttpContext.User.Identity.Name
};
var menus = await _sysLoginService.GetMenusAndFunctionByUserAsync(userDto);
return(View(menus));
}
public async void AddUser()
{
SysUserDto dto = new SysUserDto();
dto.Serialnum = Guid.NewGuid().ToString();
dto.LoginName = "chenqi";
dto.UserName = "******";
dto.Email = "*****@*****.**";
dto.QQ = "1497353329";
dto.Password = "******";
// _sysUserService = Ioc.CurrentIoc.Resolve<ISysUserService>();
await _sysUserService.AddAsync(dto);
}
/// <summary>
/// 非该角色用户 分页查询
/// </summary>
/// <param name="queryParam"></param>
/// <returns></returns>
public QueryResult <SysUserDto> QueryIsNotRole(SysRoleUserQueryParam queryParam)
{
QueryResult <SysUserDto> result = new QueryResult <SysUserDto>();
var r = SysRoleUserRepository.QueryIsNotRole(queryParam);
result.Total = r.Total;
result.List = r.List.Select(f =>
{
var d = new SysUserDto();
d.CopyFrom(f);
d.HeadImgUrl = SysFileRelationService.GetUserHeadImgPath(d.Id, Model.Enum.UploadType.UserPicture);
return(d);
}).ToList();
return(result);
}
public async Task <ActionResult> AddSysUser(string account, string pwd)
{
var count = IdentityContract.Users.Count(x => x.UserName == account);
if (count > 0)
{
return(Json(new OperationResult(OperationResultType.QueryNull, "此账号已存在").ToAjaxResult()));
}
SysUserDto dto = new SysUserDto
{
UserName = account,
Password = pwd
};
OperationResult result = await IdentityContract.SaveUsers(dto);
return(Json(result.ToAjaxResult()));
}
public JsonResult Index(string oldp, string newp)
{
OperationResult r = new OperationResult();
SysUserDto u = SysUser.GetById(UserHelper.GetSigninUser.userId);
if (u.Password.Equals(Zhongyu.Common.EncryptHelper.MD5Encrypt(oldp, 32)))
{
SysUser.ChangePassword(UserHelper.GetSigninUser.userId, Zhongyu.Common.EncryptHelper.MD5Encrypt(newp, 32));
r.ResultType = OperationResultType.Success;
}
else
{
r.Message = "原始密码不正确。";
r.ResultType = OperationResultType.ValidError;
}
return(Json(r));
}
public static int ChangePassword(string uid, string password)
{
using (IDbConnection conn = MySqlConnection())
{
SysUserDto item = GetById(uid);
item.Password = password;
UsersDto user = new UsersDto()
{
Name = item.Name, Enable = item.Enable, Id = item.Id, Password = item.Password, LoginName = item.LoginName, Phone = item.Phone
};
return(conn.Execute(
"update sysuser set Id=@Id,LoginName=@LoginName,Password=@Password,Name=@Name,Phone=@Phone,Enable=@Enable where Id=@Id",
user));
}
}
public WMSBaseApiAccessor(Wms_warehouse warehouse, ISqlSugarClient client, SysUserDto userDto)
{
this.Warehouse = warehouse;
HttpApiConfig config = new HttpApiConfig();
config.HttpHost = new Uri(warehouse.IFAddress);
if (!string.IsNullOrWhiteSpace(WMSProxy))
{
config.HttpHandler.UseProxy = true;
config.HttpHandler.Proxy = new HttpProxy(WMSProxy);
WebRequest.DefaultWebProxy = new WebProxy(WMSProxy)
{
BypassProxyOnLocal = false
};
}
_apiProxy = HttpApi.Create <IWMSApiProxy>(config);
_selfAccessor = new SelfWMSBaseApiAccessor(warehouse, client, userDto);
}
public IActionResult AddSysUser([FromBody] SysUserDto sysUserDto)
{
try
{
PwdTransition pwdTransition = new PwdTransition();
var Salt = Guid.NewGuid().ToString();
var Hashpwd = pwdTransition.ToHash("123aaa", Salt);
string ip = HttpContext.Connection.RemoteIpAddress.ToString();
var SysUserInfo = new SysUser()
{
Account = sysUserDto.Account,
Pwd = Hashpwd,
Salt = Salt,
Addr = sysUserDto.Addr,
Comments = sysUserDto.Comments,
CreatDate = DateTime.Now,
Ip = ip,
Name = sysUserDto.Name,
Phone = sysUserDto.Phone,
Latitude = sysUserDto.Latitude,
Longitude = sysUserDto.Longitude,
Popenid = sysUserDto.Popenid,
Comment1 = sysUserDto.Comment1,
Price = sysUserDto.Price,
TemIdAccept = sysUserDto.TemIdAccept,
TemIdRefuse = sysUserDto.TemIdRefuse,
TemIdOrder = sysUserDto.TemIdOrder,
TemIdSend = sysUserDto.TemIdSend,
IsOpen = sysUserDto.IsOpen
};
_context.SysUsers.Add(SysUserInfo);
_context.SaveChanges();
return(Ok("添加成功"));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task <IActionResult> Post([FromBody] SysUserDto viewmodel)
{
try
{
if (ModelState.IsValid)
{
await _logic.Create(viewmodel);
_logger.LogInformation("Success: Created");
return(Ok());
}
else
{
_logger.LogError("ERROR: Model State not Valid");
return(BadRequest(ModelState));
}
}catch (Exception ex)
{
_logger.LogCritical("ERROR: Info: " + ex.ToString());
return(StatusCode(500));
}
}
public async Task<ActionResult> SaveUserData(SysUserDto[] dtos)
{
dtos.CheckNotNull("dtos");
OperationResult result = await IdentityContract.SaveUsers(dtos);
return Json(result.ToAjaxResult());
}