public async Task <UpdateUserOutputModel> UpdateUser(UpdateUserModel model)
{
var res = new UpdateUserOutputModel();
using (IDbConnection db = new SqlConnection(Global.Connection))
{
var p = new DynamicParameters();
p.Add("@password", model.Password);
p.Add("@Phone1", model.Phone);
p.Add("@whatsapp", model.WhatsApp);
p.Add("@skype", model.Skype);
p.Add("@f", model.f);
p.Add("@e_mail", model.Email);
p.Add("@Cust_ID_Main", model.Cust_ID_Main);
p.Add("@Cust_ID", model.Cust_ID);
p.Add("@Street", model.Street);
p.Add("@Comp_ID", dbType: DbType.String, direction: ParameterDirection.Output, size: 50);
p.Add("@Txt", dbType: DbType.String, direction: ParameterDirection.Output, size: 50);
var procRes = await db.ExecuteAsync("sp_UpdateWebCustomerCompany", p,
commandType : CommandType.StoredProcedure);
res = new UpdateUserOutputModel
{
Cust_ID = p.Get <string>("@Cust_ID"),
Comp_ID = p.Get <string>("@Comp_ID"),
Txt = p.Get <string>("@Txt")
};
}
return(res);
}
public JsonResult Update(UpdateUserModel model)
{
CommonModelResult result = new CommonModelResult();
try
{
_userService.UpdateUser(new LoginUserInfo()
{
UserId = model.UserId,
FullName = model.NewName
});
}
catch (BusinessException exception)
{
_logger.DebugFormat("BusinessException: {0}-{1}", exception.ErrorCode, exception.Message);
result.ErrorCode = exception.ErrorCode;
result.ErrorDescription = CommonUtils.GetErrorMessage(exception);
}
catch (Exception exception)
{
_logger.Error(string.Format("Iternal error {0}", exception));
result.ErrorCode = ErrorCode.InternalErrorException;
result.ErrorDescription = CommonUtils.GetEnumDescription(ErrorCode.InternalErrorException);
}
return(Json(result));
}
public async Task <IResult> UpdateAsync(UpdateUserModel updateUserModel)
{
var validation = new UpdateUserModelValidator().Valid(updateUserModel);
if (!validation.Success)
{
return(new ErrorResult(validation.Message));
}
var userEntityDatabase = await UserRepository.SelectAsync(updateUserModel.UserId).ConfigureAwait(false);
var userDomain = UserDomainFactory.Create(updateUserModel);
userDomain.SetLogin(userEntityDatabase.Login);
userDomain.SetPassword(userEntityDatabase.Password);
var userEntity = userDomain.Map <UserEntity>();
await UserRepository.UpdateAsync(userEntity, userEntity.UserId).ConfigureAwait(false);
await DatabaseUnitOfWork.SaveChangesAsync().ConfigureAwait(false);
return(new SuccessResult());
}
public void UpdateFromModel(UpdateUserModel model)
{
UserName = model.Email;
Email = model.Email;
MaxAllowedDeviceCount = model.MaxAllowedDeviceCount;
MaxAllowedStudentCount = model.MaxAllowedStudentCount;
CanScan = model.CanScan;
LicenseTypeId = model.LicenseTypeId;
ExpiryDateUtc = model.ExpiryDateUtc;
if (model.Active != null)
{
Active = model.Active.Value;
}
if (model.ActivationTimeUtc != null)
{
ActivationTimeUtc = model.ActivationTimeUtc;
}
if (model.StartDateTimeUtc != null)
{
StartDateTimeUtc = model.StartDateTimeUtc;
}
}
public async Task <IActionResult> EditUser([FromBody] UpdateUserModel user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var returnedUser = new User();
var returnedUserViewModel = new UserViewModel();
try
{
returnedUser = await this.usersService.UpdateUser(user);
returnedUserViewModel = mapper.Map <UserViewModel>(returnedUser);
}
catch (Exception)
{
return(BadRequest());
}
if (returnedUser == null || returnedUserViewModel == null)
{
return(BadRequest());
}
return(Ok(returnedUserViewModel));
}
public async Task UpdateShouldUpdateRoles()
{
var role = new Role
{
Name = _random.Next().ToString()
};
_roleList.Add(role);
var user = new User
{
Id = _random.Next(),
Roles = new List <UserRole>
{
new UserRole()
}
};
_userList.Add(user);
var model = new UpdateUserModel
{
LastName = _random.Next().ToString(),
FirstName = _random.Next().ToString(),
Roles = new[] { role.Name }
};
var result = await _query.Update(user.Id, model);
result.Roles.Should().HaveCount(1);
result.Roles.Should().Contain(x => x.User == result && x.Role == role);
}
public async Task <CustomResponse <UserResponse> > UpdateUser(UpdateUserModel model)
{
var infos = new List <string>();
var user = _context.AspNetUsers.FirstOrDefault(u => u.Id == model.UserId);
#region Validate User
if (user == null)
{
infos.Add("User not exist.");
return(new CustomResponse <UserResponse> {
Message = infos
});
}
;
#endregion
user.Fullname = string.IsNullOrEmpty(model.Fullname) ? user.Fullname : model.Fullname;
user.MobileNumber = string.IsNullOrEmpty(model.MobileNumber) ? user.MobileNumber : model.MobileNumber;
user.UpdatedAt = DateTime.UtcNow;
_context.Update(user);
await _context.SaveChangesAsync();
return(new CustomResponse <UserResponse> {
Succeed = true,
Data = _mapper.Map <UserResponse>(user)
});
}
