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