public ActionResult ChangePassword(UpdateAccount _user)
{
string message = "";
bool status = false;
if (ModelState.IsValid)
{
var currentUser = (ClaimsPrincipal)Thread.CurrentPrincipal;
var UserId = currentUser.Claims.Where(x => x.Type == ClaimTypes.PrimarySid).Select(c => c.Value).SingleOrDefault();
int UserID = int.Parse(UserId);
_user.CurrentPassword = new Helper().Encrypt(_user.CurrentPassword);
tblUser user = users.GetByID(x => x.UserId == UserID && x.Password == _user.CurrentPassword);
if (user != null)
{
user.Password = new Helper().Encrypt(_user.ConfirmPassword);
users.Edit(user);
users.Save();
return(RedirectToAction("Logout"));
}
else
{
TempData["valid"] = "You Enter Wrong Current Password";
}
}
return(View());
}
public void Handle(UpdateAccount command)
{
var account = _repository.Find(command.AccountId);
account.Update(command.Name);
_repository.Save(account, command.Id.ToString());
}
public object Any(UpdateAccount request)
{
var response = Global.RequestsProcessor.Any(request);
TransferHeader(request, response);
return(response);
}
public static void UpdatePassword(UpdateAccount model, out string errorMessage, bool isTest = false)
{
try
{
IMembershipTools membershipTools = AppTools.InitMembershipTools(isTest);
errorMessage = string.Empty;
if (model.NewPassword.Length < 9)
{
errorMessage = "Password must be at least 9 characters and have a special character";
}
else if (model.CurrentPassword == model.NewPassword)
{
errorMessage = "New password must be different from the current password.";
}
else if (model.NewPassword != model.RepeatPassword)
{
errorMessage = "New password and repeated password does not match.";
}
else if (membershipTools.UpdatePassword(model.UserName, model.NewPassword) == false)
{
errorMessage = "Error updating account.";
}
}
catch (Exception ex)
{
DBCommands.RecordError(ex);
errorMessage = ex.Message;
}
}
/// <inheritdoc/>
public IAccount Update(int accountId, UpdateAccount @params)
{
#region Check arguments
if (@params is null)
{
throw new ArgumentNullException(nameof(@params));
}
if (@params.Contacts != null && !ValidateContacts(@params.Contacts))
{
throw new UnsupportedContactException();
}
#endregion
// Get account
var account = GetById(accountId);
// Assign values
OnUpdateParams(account, @params);
// Save changes
account = AccountRepository.Update(account);
Logger.Info("Account {id} updated", account.Id);
// Return JSON
return(account);
}
public void UpdateAccount(Guid accountId, UpdateAccount accountToUpdate)
{
using (var db = new LiteDatabase(BankBerDbLocation))
{
var userCol = db.GetCollection <Account>("Accounts");
var foundAccount = userCol.FindById(accountId);
if (foundAccount == null)
{
throw new KeyNotFoundException();
}
if (!string.IsNullOrWhiteSpace(accountToUpdate.Type))
{
foundAccount.Type = accountToUpdate.Type;
}
if (!string.IsNullOrWhiteSpace(accountToUpdate.Name))
{
foundAccount.Name = accountToUpdate.Name;
}
return;
}
}
public void UpdateAccount_Success(string name)
{
RunInitSql(name, "ConnectionStringAccounts");
// 1. initializing the session
InitSession initReq = new InitSession()
{
AccountKey = ConfigurationManager.AppSettings["AccountKey"],
RequestID = "D3770630-9532-457D-8EBB-DBF99F6A23D3",
SessionToken = null
};
InitSessionResponse initResp = Post <InitSession, InitSessionResponse>("InitSession", initReq);
string sessionToken = initResp.SessionToken;
// 2. update user
UpdateAccount updateReq = base.PrepareRequest <UpdateAccount>(name);
updateReq.SessionToken = sessionToken;
UpdateAccountResponse updateRes = Post <UpdateAccount, UpdateAccountResponse>("UpdateAccount", updateReq);
RunFinalizeSql(name, "ConnectionStringAccounts");
Assert.True(updateRes.Success, "Account was not updated - success = false");
Assert.IsEmpty(updateRes.Errors, "Unexpected errors returned");
}
public UpdateAccount GetUpdateAccountDto(Application app, Applicant applicant, string userToken)
{
var stubServiceRepo = Substitute.For <ISoapRepository>();
var stubLmsRepo = Substitute.For <ILmsRepository>();
var fakeBehavior = new UpdateAccountBehavior(app, userToken, stubServiceRepo, stubLmsRepo);
var account = new UpdateAccount()
{
Message = new Dto.Soap.Message()
{
DataUpdate = new DataUpdate()
{
TraceNumber = "1266523457",
ProcessingCode = "ExternalUpdateRequest",
Source = "LoanOrigination",
UpdateAction = "Modify",
Account = new Account()
{
AccountNumber = "9000000000007",
LoanOfficerName = "Steve Higgs",
AccountOpenDate = "2019-05-20",
ProductName = "Test Gold",
RateClass = "Promo Test Gold",
CreditLimit = 40000.00m,
TaxOwnerPartyId = "5597",
TaxOwnerPartyType = "Person",
UserFields = fakeBehavior.GetUserFields(applicant)
},
ModifiedFields = fakeBehavior.GetModifiedFields(applicant)
}
}
};
return(account);
}
public ActionResult <int> UpdateAccount(UpdateAccount account)
{
// check exists account
var userid = _Data.BaseMYSQL.GetScalarValue($@"
SELECT id FROM Accounts WHERE email = '{account.Email}'
");
if (userid == null || Convert.ToString(userid) == "")
{
throw new Exception("Email has not existed to login.");
}
var sql = $@"
START TRANSACTION;
UPDATE `Accounts` SET
phone = '{account.Phone}',
email = '{account.Email}'
WHERE id = {Convert.ToString(userid)};
UPDATE `PersonInfo` SET
full_Name = '{account.FullName}',
id_card = '{account.IdCard}',
address = '{account.Address}',
avatar = '{account.Avatar}'
WHERE user_id = {Convert.ToString(userid)};
COMMIT;
";
var result = _Data.BaseMYSQL.SaveChanges(sql);
return(result);
}
public void UpdateAccount_WhenApplicationIsAnAddon_AndPrimaryPersonExistsInCCM_ShouldSuccessfullyUpdateCreditLimitInCCM()
{
// ARRANGE
_applicationAddOn = GetApplication_AddOn();
_primaryApplicant = GetApplicant();
_userToken = "aBc123";
_account = GetUpdateAccountDto(_applicationAddOn, _primaryApplicant, _userToken);
_applicationAddOn.IsAddon = true;
var credentials = new Credentials()
{
BaseUrl = "https://some.bank.or.cu/api",
Username = "******",
Password = "******",
Facility = "validFacility"
};
var credentialsHeader = GetCredentialsHeader(credentials);
var messageXml = _account.Message?.SerializeToXmlString();
messageXml = HostValueTranslator.UpdateRequestWithHostValues(
messageXml,
_applicationAddOn.HostValues.Where(hv => hv.Field1.StartsWith("UpdateAccount.")).ToList(),
_account.Message?.HostValueParentNode
);
messageXml = HostValueTranslator.UpdateRequestWithHostValues(
messageXml,
_primaryApplicant.HostValues.Where(hv => hv.Field1.StartsWith("UpdateAccount.")).ToList(),
_account.Message?.HostValueParentNode
);
var processMessageNodeRequest = new ProcessMessageNodeRequest()
{
CredentialsHeader = credentialsHeader,
request = GetXmlNode(messageXml)
};
var stubServiceRepo = Substitute.For <ISoapRepository>();
stubServiceRepo.GetProcessMessageNodeRequest(credentialsHeader, messageXml).Returns(processMessageNodeRequest);
_messageResponse = GetMessageResponseSuccess();
stubServiceRepo.UpdateAccount(_account, _applicationAddOn, _primaryApplicant).Returns(_messageResponse);
var mockBehavior = new UpdateAccountBehavior(_applicationAddOn, _userToken, stubServiceRepo);
mockBehavior.Account = _account;
// ACT
var result = mockBehavior.UpdateAccount(_primaryApplicant);
// ASSERT
Assert.AreEqual(0, result.Messages.Count(m => m.Type == MessageType.Error));
Assert.IsTrue(result.Result);
Assert.AreEqual("Success", mockBehavior.MessageResponse.ResponseCode);
}
public void UpdateAccount(Account account, Account loginUser)
{
EmployeeNames = null;
UpdateAccount updateAccount = new UpdateAccount(account, loginUser);
updateAccount.Excute();
}
public void Handle(UpdateAccount msg)
{
if (!Created)
{
throw new DomainException(string.Format("Account {0:n} does not exist.", msg.AggregateId));
}
Events.Publish(new AccountUpdated(msg.AggregateId, msg.TaxNumber, msg.EntityName, msg.Type, Version + 1));
}
public UpdateAccount GetDto(Applicant primaryApplicant)
{
var account = new UpdateAccount()
{
Message = GetMessage(primaryApplicant)
};
return(account);
}
public async Task <ActionResult> Put([FromRoute] Guid id, [FromBody] UpdateAccount command)
{
command.Id = id;
await _mediator.Send(new GetAccount()
{
Id = id
});
return(NoContent());
}
public object Put(UpdateAccount request)
{
var entity = request.ConvertTo <Account>();
return(InTransaction(db =>
{
Logic.Update(entity);
return new CommonResponse(Logic.GetById(entity.Id));
}));
}
public ActionResult ManageAccount()
{
Provider provider = new Provider();
UpdateAccount account = new UpdateAccount();
account.UserName = Membership.GetUser(User.Identity.Name).UserName;
return(View(account));
}
public async Task ChangePasswordAsync(int id, UpdateAccount command)
{
var account = await GetAsync(id);
_passwordManager.CalculatePasswordHash(command.NewPassword, out byte[] passwordHash, account.Salt);
account.Update(account.Name, account.Surname, passwordHash);
await _context.SaveChangesAsync();
}
/// <summary>
/// Update the Account
/// </summary>
/// <param name="Account">Account Model</param>
/// <returns>Updated record count</returns>
public async Task <int> UpdateAccount(UpdateAccount Account)
{
//Create AccountLocation Model
var AccountLocation = _mapper.Map <AccountLocation>(Account);
//Update the AccountLocation
var count = await _accountLocationClient.UpdateAccountLocation(AccountLocation);
//Update the Account using integrated API.
return(await _accountClient.UpdateAccount(Account));
}
public async Task <IActionResult> Update([FromBody] UpdateAccount user)
{
if (ModelState.IsValid)
{
user.UpdatedBy = User.Claims.FirstOrDefault(s => s.Type == "userName").Value;
var response = await _accountRepository.Update(user);
return(Ok(response));
}
return(BadRequest(ModelState));
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public async Task <UserViewModel> Update(UpdateAccount data)
{
var user = _userManager.Users.FirstOrDefault(f => f.Id == data.Id);
user.PhoneNumber = data.PhoneNumber;
user.FirstName = data.FirstName;
user.LastName = data.LastName;
user.Department = data.Department;
user.Position = data.Position;
user.Gender = data.Gender;
user.Birthday = data.Birthday;
user.Code = data.Code;
user.Address = data.Address;
user.UpdatedAt = DateTime.UtcNow;
user.UpdatedBy = data.UpdatedBy;
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
var companyId = _httpContextAccessor.HttpContext.Request?.Headers["CompanyId"].FirstOrDefault();
var userRole = await _accessRightRepository.Roles(companyId, user.Id);
var response = new UserViewModel
{
Id = user.Id,
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
Position = user.Position,
Gender = user.Gender,
Birthday = user.Birthday,
PhoneNumber = user.PhoneNumber,
AvatarUrl = user.AvatarUrl,
Code = user.Code,
Department = user.Department,
Address = user.Address,
CreatedAt = user.CreatedAt,
CreatedBy = user.CreatedBy,
UpdatedAt = user.UpdatedAt,
UpdatedBy = user.UpdatedBy,
RequiredChangePassword = user.RequiredChangePassword,
Roles = userRole
};
return(response);
}
else
{
throw new Exception(result.Errors.FirstOrDefault().Code);
}
}
public ResponseBase Any(UpdateAccount request)
{
_logger.Log(EErrorType.Info, " ****** Call start: UpdateAccount");
UpdateAccountResponse response = new UpdateAccountResponse();
try
{
SessionInfo sessionParams = new SessionInfo();
sessionParams.SessionId = request.SessionToken;
SessionInfo sessionInfo = _dal.GetSessionInfo(sessionParams, true);
if (sessionInfo != null)
{
CreateUpdateUserAccountParams updateParams = new CreateUpdateUserAccountParams();
updateParams.AccountKey = sessionInfo.AccountKey;
updateParams.Email = request.Email ?? null;
updateParams.Name = request.Name ?? null;
updateParams.PwdHash = !string.IsNullOrEmpty(request.Pwd) ? EncodeUtils.GetPasswordHash(request.Pwd) : null;
updateParams.State = request.State ?? null;
_dal.UpdateUserAccount(updateParams);
response.Success = true;
}
else
{
response.Success = false;
response.Errors.Add(new Error()
{
Code = EErrorCodes.InvalidSession, Type = EErrorType.Error, Message = "Invalid session"
});
}
}
catch (Exception ex)
{
_logger.Log(ex);
response.Success = false;
response.Errors.Add(new Error()
{
Code = EErrorCodes.GeneralError,
Type = EErrorType.Error,
Message = string.Format("Unexpected error: {0}", ex.Message)
});
}
_logger.Log(EErrorType.Info, " ****** Call end: UpdateAccount");
return(response);
}
public async Task <IActionResult> AccountUpdate([FromBody] UpdateAccount command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try {
await _accountService.UpdateAsync(UserId, command.Name, command.Surname, command.Email,
command.PhoneNumber, command.CompanyName, command.Location, command.CompanyDescription);
return(StatusCode(200));
} catch (Exception e) {
return(BadRequest(e.Message));
}
}
public async Task UpdateAccount(UpdateAccount cmd)
{
await _repo.UpdateAccount(cmd);
var tpl = _emailTemplates.Single(m =>
m.TemplateName == "AccountUpdated");
await _bus.Publish(
new SendMail
{
ToName = cmd.Name,
ToEmail = cmd.Email,
Subject = tpl.Subject,
Body = tpl.Body.FormatWith(cmd.Name)
});
}
public void UpdatePassword_ReturnString(string cPassword, string nPassword, string rPassword, string userName, bool expected)
{
UpdateAccount model = new UpdateAccount();
model.CurrentPassword = cPassword;
model.NewPassword = nPassword;
model.RepeatPassword = rPassword;
model.UserName = userName;
string errorMessage;
bool isEmpty;
UserManager.UpdatePassword(model, out errorMessage, true);
isEmpty = string.IsNullOrEmpty(errorMessage);
Assert.IsTrue(isEmpty == expected);
}
public BaseResult UpdateAccount(Applicant primaryApplicant)
{
var result = new BaseResult();
using (var tr = new Tracer("LMS.Connector.CCM.Behaviors.Soap.UpdateAccountBehavior.UpdateAccount"))
{
tr.Log($"UpdateAccount for ApplicantId {primaryApplicant.ApplicantId}, PersonNumber => {primaryApplicant.PersonNumber}");
tr.Log($"UpdateAccount _account null? => {_account == null}");
if (_account == null)
{
tr.Log("Call GetDto() to get new _account");
_account = GetDto(primaryApplicant);
}
tr.LogObject(_account);
try
{
tr.Log("Calling ISoapRepository.UpdateAccount");
_messageResponse = _soapRepository.UpdateAccount(_account, _app, primaryApplicant);
tr.Log($"_messageResponse.ResponseCode = {_messageResponse?.ResponseCode}");
tr.Log($"_messageResponse.ErrorMessage = {_messageResponse?.ErrorMessage}");
}
catch (Exception ex)
{
tr.LogException(ex);
result.Result = false;
result.ExceptionId = Utility.LogError(ex, "LMS.Connector.CCM.Behaviors.Soap.UpdateAccountBehavior.UpdateAccount");
result.AddMessage(MessageType.Error, $"Exception when attempting to call SOAP Repository UpdateAccount(): {ex.Message}");
}
finally
{
// Deallocate DTO
_account = null;
}
if (_messageResponse?.ResponseCode != "Success" && _messageResponse?.ErrorMessage?.Length > 0)
{
result.Result = false;
result.AddMessage(MessageType.Error, _messageResponse.ErrorMessage);
}
}
return(result);
}
public MessageResponse UpdateAccount(UpdateAccount account, Application app, Applicant applicant)
{
MessageResponse messageResponse = null;
string messageXml = string.Empty;
using (var tr = new Tracer("LMS.Connector.CCM.Repositories.SoapRepository.UpdateAccount"))
{
try
{
messageXml = account.Message?.SerializeToXmlString();
tr.Log($"UpdateAccount: BEFORE setting host values => {messageXml}");
tr.Log("UpdateAccount: Set Application-level host values ");
messageXml = HostValueTranslator.UpdateRequestWithHostValues(
messageXml,
app.HostValues.Where(hv => hv.Field1.StartsWith("UpdateAccount.")).ToList(),
account.Message?.HostValueParentNode
);
tr.Log($"UpdateAccount: AFTER Application-level host values => {messageXml}");
tr.Log("UpdateAccount: Set Applicant-level host values");
messageXml = HostValueTranslator.UpdateRequestWithHostValues(
messageXml,
applicant.HostValues.Where(hv => hv.Field1.StartsWith("UpdateAccount.")).ToList(),
account.Message?.HostValueParentNode
);
tr.Log($"UpdateAccount: AFTER Applicant-level host values => {messageXml}");
tr.LogObject(CredentialsHeader);
tr.Log("UpdateAccount: Calling ISoapRepository.ProcessMessage");
messageResponse = ProcessMessage(messageXml);
}
catch (Exception ex)
{
// Handle serialization and host value translation exceptions here
tr.LogException(ex);
Utility.LogError(ex, "LMS.Connector.CCM.Repositories.SoapRepository.UpdateAccount");
throw;
}
}
return(messageResponse);
}
/// <summary>
/// Update thông tin cá nhân
/// Author : HoangNM - 29/03/2019 - create
/// </summary>
/// <param name="account">
/// thông tin mà người dùng muốn thay đổi
/// </param>
/// <returns>
/// Thông báo
/// </returns>
public ResponseInfo UpdateAccount(UpdateAccount account)
{
DbContextTransaction transaction = context.Database.BeginTransaction();
ResponseInfo response = new ResponseInfo();
try
{
string token = HttpContext.Current.Request.Cookies["ToKen"].Value.Replace("%3d", "=");
token = BaoMat.Base64Decode(token);
TblToken TblToken = context.Tokens.FirstOrDefault(x => x.TokenTaiKhoan == token);
if (account.New_Passord != "" && string.Compare(account.New_Passord, account.Confirm_Password) == 0)
{
string Hash_Pass = BaoMat.GetMD5(BaoMat.GetSimpleMD5(account.New_Passord), context.TaiKhoans.Where(x => x.Id == TblToken.TaiKhoan.Id && !x.DelFlag).FirstOrDefault().salt_Pass);
//cập nhật mật khẩu
context.TaiKhoans.Where(x => x.Id == TblToken.TaiKhoan.Id && !x.DelFlag).Update(y => new TblTaiKhoan
{
hash_Pass = Hash_Pass
});
}
context.ThongTinNguoiDungs.Where(x => x.Id == TblToken.TaiKhoan.ThongTinNguoiDung.Id && !x.DelFlag).Update(x => new TblUser
{
Ten = account.Ten,
NgaySinh = account.NgaySinh,
GioiTinh = account.GioiTinh
});
context.SaveChanges();
response.IsSuccess = true;
transaction.Commit();
var errorMsg = new GetErrorMsg().GetMsg((int)MessageEnum.MsgNO.CapNhatThongTinThanhCong);
response.TypeMsgError = errorMsg.Type;
response.MsgError = errorMsg.Msg;
}
catch (Exception e)
{
response.IsSuccess = false;
transaction.Rollback();
throw e;
}
return(response);
}
private void EditAccount(object sender, MouseButtonEventArgs e)
{
try
{
DataGrid dg = sender as DataGrid;
AdminDataGrid p = (AdminDataGrid)dg.SelectedItems[0]; // OR: Patient p = (Patient)dg.SelectedItem;
UpdateAccount up = new UpdateAccount(p);
up.UserRole.SelectedItem = p.StaffDBRole;
up.ShowDialog();
}
catch (Exception error)
{
}
Refresh_AdminGrid(sender, e);
}
private void EditAccount(object sender, MouseButtonEventArgs e)
{
try
{
DataGrid dg = sender as DataGrid;
AdminDataGrid p = (AdminDataGrid)dg.SelectedItems[0]; // OR: Patient p = (Patient)dg.SelectedItem;
UpdateAccount up = new UpdateAccount(p);
up.UserRole.SelectedItem = p.StaffDBRole;
up.ShowDialog();
}
catch (Exception error)
{
}
Refresh_AdminGrid(sender, e);
}
public async Task UpdateAccount(UpdateAccount cmd)
{
using (var conn = new MySqlConnection(_connStr))
{
await conn.ExecuteAsync(updAccount, new
{
id = cmd.Id,
name = cmd.Name,
email = cmd.Email
});
await InsertLog(
conn,
cmd.Id,
EventType.AccountUpdated,
data : $"name '{cmd.Name}' and email '{cmd.Email}'");
}
}
public ActionResult ManageAccount(UpdateAccount account, string returnUrl)
{
Provider provider = new Provider();
if (ModelState.IsValid)
{
string errorMessage = string.Empty;
UserManager.UpdatePassword(account, out errorMessage);
if (string.IsNullOrEmpty(errorMessage))
{
return(ManageReturnUrl(returnUrl));
}
ModelState.AddModelError("", errorMessage);
}
return(View());
}
public HttpResponseMessage Put(UpdateAccount model)
{
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(
HttpStatusCode.BadRequest, ModelState);
}
var account = DataContext.Accounts.Find(model.Id);
if ((account == null) || (account.UserId != UserId))
{
return Request.CreateResponse(HttpStatusCode.NotFound);
}
account.Merge(model);
DataContext.SaveChanges();
return Request.CreateResponse(HttpStatusCode.NoContent);
}
public void Update_Account()
{
var probe = CreateTestProbe("probe");
var accountRef = PrepareTest(accountId, probe, "1");
var commandCreate = new CreateAccount(accountId, "123456", "TestAccount", AccountType.Individual);
accountRef.Tell(commandCreate);
probe.ExpectMsg<AccountCreated>(new AccountCreated(accountId, "123456", "TestAccount", AccountType.Individual, 1));
var commandUpdate = new UpdateAccount(accountId, "123456", "Test Account", AccountType.Individual);
accountRef.Tell(commandUpdate);
probe.ExpectMsg<AccountUpdated>(new AccountUpdated(accountId, "123456", "Test Account", AccountType.Individual, 2));
}
public void Handle(UpdateAccount msg)
{
if (!Created)
throw new DomainException(string.Format("Account {0:n} does not exist.", msg.AggregateId));
Events.Publish(new AccountUpdated(msg.AggregateId, msg.TaxNumber, msg.EntityName, msg.Type, Version + 1, ContextHelper.CreateFromCommand(msg)));
}
