public UpdateUserResponse ChangePassword(ChangePasswordRequest request)
{
var response = new UpdateUserResponse { IsSuccess = false, Message = "Unknown Error" };
if (request.New_Password == null)
{
response.Message = "New Password Could not be null!";
return response;
}
var user = DataContext.Users.First(x => x.Id == request.Id).MapTo<User>();
if (user != null)
{
if (user.Password != crypto.Compute(request.Old_Password, user.PasswordSalt))
{
response.Message = "Current Password isn't correct!";
return response;
}
user.PasswordSalt = crypto.Salt != null ? crypto.Salt : crypto.GenerateSalt(crypto.HashIterations, crypto.SaltSize);
user.Password = crypto.Compute(request.New_Password, user.PasswordSalt);
DataContext.Users.Attach(user);
DataContext.Entry(user).State = EntityState.Modified;
DataContext.SaveChanges();
response.IsSuccess = true;
response.Message = "Password Successfully Changed!";
}
return response;
}
public async Task Should_reset_password()
{
var client = new Mock <ITestApiClient>();
var response = new UpdateUserResponse
{
NewPassword = UserData.NEW_PASSWORD
};
client
.Setup(x => x.GetUserExistsInAdAsync(It.IsAny <string>()))
.ReturnsAsync(true);
client
.Setup(x => x.ResetUserPasswordAsync(It.IsAny <ResetUserPasswordRequest>()))
.ReturnsAsync(response);
var controller = new UserController(client.Object, _loggerMock.Object, _configuration.Object);
var result = await controller.ResetPassword(_request);
var typedResult = (ObjectResult)result;
typedResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var updateUserResponse = (UpdateUserResponse)typedResult.Value;
updateUserResponse.Should().NotBeNull();
updateUserResponse.Should().BeEquivalentTo(response);
}
public UpdateUserResponse UpdateUser(UpdateUserRequest request)
{
UpdateUserResponse response = new UpdateUserResponse
{
Success = true,
Error = ""
};
User_Users DbUser = db.User_Users.FirstOrDefault(u => u.UserNr == request.UserNr);
if (DbUser == null)
{
response.Success = false;
response.Error = "No user found";
return(response);
}
try
{
DbUser.Email = request.Email;
db.SaveChanges();
}
catch (Exception e)
{
_logger.ErrorFormat($"error happend error: {e.Message} stacktrace: {e.StackTrace}");
response.Success = false;
response.Error = "An error occured in user creation please check logs for more details";
}
return(response);
}
public ActionResult <Response> Update([FromRoute] Guid id, [FromBody] UpdateUserRequest model)
{
var identity = (ClaimsIdentity)HttpContext.User.Identity;
_unitOfWork.SetIdentity(identity);
var user = _unitOfWork.UserRepository.GetSingle(id);
if (user == null)
{
return(BadRequest(new Response(HttpStatusCode.BadRequest, "User not found")));
}
var password = _authService.HashPassword(model.Password, out byte[] salt);
user.Username = model.Username;
user.Role = model.Role;
user.Password = password;
user.Salt = Convert.ToBase64String(salt);
_unitOfWork.UserRepository.Update(user);
_unitOfWork.SaveChanges();
user = _unitOfWork.UserRepository.GetSingle(user.Id, x => x.Include(i => i.RoleNavigation));
var data = new UpdateUserResponse()
{
Id = user.Id,
Username = user.Username,
Role = user.RoleNavigation.Code,
};
return(Ok(new Response(HttpStatusCode.OK, data)));
}
public HttpResponseMessage UpdateUser(UserViewModel userViewModel)
{
int userId = this.UserId;
userViewModel.ModifiedBy = userId;
userViewModel.ModifiedOn = DateTime.Now.ToUniversalTime();
UpdateUserResponse response = new UpdateUserResponse();
try
{
UpdateUserRequest request = new UpdateUserRequest()
{
UserViewModel = userViewModel,
AccountId = this.AccountId
};
response = userService.UpdateUser(request);
IEnumerable <int> userIds = new List <int>()
{
userViewModel.UserID
};
InsertProfileAudit(userIds, UserAuditType.ProfileUpdate, null, userId);
}
catch (Exception ex)
{
response.ErrorMessage = ex.Message;
}
return(Request.BuildResponse(response));
}
public UpdateUserResponse Handle(UpdateUserRequest request)
{
var response = new UpdateUserResponse();
response.Errors = Validate(request);
if (response.HasErrors)
{
return(response);
}
if (!string.IsNullOrEmpty(request.UserToUpdate.Password)) //nes gali ir nepaduoti
{
request.UserToUpdate.Password = PasswordsHelper.HashPassword(request.UserToUpdate.Password);
}
try
{
UpdateUserObject(request.UserOrigin, request.UserToUpdate);
_usersRepository.Update(request.UserOrigin);
return(response);
}
catch (Exception ex)
{
response.Errors.Add(new ErrorStatus(ex.Message));
//response.Errors.Add(new ErrorStatus("BAD_REQUEST"));
return(response);
}
}
public virtual UpdateUserResponse UpdateUser(UpdateUserRequest request)
{
var response = new UpdateUserResponse();
try {
// Raise Initialization Event
var initialization = UpdateUserInitialization;
if (initialization != null)
{
initialization(request, response);
}
// Raise Execute Event
var execute = UpdateUserExecute;
if (execute != null)
{
response = execute(request);
}
// Raise Complete Event
var complete = UpdateUserComplete;
if (complete != null)
{
complete(request, response);
}
}
catch (Exception exception) {
// Raise Error Event
var error = UpdateUserError;
if (error != null)
{
error(request, response, exception);
}
}
return(response);
}
public UpdateUserResponse UpdateUser(UpdateUserRequest request)
{
var response = new UpdateUserResponse();
try
{
var existingUser = _userRepository.FindBy(request.Id);
if (existingUser != null)
{
_userMapper.PopulateDomainObject(existingUser, request.UserProperties);
ThrowExceptionIfUserIsInvalid(existingUser);
_userRepository.Update(existingUser);
_uow.Commit();
response.Result = true;
return(response);
}
response.Exception = GetStandardUserNotFoundException();
return(response);
}
catch (Exception ex)
{
response.Exception = ex;
return(response);
}
}
public async Task <UpdateUserResponse> UpdateUser(UpdateUserRequest request)
{
var session = await _sessionService.GetAuthenticatedSession();
var response = new UpdateUserResponse();
var duplicateResponse = await _accountService.DuplicateUserCheck(new DuplicateUserCheckRequest()
{
EmailAddress = request.EmailAddress,
Username = request.Username,
MobileNumber = request.MobileNumber,
UserId = request.Id
});
if (duplicateResponse.Notifications.HasErrors)
{
response.Notifications.Add(duplicateResponse.Notifications);
return(response);
}
using (var uow = _uowFactory.GetUnitOfWork())
{
var user = await uow.UserRepo.GetUserById(new Infrastructure.Repositories.UserRepo.Models.GetUserByIdRequest()
{
Id = request.Id
});
var dbRequest = new Infrastructure.Repositories.UserRepo.Models.UpdateUserRequest()
{
Id = request.Id,
Username = request.Username,
First_Name = request.FirstName,
Last_Name = request.LastName,
Mobile_Number = request.MobileNumber,
Email_Address = request.EmailAddress,
Password_Hash = user.Password_Hash,
Registration_Confirmed = request.RegistrationConfirmed,
Updated_By = session.User.Entity.Id,
};
if (!string.IsNullOrEmpty(request.Password))
{
dbRequest.Password_Hash = PasswordHelper.HashPassword(request.Password);
}
await uow.UserRepo.UpdateUser(dbRequest);
uow.Commit();
}
await CreateOrDeleteUserRoles(request.RoleIds, request.Id, session.User.Entity.Id);
await _sessionService.WriteSessionLogEvent(new Models.ServiceModels.Session.CreateSessionLogEventRequest()
{
EventKey = SessionEventKeys.UserUpdated
});
response.Notifications.Add($"User {request.Username} has been updated", NotificationTypeEnum.Success);
return(response);
}
public UpdateUserResponse Update(UpdateUserRequest request)
{
var response = new UpdateUserResponse();
try
{
var user = request.MapTo <User>();
user.Role = DataContext.RoleGroups.First(x => x.Id == request.RoleId);
if (request.ChangePassword && request.Password != null)
{
user.Password = crypto.Compute(request.Password);
user.PasswordSalt = crypto.Salt;
}
DataContext.Users.Attach(user);
DataContext.Entry(user).State = EntityState.Modified;
DataContext.SaveChanges();
response.IsSuccess = true;
response.Message = "User item has been updated successfully";
}
catch (DbUpdateException dbUpdateException)
{
response.Message = dbUpdateException.Message;
}
return(response);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
UpdateUserResponse response = new UpdateUserResponse();
return(response);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
UpdateUserResponse response = new UpdateUserResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("RequestId", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.RequestId = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("User", targetDepth))
{
var unmarshaller = UserUnmarshaller.Instance;
response.User = unmarshaller.Unmarshall(context);
continue;
}
}
response.Status = (int)context.ResponseData.StatusCode;
return(response);
}
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
UpdateUserResponse response = new UpdateUserResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.IsStartElement)
{
if (context.TestExpression("UpdateUserResult", 2))
{
UnmarshallResult(context, response);
continue;
}
if (context.TestExpression("ResponseMetadata", 2))
{
response.ResponseMetadata = ResponseMetadataUnmarshaller.Instance.Unmarshall(context);
}
}
}
return(response);
}
public UpdateUserResponse ChangePassword(ChangePasswordRequest request)
{
var response = new UpdateUserResponse {
IsSuccess = false, Message = "Unknown Error"
};
if (request.New_Password == null)
{
response.Message = "New Password Could not be null!";
return(response);
}
var user = DataContext.Users.First(x => x.Id == request.Id).MapTo <User>();
if (user != null)
{
if (user.Password != crypto.Compute(request.Old_Password, user.PasswordSalt))
{
response.Message = "Current Password isn't correct!";
return(response);
}
user.PasswordSalt = crypto.Salt != null ? crypto.Salt : crypto.GenerateSalt(crypto.HashIterations, crypto.SaltSize);
user.Password = crypto.Compute(request.New_Password, user.PasswordSalt);
DataContext.Users.Attach(user);
DataContext.Entry(user).State = EntityState.Modified;
DataContext.SaveChanges();
response.IsSuccess = true;
response.Message = "Password Successfully Changed!";
}
return(response);
}
public async Task Should_reset_user_password()
{
const string USERNAME = EmailData.NON_EXISTENT_USERNAME;
const string NEW_PASSWORD = UserData.NEW_PASSWORD;
var request = new ResetUserPasswordRequest()
{
Username = USERNAME
};
var response = new UpdateUserResponse()
{
NewPassword = NEW_PASSWORD
};
UserApiClient
.Setup(x => x.ResetUserPasswordAsync(USERNAME))
.ReturnsAsync(response);
var result = await Controller.ResetUserPassword(request);
result.Should().NotBeNull();
var objectResult = (OkObjectResult)result;
objectResult.StatusCode.Should().Be((int)HttpStatusCode.OK);
var passwordResponse = (UpdateUserResponse)objectResult.Value;
passwordResponse.NewPassword.Should().Be(response.NewPassword);
}
public void UpdateUserUsernameExists()
{
UsersFacade usersFacade = new UsersFacade();
AddUserRequest addUserRequest = new AddUserRequest()
{
Username = AlphaNumericStringGenerator.GetString(10),
Password = AlphaNumericStringGenerator.GetString(10),
PasswordConfirm = AlphaNumericStringGenerator.GetString(10)
};
AddUserRequest addUserRequest2 = new AddUserRequest()
{
Username = AlphaNumericStringGenerator.GetString(10),
Password = AlphaNumericStringGenerator.GetString(10),
PasswordConfirm = AlphaNumericStringGenerator.GetString(10)
};
AddUserResponse addUserResponse = usersFacade.AddUser(addUserRequest);
AddUserResponse addUserResponse2 = usersFacade.AddUser(addUserRequest2);
Assert.AreEqual(HttpStatusCode.OK, addUserResponse.Status);
UpdateUserRequest updateUserRequest = new UpdateUserRequest()
{
Username = addUserResponse.Username,
Password = AlphaNumericStringGenerator.GetString(10)
};
UpdateUserResponse updateUserResponse = usersFacade.UpdateUser(addUserResponse2.UserId, updateUserRequest);
Assert.AreEqual(HttpStatusCode.BadRequest, updateUserResponse.Status);
}
private static void UpdateUser(String OldUserName, String NewUserName, String NewPath)
{
if (String.IsNullOrEmpty(Token))
{
stsClient = new AmazonIdentityManagementServiceClient(AccessKeyId, SecretKey, iamconfig);
}
else
{
stsClient = new AmazonIdentityManagementServiceClient(AccessKeyId, SecretKey, Token, iamconfig);
}
UpdateUserRequest req = new UpdateUserRequest(OldUserName);
if (!String.IsNullOrEmpty(NewUserName))
{
req.NewUserName = NewUserName;
}
if (!String.IsNullOrEmpty(NewPath))
{
req.NewPath = NewPath;
}
try
{
UpdateUserResponse response = stsClient.UpdateUser(req);
Console.WriteLine("User updated");
}
catch (Exception ex)
{
Console.WriteLine("Error occured while creating user. " + ex.ToString());
}
}
public async Task <ActionResult <UpdateUserResponse> > UpdateUserDetails([FromBody] UpdateUserRequest updateUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
try
{
var result = await _repository.UpdateDetails(
new UserEntity
{
UserId = User.Claims.GetUserId(),
Name = updateUser.Name,
Password = updateUser.Password,
IsMale = updateUser.IsMale,
DateOfBirth = updateUser.DateOfBirth
});
var response = new UpdateUserResponse
{
Email = result.Email,
Name = result.Name,
Password = result.Password,
IsMale = result.IsMale,
DateOfBirth = result.DateOfBirth
};
return(Ok(response));
}
catch (Exception)
{
return(StatusCode(500));
}
}
public UpdateUserResponse Update(UpdateUserRequest request)
{
var response = new UpdateUserResponse();
try
{
//var user = request.MapTo<User>();
var user = DataContext.Users.Include(u => u.Role).First(x => x.Id == request.Id).MapTo <User>();
user.Role = DataContext.RoleGroups.First(x => x.Id == request.RoleId);
user.FullName = request.FullName;
user.SignatureImage = request.SignatureImage;
user.Username = request.Username;
user.IsActive = request.IsActive;
user.ChangeModel = request.ChangeModel;
if (request.ChangePassword && request.Password != null)
{
user.PasswordSalt = crypto.Salt != null ? crypto.Salt : crypto.GenerateSalt(crypto.HashIterations, crypto.SaltSize);
user.Password = crypto.Compute(request.Password, user.PasswordSalt);
}
DataContext.Users.Attach(user);
DataContext.Entry(user).State = EntityState.Modified;
DataContext.SaveChanges();
response.IsSuccess = true;
response.Message = "User item has been updated successfully";
}
catch (DbUpdateException dbUpdateException)
{
response.Message = dbUpdateException.Message;
}
return(response);
}
public async Task <ActionResult <UpdateUserResponse> > UpdateUser(int userId, UpdateUserRequest request)
{
var response = new UpdateUserResponse();
var user = await _userService.GetUserAsync(userId);
if (user is null)
{
return(NotFound());
}
try
{
_mapper.Map(request, user);
response = _userService.UpdateUser(user);
return(Ok(response));
}
catch (Exception e)
{
response.Message = e.Message;
response.Success = false;
return(BadRequest(response));
}
}
public async Task ToAuthenticateAndUserExist_TokenIsReturnedAsync()
{
var loggerMock = Mock.Of <ILogger <AccountManagerService> >();
var clientFactoryMock = new Mock <IClientFactory>();
var clientMock = new Moq.Mock <ResourceAccess.ResourceAccessClient>();
var expectedResponse = new GetUserOnUserNameResponse
{
User = new UserMessage
{
Firstname = "Firstname",
Lastname = "Lastname",
UserId = Guid.NewGuid().ToString(),
Role = "User",
UserName = "******",
}
};
var fakeCall = TestCalls.AsyncUnaryCall <GetUserOnUserNameResponse>(Task.FromResult(expectedResponse), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });
clientMock.Setup(m => m.GetUserOnUserNameAsync(Moq.It.IsAny <GetUserOnUserNameRequest>(), null, null, CancellationToken.None)).Returns(fakeCall);
var expectedUpdateResponse = new UpdateUserResponse
{
User = new UserMessage
{
Firstname = "Firstname",
Lastname = "Lastname",
UserId = Guid.NewGuid().ToString(),
Role = "User",
UserName = "******"
}
};
expectedUpdateResponse.User.RefreshTokens.Add(new RefreshTokenMessage
{
CreatedByIp = "123",
Token = "123123",
});
var fakeUIpdateCall = TestCalls.AsyncUnaryCall <UpdateUserResponse>(Task.FromResult(expectedUpdateResponse), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });
clientMock.Setup(m => m.UpdateUserAsync(Moq.It.IsAny <UpdateUserRequest>(), null, null, CancellationToken.None)).Returns(fakeUIpdateCall);
clientFactoryMock.Setup(c => c.AccountResourceAccessClient()).Returns(clientMock.Object);
var testoption = Options.Create(new AppSettings {
SecretString = "secretStuff!ddddddddddddddddddddddddddddddddddddddddddddddddddddddgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg"
});
var service = new AccountManagerService(loggerMock, clientFactoryMock.Object, testoption);
AuthenticateResponse authResponse = await service.Authenticate(new AuthenticateRequest { HashedPassword = "******", IpAddress = "123", UserName = "******" }, null);
Assert.False(string.IsNullOrEmpty(authResponse.JwtToken));
Assert.False(string.IsNullOrEmpty(authResponse.RefreshToken));
Assert.False(string.IsNullOrEmpty(authResponse.Role));
Assert.False(string.IsNullOrEmpty(authResponse.UserId));
Assert.False(string.IsNullOrEmpty(authResponse.UserName));
}
public async Task <UpdateUserResponse> UpdateUser(UpdateUserRequest o)
{
var result = new UpdateUserResponse(o.RequestId);
result.Application = o.Application;
result.Updated = await Server.UpdateUserProfileById(o.Id, o.FirstName, o.LastName, o.Email, o.Phone);
return(result);
}
public async Task <UpdateUserResponse> UpdateUser(UpdateUserRequest request)
{
var sessionUser = await _sessionManager.GetUser();
var response = new UpdateUserResponse();
var duplicateResponse = await _accountService.DuplicateUserCheck(new DuplicateUserCheckRequest()
{
EmailAddress = request.EmailAddress,
Username = request.Username,
MobileNumber = request.MobileNumber,
UserId = request.Id
});
if (duplicateResponse.Notifications.HasErrors)
{
response.Notifications.Add(duplicateResponse.Notifications);
return(response);
}
using (var uow = _uowFactory.GetUnitOfWork())
{
var user = await uow.UserRepo.GetUserById(new Repositories.DatabaseRepos.UserRepo.Models.GetUserByIdRequest()
{
Id = request.Id
});
var dbRequest = new Repositories.DatabaseRepos.UserRepo.Models.UpdateUserRequest()
{
Id = request.Id,
Username = request.Username,
First_Name = request.FirstName,
Last_Name = request.LastName,
Mobile_Number = request.MobileNumber,
Email_Address = request.EmailAddress,
Updated_By = sessionUser.Id,
};
await uow.UserRepo.UpdateUser(dbRequest);
uow.Commit();
}
await CreateOrDeleteUserRoles(request.RoleIds, request.Id, sessionUser.Id);
await _sessionManager.WriteSessionLogEvent(new Models.ManagerModels.Session.CreateSessionLogEventRequest()
{
EventKey = SessionEventKeys.UserUpdated,
Info = new Dictionary <string, string>()
{
{ "User_Id", request.Id.ToString() }
}
});
response.Notifications.Add($"User {request.Username} has been updated", NotificationTypeEnum.Success);
return(response);
}
public static UpdateUserResponse Unmarshall(UnmarshallerContext context)
{
UpdateUserResponse updateUserResponse = new UpdateUserResponse();
updateUserResponse.HttpResponse = context.HttpResponse;
updateUserResponse.RequestId = context.StringValue("UpdateUser.RequestId");
updateUserResponse.Success = context.BooleanValue("UpdateUser.Success");
return(updateUserResponse);
}
public UpdateUserResponse UpdateUser(UpdateUserRequest request)
{
RestRequest restRequest = new RestRequest("Account/UpdateUser", Method.POST);
restRequest.AddJsonBody(request);
UpdateUserResponse response = _client.Execute <UpdateUserResponse>(restRequest).Data;
return(response);
}
public UpdateUserResponse UpdateUser(User request)
{
var response = new UpdateUserResponse {
Errors = new List <string>()
};
_userRepository.Update(request);
response.Success = true;
return(response);
}
public void Handle(UpdateUserResponse response)
{
if (response.SuccessFul)
{
ActionResult = new OkObjectResult(MapToUserModel(response.User));
}
else
{
ActionResult = response.NotFound ? (IActionResult) new NotFoundResult() : new ConflictResult();
}
}
public UserProfilePage()
{
InitializeComponent();
_objUserDetailsResponse = new UserDetailsResponse();
_objobjUpdateUserResponse = new UpdateUserResponse();
_apiService = new RestApi();
_objHeadermodel = new HeaderModel();
_baseUrl = Domain.Url + Domain.USerDetailsApiConstant;
_baseUrlUpdate = Domain.Url + Domain.UpdateUserDetailsApiConstant;
LoadUserProfileData();
}
public UpdateUserResponse UpdateUser(UpdateUserRequest request)
{
UpdateUserResponse response = new UpdateUserResponse();
try
{
using (IUnitOfWork unitOfWork = RepositoryFactory.GetUnitOfWork())
{
if (request == null)
{
throw new Exception("null Input!");
}
IUserRepository userRepository = RepositoryFactory.Get(typeof(IUserRepository), unitOfWork) as IUserRepository;
IRoleRepository roleRepository = RepositoryFactory.Get(typeof(IRoleRepository), unitOfWork) as IRoleRepository;
User user = userRepository.GetByKey(System.Guid.Parse(request.Id));
Role role = roleRepository.GetByKey(request.RoleId);
if (user == null)
{
throw new Exception("no User in UpdateUser of UserService!");
}
if (role == null)
{
throw new Exception("no role in UpdateUser of UserService!");
}
user.Name = request.Name;
user.Password = request.Password;
user.RoleId = request.RoleId;
user.Duty = request.Duty;
user.Email = request.Email;
userRepository.Save(user);
unitOfWork.Commit();
response.IsSucess = true;
response.User = new ViewModels.UserView()
{
Id = user.Id.ToString(),
Name = user.Name,
Duty = user.Duty,
Email = user.Email,
RoleId = user.RoleId,
RoleName = role.Name
};
}
}
catch (Exception ex)
{
Log.Write(ex.Message);
response.IsSucess = false;
response.Message = ex.Message;
}
return(response);
}
public static UpdateUserResponse Unmarshall(UnmarshallerContext _ctx)
{
UpdateUserResponse updateUserResponse = new UpdateUserResponse();
updateUserResponse.HttpResponse = _ctx.HttpResponse;
updateUserResponse.Paging = _ctx.BooleanValue("UpdateUser.Paging");
updateUserResponse.RequestId = _ctx.StringValue("UpdateUser.RequestId");
updateUserResponse.Data = _ctx.BooleanValue("UpdateUser.Data");
return(updateUserResponse);
}
public static UpdateUserResponse Unmarshall(UnmarshallerContext _ctx)
{
UpdateUserResponse updateUserResponse = new UpdateUserResponse();
updateUserResponse.HttpResponse = _ctx.HttpResponse;
updateUserResponse.Code = _ctx.StringValue("UpdateUser.Code");
updateUserResponse.Data = _ctx.StringValue("UpdateUser.Data");
updateUserResponse.Message = _ctx.StringValue("UpdateUser.Message");
updateUserResponse.RequestId = _ctx.StringValue("UpdateUser.RequestId");
return(updateUserResponse);
}
public ActionResult CheckPassword(ChangePasswordViewModel model)
{
var response = new UpdateUserResponse();
response = _userService.CheckPassword(new CheckPasswordRequest { Name = User.Identity.Name, Password = model.Old_Password });
if (response.IsSuccess)
{
return Json(true, JsonRequestBehavior.AllowGet);
}
else
{
return Json(false, JsonRequestBehavior.AllowGet);
}
}
public UpdateUserResponse CheckPassword(CheckPasswordRequest request)
{
var response = new UpdateUserResponse();
var user = DataContext.Users.First(x => x.Username == request.Name);
if (user != null && request.Password != null && user.Password == crypto.Compute(request.Password, user.PasswordSalt))
{
//Include(x => x.Role).
response.IsSuccess = true;
}
else
{
response.IsSuccess = false;
response.Message = string.Format("Your current password isn't correct");
}
return response;
}
// Update
public UpdateUserResponse UpdateUser(UpdateUserRequest request)
{
var response = new UpdateUserResponse();
try
{
Guard.ArgNotNull(request, "request");
User user = _unitOfWork.UserRepository.GetById(request.Id);
Guard.ArgNotNull(user, "user");
user.LoginName = request.LoginName;
user.Email = request.Email;
user.AvatarImage = request.AvatarImage;
_unitOfWork.UserRepository.Update(user);
_unitOfWork.Save();
response.Success = true;
Logger.LogInfo("Successfully updated User Id: " + request.Id.ToString(), LogType.General);
if (!response.Success)
{
string errorString = "Unknown failure updating User Id: " + request.Id.ToString();
response.FailureInformation = errorString;
Logger.LogWarning(errorString, null);
}
}
catch (Exception ex)
{
response.Success = false;
response.FailureInformation = ex.Message;
Logger.LogError("UpdateUser method failed", ex);
}
return response;
}
public UpdateUserResponse Update(UpdateUserRequest request)
{
var response = new UpdateUserResponse();
try
{
var user = request.MapTo<User>();
user.Role = DataContext.RoleGroups.First(x => x.Id == request.RoleId);
if (request.ChangePassword && request.Password != null)
{
user.Password = crypto.Compute(request.Password);
user.PasswordSalt = crypto.Salt;
}
DataContext.Users.Attach(user);
DataContext.Entry(user).State = EntityState.Modified;
DataContext.SaveChanges();
response.IsSuccess = true;
response.Message = "User item has been updated successfully";
}
catch (DbUpdateException dbUpdateException)
{
response.Message = dbUpdateException.Message;
}
return response;
}
public UpdateUserResponse Update(UpdateUserRequest request)
{
crypto.HashIterations = 10;
crypto.SaltSize = 12;
var response = new UpdateUserResponse();
try
{
//var user = request.MapTo<User>();
var user = DataContext.Users.Include(u => u.Role).Include(r=>r.RolePrivileges).First(x => x.Id == request.Id).MapTo<User>();
user.Role = DataContext.RoleGroups.First(x => x.Id == request.RoleId);
user.FullName = request.FullName;
user.RolePrivileges.Clear();
if (request.RolePrivilegeIds.Count > 0)
{
foreach (var role in request.RolePrivilegeIds)
{
var rolePrivilege = DataContext.RolePrivileges.Find(role);
user.RolePrivileges.Add(rolePrivilege);
}
}
user.SignatureImage = request.SignatureImage;
user.Position = request.Position;
user.Username = request.Username;
user.IsActive = request.IsActive;
user.ChangeModel = request.ChangeModel;
if (request.ChangePassword && request.Password != null)
{
user.PasswordSalt = crypto.GenerateSalt(crypto.HashIterations, crypto.SaltSize);
user.Password = crypto.Compute(request.Password, user.PasswordSalt);
}
DataContext.Users.Attach(user);
DataContext.Entry(user).State = EntityState.Modified;
DataContext.SaveChanges();
response.IsSuccess = true;
response.Message = "User item has been updated successfully";
}
catch (DbUpdateException dbUpdateException)
{
response.Message = dbUpdateException.Message;
}
return response;
}
