public async Task <IActionResult> Updatepassword(PasswordRequest pas) { string userName = HttpContext.Session.GetString("UserName"); int? userId = HttpContext.Session.GetInt32("UserId"); log.InfoFormat(userName + " || Get into 修改密码"); try { pas.UserId = userId; var t = await _userManager.Psupdate(pas); if (t) { ViewData["Bool"] = 1; } log.InfoFormat("修改密码成功"); ViewData["UserName"] = userName; return(View()); } catch (Exception e) { log.Error("修改密码失败,错误提示: " + Helper.JsonHelper.ToJson(e)); return(View("Error", e)); } }
public static void Run() { // ExStart:1 CellsApi cellsApi = new CellsApi(Common.APP_KEY, Common.APP_SID, Common.BASEPATH); StorageApi storageApi = new StorageApi(Common.APP_KEY, Common.APP_SID, Common.BASEPATH); String fileName = "Sample_Test_Book.xls"; String storage = ""; String folder = ""; PasswordRequest body = new PasswordRequest(); body.Password = "******"; try { // Upload source file to aspose cloud storage storageApi.PutCreate(fileName, "", "", System.IO.File.ReadAllBytes(Common.GetDataDir() + fileName)); // Invoke Aspose.Cells Cloud SDK API to set modify password SaaSposeResponse apiResponse = cellsApi.PutDocumentProtectFromChanges(fileName, storage, folder, body); if (apiResponse != null && apiResponse.Status.Equals("OK")) { Console.WriteLine("Password is changed!"); Console.ReadKey(); } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("error:" + ex.Message + "\n" + ex.StackTrace); } // ExEnd:1 }
public ActionResult UpdatePassword([ModelBinder(typeof(PasswordRequestModelBinder))] PasswordRequest passwordRequest) { //validate password check password satisfies the complexity rules if (!this.ModelState.IsValid) { Response.StatusCode = (int)HttpStatusCode.BadRequest; return(Json(new { success = false, errorMessage = "invalid request" })); } //call api to reset the password //get the current user var user = _authenticationManager.User; if (user == null) { return(UnauthorisedJson()); } var subClaim = user.Claims.FirstOrDefault(c => c.Type == "sub"); if (subClaim == null) { return(UnauthorisedJson()); } var response = _coreClient.UpdatePassword(subClaim.Value, passwordRequest); if (!response.Errored) { return(Json(new { success = true })); } Response.StatusCode = (int)HttpStatusCode.BadRequest; return(Json(new { success = false })); }
/// <summary> /// 获取当前密保问题 /// </summary> /// <param name="param"></param> /// <returns></returns> public async Task <Result <QuestionInfo> > GetCurrentQuestionByUserAsync(PasswordRequest param) { var result = new Result <QuestionInfo>(); //验证密码 var userExist = readOnlyContext.Users.Any(a => a.ID == currentUser.UserID && a.Password == param.Password); if (!userExist) { result.Code = "password error"; result.Msg = "密码错误"; return(result); } //获取密保问题 var currentQuestion = await masterContext.UserSecurityQuestions.Where(a => a.UserID == currentUser.UserID).Include(a => a.SecurityQuestion)?.FirstOrDefaultAsync(); if (currentQuestion == null) { result.Code = "no security question"; result.Msg = "没有密保问题"; return(result); } //密保问题映射实体 var questionInfo = Mapper.Map <QuestionInfo>(currentQuestion.SecurityQuestion); questionInfo.QuestionContent = questionInfo.QuestionContent.JsonToObj <MultipleLanguage>().GetContent(param.Lang); result.Data = questionInfo; result.IsSuccess = true; return(result); }
public async Task <IActionResult> EditUserPassword(int id, PasswordRequest password) { DataResponse response = new DataResponse(); try { var user = await _userService.GetByPassword(id, password.OldPassword); if (user == null) { response.Message = "The user or password does not exist."; return(Ok(response)); } await _userService.EditPassword(user, password.NewPassword); response.Success = 1; response.Message = "The password has been edited."; return(Ok(response)); } catch (Exception ex) { response.Message = ex.Message; return(StatusCode(500, response)); } }
public async Task <bool> ChangePasswordAsync(string oldPassword, string newPassword) { if (oldPassword == null) { throw new ArgumentNullException("oldPassword"); } if (newPassword == null) { throw new ArgumentNullException("newPassword"); } var address = baseAddress.WithResource("password"); PasswordRequest data = new PasswordRequest { old_password = oldPassword, new_password = newPassword }; string content = contentSerializer.Serialize(data); IHttpRequest request = new HttpRequest(HttpMethod.Post, address.Build(), baseHeaders, content); IHttpResponse response = await httpFacade.RequestAsync(request); HttpUtils.ThrowOnBadStatus(response, contentSerializer); return(contentSerializer.Deserialize <PasswordResponse>(response.Body).success ?? false); }
public async Task <IActionResult> ChangeUserPassword(int id, [FromBody] PasswordRequest passwordRequest) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (passwordRequest.OldPassword == null || passwordRequest.NewPassword == null) { return(BadRequest()); } ApplicationUser user = await usermanager.FindByIdAsync(id.ToString()); if (user == null) { return(NotFound()); } IdentityResult result = await usermanager.ChangePasswordAsync(user, passwordRequest.OldPassword, passwordRequest.NewPassword); if (result.Succeeded) { return(Ok()); } return(BadRequest(result.Errors)); }
public async Task <IActionResult> Edit(int id, [Bind("RequestId,LoginId,NewPassword,RequestDate,Status")] PasswordRequest passwordRequest) { if (id != passwordRequest.RequestId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(passwordRequest); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!PasswordRequestExists(passwordRequest.RequestId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["LoginId"] = new SelectList(_context.Login, "LoginId", "LoginId", passwordRequest.LoginId); return(View(passwordRequest)); }
public async Task <Response> Enviar(PasswordRequest contrasenaRequest) { try { //Configuring webMail class to send emails //gmail smtp server WebMail.SmtpServer = CorreoUtil.SmtpServer; //gmail port to send emails WebMail.SmtpPort = Convert.ToInt32(CorreoUtil.Port); WebMail.SmtpUseDefaultCredentials = true; //sending emails with secure protocol WebMail.EnableSsl = true; //EmailId used to send emails from application WebMail.UserName = CorreoUtil.UserName; WebMail.Password = CorreoUtil.Password; //Sender email address. WebMail.From = CorreoUtil.UserName; //Send email WebMail.Send(to: contrasenaRequest.Email, subject: "Código de Seguridad: " + contrasenaRequest.Codigo, body: "Código de seguridad: " + contrasenaRequest.Codigo, isBodyHtml: true); return(new Response { IsSuccess = true }); } catch (Exception ex) { return(new Response { IsSuccess = false, Message = ex.Message }); throw; } }
public IActionResult Password(PasswordRequest request) { ValidateEntity <PasswordRequest>(request); string username = request.Username; if (String.IsNullOrWhiteSpace(username)) { username = Context.Current.User.Username; } LoginOutput loginOutput = Business.User.Login(username, request.Old); if (loginOutput.Result == LoginResult.Failed) { throw new ApiAccessDeniedException(Messages.WrongPassword); } if (request.Old == request.New) { throw new ApplicationException(Messages.PasswordChangeSame); } if (request.New != request.Confirm) { throw new ApplicationException(Messages.PasswordDontMatch); } Business.User.ChangePassword(username, request.Old, request.New); return(GetOutput()); }
public async Task <bool> RecoveryPass(string email, string password, string confirmPassword, int codigo) { var client = new HttpClient(); if (password == confirmPassword) { var model = new PasswordRequest { Email = email, Codigo = codigo, NewPassword = password }; var json = JsonConvert.SerializeObject(model); HttpContent httpContent = new StringContent(json); httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json"); var response = await client.PostAsync( Constants.BaseApiAddress + "api/Account/RecoveryPass", httpContent); if (response.IsSuccessStatusCode) { return(true); } } return(false); }
public IActionResult PasswordValidation(PasswordRequest passwordRequest) { try { if (string.IsNullOrEmpty(passwordRequest?.Password)) { Log.Warning("Password cannot empy or null."); return(StatusCode(403, "Password cannot empy or null.")); } Log.Information("Send to service Validation."); var result = validationService.ValidationPassaword(passwordRequest.Password); if (result.IsValid) { Log.Information("Minimum password requirement has been met."); return(StatusCode(200, result)); } Log.Information("Minimum password requirement has not been met."); return(StatusCode(400, result)); } catch (Exception ex) { Log.Error($"An erro in proccess. Error is {ex}"); return(StatusCode(500, "It was not possible to validate the password.")); } }
public async Task <IResponse> SetupPassword(PasswordRequest request) { var existingRecord = await _passwordsRepository .First(x => x.UserName == request.UserName); if (existingRecord != null) { throw new Exception($"User {request.UserName} is already registered."); } var(passwordHash, salt) = GenerateHash(request.Password, SaltLength, HashLength, Iterations); var record = new PasswordRecord() { PasswordHash = passwordHash, Salt = salt, Iterations = Iterations, UserName = request.UserName, HashLength = HashLength }; await _passwordsRepository.Create(record); return(new MethodResponse() { Sucess = true, Errors = new List <ErrorResponse>() }); }
public IHttpActionResult Register(PasswordRequest req) { var userService = new UserService(); return Ok( userService.Register(req.DeviceId, req.Password) ); }
/// <summary> /// 修改密码 /// </summary> /// <param name="pas"></param> /// <returns></returns> public async Task <bool> Psupdate(PasswordRequest pas) { try { var old = await _userStore.GetuserAsync(a => a.Where(b => b.UserId == pas.UserId)); var model = await _loginStore.GetAsync(a => a.Where(b => b.Password == pas.Oldpassword && b.UserId == pas.UserId)); if (model == null) { return(false); } if (pas.Newpassword != pas.Upassword) { return(false); } old.Password = pas.Newpassword; await _userStore.Userupdate(old); return(true); } catch (Exception e) { throw e; } }
private async void editButton_Click(object sender, EventArgs e) { if (this.passwordTextBox.ReadOnly) { this.passwordTextBox.ReadOnly = false; this.editButton.Text = "Submit"; } else { this.passwordTextBox.ReadOnly = true; this.editButton.Text = "Edit"; // Assumption: The selected node is capable of having a parent (since it's // the app node). var selectedNode = this.applicationTreeView.SelectedNode; var username = selectedNode.Text; var appName = selectedNode.Parent.Text; var appType = selectedNode.Parent.Parent.Text; var encryptedPw = Shared.CryptManager.encrypt(this.passwordTextBox.Text, M_secretkey); var app = new Shared.Application(appName, new Shared.Username[] { new Shared.Username(username, encryptedPw) }, appType); var request = new PasswordRequest(app); request.updatePassword = true; var response = await SocketManager.Instance.SendRequest <PasswordResponse>(request); var password = Shared.CryptManager.decrypt(response.application.Usernames[0].password, M_secretkey); this.fillPasswordBox(password); } }
public async Task <IdResponse> UpdatePassword(int id, [FromBody] PasswordRequest request) { var ps = new IdResponse(); try { var userId = await Util.GetLoggedInUser(HttpContext); if (userId > 0) { var matchingUser = await db.Users.FirstOrDefaultAsync(u => u.Id == id); if (matchingUser != null && matchingUser.Id == userId) { if (request.OldPassword != null && PasswordHash.VerifyHashedPassword(matchingUser.Password, request.OldPassword)) { if (await PasswordCheck.IsStrong(request.NewPassword)) { matchingUser.Password = PasswordHash.HashPassword(request.NewPassword); await db.SaveChangesAsync(); ps.Id = id; logger.LogTrace($"Changed password for user {id}"); } else { logger.LogWarning($"attempt to use weak password {request.NewPassword}"); ps.ResponseCodes.Add(ResponseCodes.WeakPassword); } } else { logger.LogWarning($"incorrect password for user {id}"); ps.ResponseCodes.Add(ResponseCodes.InvalidPassword); } } else { logger.LogWarning( $"user {id} does not exist or attempt to modify another user's password by {userId}"); ps.ResponseCodes.Add(ResponseCodes.InvalidUser); } } else { logger.LogWarning("Attempt without logging in"); ps.ResponseCodes.Add(ResponseCodes.NotLoggedIn); } } catch (Exception ex) { logger.LogError(ex, $"failed to update password for {id}"); ps.ResponseCodes.Add(ResponseCodes.InternalError); } return(ps); }
public IActionResult ChangePassword(string sessionid, string language, PasswordRequest request) { return(this.RequestHandler(language, () => { MessageSessionResponse response = _userLogic.ChangePassword(language, sessionid, request); return Ok(response); })); }
public IHttpActionResult Register(PasswordRequest req) { var userService = new UserService(); return(Ok( userService.Register(req.DeviceId, req.Password) )); }
public void Senha_deve_conter_caractere() { var model = new PasswordRequest { Password = "******" }; var result = passwordValidator.TestValidate(model); var aa = result.ShouldHaveValidationErrorFor(a => a.Password) .WithErrorMessage("Deve conter no mínimo um caractere especial"); }
public JsonResult Password(PasswordRequest request) { var response = new JResult() { Status = false }; var result = VHelper.ValidatorRule( new Rule_NotAllowNull(request.OldPassword, "请输入旧密码!"), new Rule_StringLenth(request.Password, min: 6, max: 20, message: "新密码长度在6-20位之间"), new Rule_StringLenth(request.ConfirmPassword, min: 6, max: 20, message: "新确认密码长度在6-20位之间") ); if (!result.IsPass) { response.Status = false; response.Message = result.Message; return(Json(response, JsonRequestBehavior.AllowGet)); } //新密码与确认密码验证 if (!request.Password.Equals(request.ConfirmPassword)) { response.Message = "两次输入密码不一致!"; return(Json(response, JsonRequestBehavior.AllowGet)); } //当前上下文 var customer = CustomerContext.Context; //旧密码验证 if (!EncryptionUtil.VerifyCiphetrextWithMd5AndSalt(request.OldPassword, customer.Password)) { response.Status = false; response.Message = "原登录密码错误!"; return(Json(response, JsonRequestBehavior.AllowGet)); } try { customer.Password = EncryptionUtil.EncryptWithMd5AndSalt(request.Password); if (CustomerApp.Instance.UpdatePassword(customer.SysNo, customer.Password).Status) { response.Status = true; response.Message = "修改密码成功﹗"; } else { response.Message = "修改密码失败﹗"; } } catch (Exception ex) { response.Message = ex.Message; } return(Json(response, JsonRequestBehavior.AllowGet)); }
public void Senha_não_pode_ser_null() { var model = new PasswordRequest { Password = null }; var result = passwordValidator.TestValidate(model); var aa = result.ShouldHaveValidationErrorFor(a => a.Password) .WithErrorMessage("'Password' não pode ser nulo."); }
public void Senha_não_contem_letra_minuscula() { var model = new PasswordRequest { Password = "******" }; var result = passwordValidator.TestValidate(model); var aa = result.ShouldHaveValidationErrorFor(a => a.Password) .WithErrorMessage("Não contem letra minuscula"); }
public void Senha_não_deve_conter_espaços_em_branco() { var model = new PasswordRequest { Password = "******" }; var result = passwordValidator.TestValidate(model); var aa = result.ShouldHaveValidationErrorFor(a => a.Password) .WithErrorMessage("Não deve conter espaços em branco"); }
public void Senha_não_deve_conter_caractere_duplicados(string password) { var model = new PasswordRequest { Password = password }; var result = passwordValidator.TestValidate(model); var aa = result.ShouldHaveValidationErrorFor(a => a.Password) .WithErrorMessage("Não deve conter caracteres duplicados ou repetidos"); }
public void Senha_valido() { var model = new PasswordRequest { Password = "******" }; var result = passwordValidator.TestValidate(model); result.ShouldNotHaveValidationErrorFor(a => a.Password); }
public void Senha_deve_conter_minimo_9_caracteres() { var model = new PasswordRequest { Password = "******" }; var result = passwordValidator.TestValidate(model); var aa = result.ShouldHaveValidationErrorFor(a => a.Password) .WithErrorMessage("Deve conter no minimo 9 caracteres"); }
public async Task <ActionResult> CreatePassword([FromBody] PasswordRequest passwordRequest) { _thimbleLogger.Log(passwordRequest.UserId, "credentials.registration.started"); await _credentialsDynamoClient.CreatePassword(passwordRequest); _thimbleLogger.Log(passwordRequest.UserId, "credentials.registration.successful"); return(Created("Thimble.Password", new PasswordResponse { UserId = passwordRequest.UserId })); }
public async Task CreatePassword(PasswordRequest passwordRequest) { await _dynamoClient.PutItemAsync(DynamoConstants.CREDENTIALS_TABLE, new Dictionary <string, AttributeValue> { { DynamoConstants.UserIdKey, new AttributeValue(passwordRequest.UserId) }, { DynamoConstants.EmailKey, new AttributeValue(passwordRequest.Email) }, { DynamoConstants.PasswordHashKey, new AttributeValue( PasswordHashHelper.Generate(passwordRequest.Password)) } }); }
public IHttpActionResult Login(PasswordRequest req) { var userService = new UserService(); var sessionKey = userService.Login(req.DeviceId, req.Password); if (sessionKey != null) { return Ok(sessionKey); } return Unauthorized(); }
public async Task <IActionResult> Password([FromBody] PasswordRequest req) { req.UserId = Guid.Parse(User.Identity.Name); var response = await _busClient.RequestAsync <PasswordRequest, BasicResponse>(req); var jsonResp = JsonConvert.SerializeObject(response); _logger.LogInformation($"PasswordChange attempted- '{User.Identity.Name}' - {(response.Success ? "SUCCESS" : "FAIL")}"); return(Ok(jsonResp)); }
public async Task SaveResetPasswordRequest(string token, string email) { var passwordRequest = new PasswordRequest { Token = token, Email = email, IsActive = true }; await _unitOfWork.Repository <PasswordRequest>().AddAsync(passwordRequest); }
public Response<object> UpdatePassword(string id, PasswordRequest passwordRequest) { var passwordRequestString = JsonConvert.SerializeObject(passwordRequest, Formatting.None, new JsonSerializerSettings() { ContractResolver = new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver() }); var content = new StringContent(passwordRequestString, Encoding.UTF8, "application/json"); // call sync var response = _client.PostAsync("/credentials/" + id, content).Result; if (response.IsSuccessStatusCode) { return new Response<object>(); } return new Response<object>{ Errored = true }; }