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();
}));
}