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