public ActionResult SavePwd(UpdateUserInput updateuserinfo, Int64 Id)
{
var postParas = new Dictionary <string, string>()
{
{ "Id", updateuserinfo.Id.ToString() },
{ "ID", Id.ToString() },
{ "NewPwd", updateuserinfo.NewPwd },
{ "OldPwd", updateuserinfo.OldPwd },
{ "PhoneNumber", updateuserinfo.PhoneNumber },
{ "SavePwd", updateuserinfo.SavePwd }
};
if (postParas.ContainsKey(DataKey.UserId) == false)
{
postParas.Add(DataKey.UserId, GetLoginInfo().User.Id.ToString());
}
var fresult = PostStandardWithSameControllerAction <UpdateUserInput>(this, postParas);
if (!fresult.IsSuccess && string.IsNullOrEmpty(fresult.Message))
{
return(View());
}
if (!fresult.IsSuccess)
{
TempData["Error"] = fresult.Message;
}
else
{
TempData["Message"] = fresult.Message;
HttpContext.Items[DataKey.RemoveSessionCookie] = "yes";
Session.RemoveAll();
}
return(View());
}
public static async Task <UpdateUserOutput> UpdateUser(UpdateUserInput Parameters)
{
UpdateUserOutput output = new UpdateUserOutput()
{
Type = 0,
Message = "Kayıt güncellemede hata oluştu"
};
var filter = Builders <User> .Filter.Eq(Parameters.FilterCol, Parameters.FilterVal);
var update = Builders <User> .Update
.Set(x => x.Name, Parameters.Name)
.Set(x => x.Surname, Parameters.Surname)
.Set(x => x.Degree, Parameters.Degree)
.Set(x => x.Email, Parameters.Email)
.Set(x => x.Phone, Parameters.Phone)
.Set(x => x.Password, Parameters.Password)
.Set(x => x.ConfirmPassword, Parameters.ConfirmPassword)
.Set(x => x.Authority, Parameters.Authority)
.Set(x => x.State, Parameters.State)
.Set(x => x.BranchID, Parameters.BranchID);;
var projection = Builders <User> .Projection;
var project = projection.Exclude("_id");
var result = await db.GetCollection <User>("Users").UpdateManyAsync(filter, update);
if (result.ModifiedCount > 0)
{
output.Type = 1;
output.Message = result.ModifiedCount + " Kayıt başarıyla güncellendi.";
}
return(output);
}
public async Task <IActionResult> Put([FromBody][Required] UpdateUserRequest request)
{
var input = new UpdateUserInput(request.UserId, new ShortName(request.Name), new Email(request.Email));
await _mediator.PublishAsync(input);
return(_presenter.ViewModel);
}
public IActionResult Update([FromBody] UpdateUserInput user)
{
try
{
var userUpdate = _service.Update(user);
if (userUpdate is null)
{
return(UserNotFound(user.UserName));
}
if (userUpdate.Invalid)
{
return(BadRequest(new ResultViewModel {
Success = false, Docs = userUpdate.Notifications
}));
}
return(Ok(new ResultViewModel {
Success = true, Docs = userUpdate
}));
}
catch (Exception ex)
{
return(BadRequest(new ResultViewModel {
Success = false, Message = ex.Message, Docs = ex
}));
}
}
public async Task UpdateUserAsync(UpdateUserInput input)
{
var user = await _userRepository.GetAsync(input.User.Id);
input.User.MapTo(user);
CheckErrors(await _userManager.UpdateAsync(user));
}
public bool editInfo(UpdateUserInput input, int[] roleIds)
{
var user = db.Users.Find(input.ID);
if (user == null)
{
throw new UserFriendlyException(LocalizationConst.UserNoExist);
}
user = input.MapTo(user);
user.ModifyTime = DateTime.Now;
user.ModifyIP = IPHelper.GetIPAddress;
var list = db.UserRoles.Where(a => a.UserID == user.ID);
db.UserRoles.RemoveRange(list);
var Roles = db.Roles.Where(a => roleIds.Contains(a.ID));
var userRoles = new List <UserRole>();
foreach (var role in Roles)
{
userRoles.Add(new UserRole()
{
User = user, Role = role
});
}
db.UserRoles.AddRange(userRoles);
db.Entry(user).State = EntityState.Modified;
return(db.SaveChanges() > 0);
}
public async Task UpdateUser(UpdateUserInput input)
{
var user = _userRepository.Get(input.Id);
user.Theme = input.Theme;
CheckErrors(await UserManager.UpdateAsync(user));
}
public async Task <string> Update(UpdateUserInput input)
{
input.CheckDataAnnotations().CheckValidResult();
await _userDomainService.Update(input);
return("更新员工信息成功");
}
/// <inheritdoc/>
public async Task UpdateUser(UpdateUserInput input)
{
var user = await UserManager.GetUserByIdAsync(input.Id);
input.MapTo(user);
await UserManager.UpdateAsync(user);
}
public async Task <string> Update(UpdateUserInput input)
{
input.CheckDataAnnotations().CheckValidResult();
var userInfo = await _userRepository.SingleOrDefaultAsync(p => p.Id == input.Id);
if (userInfo == null)
{
throw new BusinessException($"不存在Id为{input.Id}的用户信息");
}
if (input.Email != userInfo.Email)
{
var exsitUser = await _userRepository.FirstOrDefaultAsync(p => p.Email == input.Email);
if (exsitUser != null)
{
throw new BusinessException($"系统中已经存在{input.Email}的用户信息");
}
}
if (input.Phone != userInfo.Phone)
{
var exsitUser = await _userRepository.FirstOrDefaultAsync(p => p.Phone == input.Phone);
if (exsitUser != null)
{
throw new BusinessException($"系统中已经存在{input.Phone}的用户信息");
}
}
userInfo = input.MapTo(userInfo);
await _userRepository.UpdateAsync(userInfo);
return("更新员工信息成功");
}
public async Task <string> Update(UpdateUserInput input)
{
input.CheckDataAnnotations().CheckValidResult();
_session.CheckLoginUserDataPermision(input.OrgId, "您没有将用户设置为该部门的权限");
await _userDomainService.Update(input);
return("更新员工信息成功");
}
public async Task <User> UpdateUser(
[Service] IAsyncUpdateStrategy <User, UpdateUserInput> strategy,
UpdateUserInput user
)
{
var result = await strategy.UpdateAsync(user);
return(result);
}
public ActionResult Edit(UpdateUserInput viewModel, string returnUrl = null)
{
if (ModelState.IsValid)
{
_userService.UpdateUserAccount(viewModel, UserContext.UserId);
return(Redirect(returnUrl ?? "/"));
}
return(View(viewModel));
}
/// <summary>
/// Allow updating properties of an existing user
/// </summary>
/// <param name="guid">
/// The unique identifier of the user that should be updated
/// </param>
/// <param name="input">
/// The updates for the user
/// </param>
/// <returns></returns>
public User UpdateUser(Guid guid, UpdateUserInput input)
{
GraphQLParameters parameters = new GraphQLParameters();
parameters.Add(@"uuid", guid);
parameters.Add(@"input", input);
return(RunMutation <User>(@"updateOrgUser", parameters));
}
/// <summary>
/// 更新用户信息
/// </summary>
/// <param name="updates">更新项</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <User> UpdateProfile(
UpdateUserInput updates,
CancellationToken cancellationToken = default)
{
var param = new UpdateUserParam(updates);
var res = await Request <UpdateUserResponse>(param.CreateRequest(), cancellationToken);
User = res.Result;
return(res.Result);
}
/// <summary>
/// 更新用户
/// </summary>
/// <param name="input">输入模型</param>
/// <returns></returns>
public async Task UpdateUser(UpdateUserInput input)
{
var user = await UserManager.GetUserByIdAsync(input.Id);
user.Name = input.Name;
user.Surname = input.Surname;
user.Password = input.Password;
CheckErrors(await UserManager.UpdateAsync(user));
}
/// <summary>
/// 更新用户信息
/// </summary>
/// <param name="input"></param>
/// <param name="output"></param>
/// <param name="errMsg"></param>
/// <returns></returns>
public bool UpdateUser(UpdateUserInput input, ref UpdateUserOut output, ref string errMsg)
{
bool doResult = HttpCommonMethod <UpdateUserInput, UpdateUserOut>("/antuser/user.updateUser.do", GlobalVariable.RequestMethod.POST, input, ref output, ref errMsg);
if (doResult && output.result == (int)GlobalVariable.Result.Failure)
{
errMsg = string.IsNullOrEmpty(output.errorCode) ? "更新用户信息失败" : resources.GetString("E_" + output.errorCode);
return(false);
}
return(doResult);
}
public void UpdateUser(UpdateUserInput input)
{
Logger.Info("Updating a user for input: " + input);
var user = _userRepository.Get(input.UserId);
user.DisplayName = input.DisplayName ?? user.DisplayName;
user.Email = input.Email ?? user.Email;
//We even do not call Update method of the repository.
//Because an application service method is a 'unit of work' scope as default.
}
/// <summary>
/// 修改用户数据
/// </summary>
/// <param name="updateUserInput"></param>
/// <returns></returns>
public async Task <bool> UpdateUser(UpdateUserInput updateUserInput)
{
var result = false;
var entity = Mapper.Map <UpdateUserInput, User>(updateUserInput);
if (entity != null && entity.Id > 0)
{
result = await _userRepository.Update(entity);
}
return(result);
}
public UpdateUserOutput UpdateUser(UpdateUserInput input)
{
//input -> business obj
var user = Mapper.Map <User>(input);
user.Id = AbpSession.GetUserId();
//更新用户信息
_userDomainService.UpdateUser(user);
return(new UpdateUserOutput());
}
public async Task <ActionResult> Update(UpdateUserInput input, IFormFile file)
{
string filePath = string.Empty;
if (file != null)
{
filePath = await SaveFile(file, input.Account);
}
input.Photos = filePath;
await _userAppService.Update(input);
return(Json(new AjaxResponse()));
}
public void UpdateUser(UpdateUserInput input)
{
var user = _userRepository.Get(input.Id);
user.TenantId = null;
user.UserName = input.UserName;
user.Name = input.Name;
user.Surname = input.Surname;
user.EmailAddress = input.EmailAddress;
user.IsEmailConfirmed = true;
user.Password = "******"; //123qwe
_userRepository.Update(user);
}
public async Task Execute(UpdateUserInput input)
{
var user = new Domain.Entities.User()
{
Id = currentUser.UserId,
Name = input.Name,
Surname = input.Surname,
Email = input.Email,
Password = input.Password
};
bool success = await identityService.UpdateUserAsync(user);
outputPort.Standart(new UpdateUserOutput(success));
}
public User Update(UpdateUserInput userInput)
{
var user = GetByUserName(userInput.UserName);
var name = new Name(userInput.FirstName, userInput.LastName);
var email = new Email(userInput.Email);
if (user is null || user.Invalid)
{
return(user);
}
user.Update(name, email);
_uow.Commit();
return(user);
}
public ActionResult Update(UpdateUserInput input)
{
input.Validate();
var services = this.CreateService <IAccountAppService>();
var user = services.GetById <Sys_User>(input.Id);
user.RoleId = input.RoleId;
user.RealName = input.RealName;
user.IsEnabled = input.IsEnabled;
user.Description = input.Description;
user.LastModifyUserId = CurrentSession.UserId;
user.LastModifyTime = DateTime.Now;
services.Update(user);
return(this.UpdateSuccessMsg());
}
public User Update(UpdateUserInput userInput)
{
var user = _respository.GetByKey(userInput.Id);
var email = new Email(userInput.Email);
user.Update(email, userInput.Name);
if (user.Invalid)
{
return(user);
}
_respository.Update(user);
_uow.Commit();
return(user);
}
public ActionResult <User> Put(int id, [FromBody] UpdateUserInput input)
{
try
{
if (id != input.Id)
{
throw new ArgumentException();
}
return(_userService.UpdateUser(input));
}
catch (Exception e)
{
//return BadRequest("Failed to update user.");
return(BadRequest(e.Message));
}
}
/// <summary>
/// 更新用户信息
/// </summary>
/// <param name="userId">用户 ID</param>
/// <param name="updates">更新信息</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <User> Update(
string userId,
UpdateUserInput updates,
CancellationToken cancellationToken = default)
{
updates.Password = client.Encrypt(updates.Password);
var param = new UpdateUserParam(updates)
{
Id = userId,
Input = updates
};
var res = await client.Request <UpdateUserResponse>(param.CreateRequest(), cancellationToken);
return(res.Result);
}
public async Task <IActionResult> UpdateUser([FromBody] UpdateUserInput updateUserInput)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var updateUserResult = await userCrud.UpdateUser(updateUserInput);
foreach (var error in updateUserResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(Ok());
}
public void UpdateUser(UpdateUserInput input)
{
input.Validate();
this.DbContext.Update <MALU_Users>(a => a.Id == input.Id, a => new MALU_Users()
{
//OrganizeId = input.OrganizeId,
RoleId = input.RoleId,
DutyId = input.DutyId,
RealName = input.RealName,
Gender = input.Gender,
MobilePhone = input.MobilePhone,
Birthday = input.Birthday,
IsEnabled = input.IsEnabled,
companyguid = input.companyguid
});
}
