public IActionResult SaveUser(AdminUserDto input) { if (!ModelState.IsValid) { return(ShowError(GetModelError(ModelState))); } if (input.Id == 0) { var res = accountService.AddUser(input); if (res > 0) { return(ShowSuccess("新增成功")); } else { return(ShowError("新增失败")); } } else { var msg = accountService.EditUser(input); if (string.IsNullOrEmpty(msg)) { return(ShowSuccess("保存成功")); } else { return(ShowError(msg)); } } }
public string EditUser(AdminUserDto user) { string res = ""; var oldUser = GetUserInfo(user.Id); if (oldUser.Id == 0) { res = "用户不存在"; } else { var userModel = ModelConvertUtil <AdminUserDto, AdminUserInfo> .ModelCopy(user); if (string.IsNullOrEmpty(user.Password)) { //未修改密码 userModel.Password = oldUser.Password; } else { //修改密码,加密 userModel.Password = MD5.Encrypt(user.Password); } res = adminRepository.Update(userModel) ? "" : "修改失败"; } return(res); }
public Result Create(AdminUserDto dto) { var validator = new AdminUserValidator(_adminUserRepository); var result = validator.ValidateResult(dto); if (!result.Success) { return(result); } var entity = Mapper.Map <AdminUser>(dto); entity.Salt = SecurityHelper.GenerateSalt(); entity.Password = SecurityHelper.GenerateHash(dto.Password, entity.Salt); _adminUserRepository.Insert(entity); foreach (var roleId in dto.Roles) { entity.Roles.Add(_adminRoleRepository.Find(roleId)); } _unitOfWork.Commit(); AdminUserCacheManager.ClearCache(); result.Id = entity.Id; return(result.SetSuccess(Messages.RecordSaved)); }
public async Task <AdminUserDto> GetAdminUseByKey(AdminUserDto adminUser) { using (connection = Get_Connection()) { var dataList = await connection.QueryAsync <AdminUserDto>("select * from AdminUser where UserName = '******' and Password = '******'", commandType : CommandType.Text); return(dataList.FirstOrDefault()); } }
public int AddUser(AdminUserDto user) { var userModel = ModelConvertUtil <AdminUserDto, AdminUserInfo> .ModelCopy(user); userModel.CreateTime = DateTime.Now; userModel.IsDisable = Models.Enum.EYesOrNo.No; userModel.Password = MD5.Encrypt(user.Password); return((int)adminRepository.Insert(userModel)); }
public AdminUserDto Create(AdminUserDto entity) { try { return(rep.Create(entity.MapTo <AdminUser>()).MapTo <AdminUserDto>()); } catch (Exception) { throw; } }
public bool Update(AdminUserDto entity) { try { return(rep.Update(entity.MapTo <AdminUser>())); } catch (Exception) { throw; } }
public AdminUserDto Login(string userName, string passWord) { AdminUserDto res = new AdminUserDto(); var model = adminRepository.GetUserInfo(userName, MD5.Encrypt(passWord)); if (model != null) { res = ModelConvertUtil <AdminUserInfo, AdminUserDto> .ModelCopy(model); } return(res); }
// GET api/<controller>/5 /// <summary> /// 获取接口 /// </summary> /// <param name="id">id</param> /// <returns></returns> // [ApiIgnore] public StandardJsonResult <AdminUserDto> GetValueById(int id) { return(base.StandardAction <AdminUserDto>(() => { AdminUserDto admin = new AdminUserDto { ID = adminUserService.Count() }; return admin; })); }
public async Task AddAdminUser(AdminUserDto adminUserDto) { ArgumentValidation.Validate(nameof(adminUserDto), adminUserDto); var request = new RestRequest("setup", Method.POST); request.AddJsonBody(adminUserDto); IRestResponse response = await Client.ExecuteAsync(request); ValidateResponse(response); }
public JsonResult UpdateSystemUser(SystemUserModel model) { CommonResult r = new CommonResult(); try { if (ModelState.IsValid) { AdminUserDto userInfo = new AdminUserDto() { IsEnable = model.Enabled, Mobile = model.Mobile, Password = new PasswordHasher().HashPassword(model.Password), Name = model.RealName, RoleIds = new List <string>() { model.RoleId }, Id = model.UserId }; int acount = UserManager.UpdateUserAndUserRole(userInfo); if (acount > 0) { r.message = "保存成功"; r.code = (int)ResultCodeEnum.OK; } else { r.message = "保存失败"; r.code = (int)ResultCodeEnum.SystemError; } } else { r.message = "字段为按要求填写"; r.code = (int)ResultCodeEnum.VerifyError; } } catch (Exception ex) { r.message = ex.Message; r.code = (int)ResultCodeEnum.SystemError; } return(Json(r)); }
private void ChildRoleUpdate(AdminUser entity, AdminUserDto dto) { var currentRecords = entity.Roles.Select(s => s.Id).ToList(); var addedRecords = dto.Roles.Except(currentRecords).ToList(); foreach (var record in addedRecords) { entity.Roles.Add(_adminRoleRepository.Find(record)); } var deletedRecords = currentRecords.Except(dto.Roles).ToList(); foreach (var record in deletedRecords) { entity.Roles.Remove(entity.Roles.First(w => w.Id == record)); } }
public static void Init() { Mapper.AddMap <AdminUser, AdminUserDto>(src => { var adminUserViewModel = new AdminUserDto(); adminUserViewModel.InjectFrom(src); adminUserViewModel.Password = null; adminUserViewModel.Roles = src.Roles.Select(s => s.Id).ToList(); return(adminUserViewModel); }); Mapper.AddMap <AdminUserDto, AdminUser>((from, to) => { var existing = to as AdminUser ?? new AdminUser(); existing.InjectFrom(new LoopInjection(new[] { "Password" }), from); return(existing); }); }
public int UpdateUserAndUserRole(AdminUserDto user) { using (ApplicationDbContext ctx = new ApplicationDbContext()) { var en = ctx.Users.FirstOrDefault(p => p.Id == user.Id); if (en != null) { en.Name = user.Name; en.PhoneNumber = user.Mobile; en.PasswordHash = user.Password; en.IsEnable = user.IsEnable; var role = ctx.UserRoles.FirstOrDefault(p => p.UserId == user.Id); role.RoleId = user.RoleIds.FirstOrDefault(); return(ctx.SaveChanges()); } else { return(0); } } }
public AdminUserDto SignIn(string email, string password) { AdminUserDto result = null; try { result = GetByEmail(email); if (result != null) { if (!VerifyPassword(result.Password, password)) { result = null; } } } catch (Exception) { throw; } return(result); }
public async Task <ActionResult> Login(AdminUserDto adminUser) { if (string.IsNullOrEmpty(adminUser.UserName) || string.IsNullOrEmpty(adminUser.Password)) { return(View("index")); } else { var userDetails = await dataAccess.GetAdminUseByKey(adminUser); if (userDetails != null) { HttpContext.Session["AdminUser"] = userDetails; return(View("Course")); } else { ViewData["LoginError"] = "Creadential are Wrong"; return(View("index")); } } }
protected override async Task <AuthenticateResult> HandleAuthenticateAsync() { if (!Request.Headers.ContainsKey("Authorization")) { return(AuthenticateResult.Fail("Missing Authorization Header")); } AdminUserDto user = null; try { var authHeader = AuthenticationHeaderValue.Parse(Request.Headers["Authorization"]); var credentialBytes = Convert.FromBase64String(authHeader.Parameter); var credentials = Encoding.UTF8.GetString(credentialBytes).Split(':'); var username = credentials[0]; var password = credentials[1]; user = await _userService.Authenticate(username, password); } catch { return(AuthenticateResult.Fail("Invalid Authorization Header")); } if (user == null) { return(AuthenticateResult.Fail("Invalid Username or Password")); } var claims = new[] { new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()), new Claim(ClaimTypes.Name, user.Username), }; var identity = new ClaimsIdentity(claims, Scheme.Name); var principal = new ClaimsPrincipal(identity); var ticket = new AuthenticationTicket(principal, Scheme.Name); return(AuthenticateResult.Success(ticket)); }
public Result Edit(int id, AdminUserDto dto) { dto.Id = id; var validator = new AdminUserValidator(_adminUserRepository); var result = validator.ValidateResult(dto); if (!result.Success) { return(result); } var entity = _adminUserRepository.AsNoTracking.Include(i => i.Roles) .FirstOrDefault(s => s.Id == dto.Id); if (entity == null) { return(new Result().SetBlankRedirect()); } Mapper.Map <AdminUser>(dto, entity); if (!string.IsNullOrEmpty(dto.Password)) { entity.Salt = SecurityHelper.GenerateSalt(); entity.Password = SecurityHelper.GenerateHash(dto.Password, entity.Salt); } _adminUserRepository.Update(entity); ChildRoleUpdate(entity, dto); _unitOfWork.Commit(); AdminUserCacheManager.ClearCache(); return(result.SetSuccess(Messages.RecordSaved)); }
public async Task <IActionResult> AddAdminUser([FromBody] AdminUserDto adminUserDto) { if (_userManager.Users.Any()) { return(NotFound("The request is not valid for this configuration.")); } if (!_credentialGenerator.CheckPassword(adminUserDto.Password)) { _logger.LogInformation("The password does not comply with the minimum requirements."); return(StatusCode(StatusCodes.Status406NotAcceptable)); } var adminRole = await _roleManager.FindByNameAsync(CommonConstants.AdministratorsRole); if (adminRole == null) { _logger.LogInformation("No Administrator-Role has been found."); return(StatusCode(StatusCodes.Status406NotAcceptable)); } var adminUser = await _userManager.FindByNameAsync(adminUserDto.EMail); if (adminUser == null) { adminUser = new OspUser { UserName = adminUserDto.EMail, Email = adminUserDto.EMail }; await _userManager.CreateAsync(adminUser, adminUserDto.Password); await _userManager.AddToRoleAsync(adminUser, adminRole.Id.ToString()); } return(Ok()); }
public IHttpActionResult Put(int id, [FromBody] AdminUserDto dto) { return(Result(_adminUserService.Edit(id, dto))); }
public IHttpActionResult Post([FromBody] AdminUserDto dto) { return(Result(_adminUserService.Create(dto))); }
public static AdminUserEntity EntityMap(this AdminUserDto model) { return(Mapper.Map <AdminUserEntity>(model)); }
/// <summary> /// /// </summary> /// <param name="dto"></param> /// <returns></returns> public StandardJsonResult Save(AdminUserDto dto) { return(base.StandardAction(() => { adminUserService.Count(); })); }