public ActionResult ForgotPassword(Kullanici model)
{
var validator = new ForgotPasswordValidator().Validate(model);
if (validator.IsValid)
{
int forgotPasswordUserId = _uow.GetRepo <Kullanici>()
.Where(x => x.Email == model.Email)
.FirstOrDefault()
.Id;
if (forgotPasswordUserId != 0)
{
_kod = Guid.NewGuid().ToString();
_uow.GetRepo <Kullanici>()
.GetById(forgotPasswordUserId)
.Kod = _kod;
_uow.Commit();
string url = Path.Combine("http://localhost:2815/Admin/Account/PasswordConfirm/", "?kod=" + _kod);
string htmlString = "<a href=" + url + ">Parolamı sıfırla</a>";
var message = (MailMessage)_mesaj;
message.To = model.Email;
bool Ok = message.SendMessage("Şifre Sıfırlama Talimatı", htmlString);
ModelState.Clear();
if (Ok)
{
IsSuccess = true;
ViewBag.IsSuccess = IsSuccess;
ViewBag.Msg = "E-postanıza onay linki gönderilmiştir";
}
else
{
IsSuccess = false;
ViewBag.IsSuccess = IsSuccess;
ViewBag.Msg = "E-posta gönderilirken bir hata oluştu,lütfen tekrar deneyiniz!";
}
return(View());
}
IsSuccess = false;
ViewBag.Msg = "Böyle bir kayıt bulunamadı!";
return(View());
}
else
{
validator.Errors.ToList().ForEach(x => ModelState.AddModelError(x.PropertyName, x.ErrorMessage));
return(View());
}
}
public void ValidWhenEmailAndPasswordProvided()
{
// arrange
var validator = new ForgotPasswordValidator();
var login = new ForgotPasswordDto
{
Email = validEmail
};
// act
var result = validator.Validate(login);
// assert
Assert.True(result.IsValid);
}
public void InvalidWhenEmailNotProvided(string email)
{
// arrange
var validator = new ForgotPasswordValidator();
var dto = new ForgotPasswordDto
{
Email = email
};
// act
var result = validator.Validate(dto);
// assert
Assert.False(result.IsValid);
}
public async Task Should_ReturnFalse_WhenRequiredInfo_IsNotProvided()
{
// Arrange
var forgotPasswordDto = new ForgotPasswordDto
{
Email = ""
};
var passwordValidator = new ForgotPasswordValidator();
// Act
var validatorResult = await passwordValidator.ValidateAsync(forgotPasswordDto);
// Assert
validatorResult.IsValid.ShouldBeFalse();
}
public void IsInvalidWhen_IsNull()
{
var validated = new ForgotPasswordForm();
var validator = new ForgotPasswordValidator(null, null);
var results = validator.Validate(validated);
results.IsValid.ShouldBeFalse();
results.Errors.Count.ShouldBeInRange(1, int.MaxValue);
var error = results.Errors.SingleOrDefault(e => e.PropertyName == PropertyName);
error.ShouldNotBeNull();
// ReSharper disable PossibleNullReferenceException
error.ErrorMessage.ShouldEqual(
ForgotPasswordValidator.FailedBecauseEmailAddressWasEmpty);
// ReSharper restore PossibleNullReferenceException
}
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordDto forgotPasswordDto, [FromServices] IForgotPasswordService service)
{
var forgotPasswordValidator = new ForgotPasswordValidator();
var validatorResult = await forgotPasswordValidator.ValidateAsync(forgotPasswordDto);
if (validatorResult.IsValid)
{
await service.RequestPasswordReset(forgotPasswordDto);
if (!service.Status.HasErrors)
{
return(Ok());
}
return(BadRequest(service.Status.Errors));
}
var validationErrors = validatorResult.Errors.Select(error => new ValidationResult(error.ErrorMessage))
.ToImmutableList();
return(BadRequest(validationErrors));
}
public UserController(IMyUser user,
IMyFiles myFiles,
UserModelValidator userModelValidator,
UpdateUserModelValidator updateUserModelValidator,
SendEmailConfirmationValidator sendEmailConfirmationValidator,
ConfirmEmailValidator confirmEmailValidator,
ChangePasswordValidator changePasswordValidator,
ForgotPasswordValidator forgotPasswordValidator,
ResetPasswordValidator resetPasswordValidator,
ResponseBadRequest badRequest)
{
_user = user;
_myFiles = myFiles;
_badRequest = badRequest;
_userModelValidator = userModelValidator;
_updateUserModelValidator = updateUserModelValidator;
_sendEmailConfirmationValidator = sendEmailConfirmationValidator;
_confirmEmailValidator = confirmEmailValidator;
_changePasswordValidator = changePasswordValidator;
_forgotPasswordValidator = forgotPasswordValidator;
_resetPasswordValidator = resetPasswordValidator;
}
private async void SendMyPassword()
{
View.HideKeyboard();
ForgotPasswordValidator validator = new ForgotPasswordValidator();
string email = ForgotEmail;
var result = validator.Validate(email);
if (result.IsValid)
{
mPlatformService.ShowNetworkIndicator();
mProgressDialogService.ShowProgressDialog();
var response = await mApiService.PostForgotPassword(email);
mPlatformService.HideNetworkIndicator();
mProgressDialogService.HideProgressDialog();
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
mMessageboxService.Show("Forgot password", Messages.ForgotPasswordSuccess);
View.HidePopupForgotPassword();
}
else
{
mMessageboxService.Show("Opps...", Messages.FotgotPasswordFail);
}
}
else if (result.Errors != null)
{
var firstError = result.Errors.First();
mMessageboxService.ShowToast(firstError.ErrorMessage);
}
}
public new void Setup()
{
_validator = new ForgotPasswordValidator();
}
public void IsValidWhen_MatchesPerson_WithNonSamlLocalUser_AndConfirmedEmailAddress()
{
var validated = new ForgotPasswordForm
{
EmailAddress = "*****@*****.**",
};
var person = new Person
{
User = new User
{
Name = "*****@*****.**",
},
Emails = new[]
{
new EmailAddress
{
Value = validated.EmailAddress,
IsConfirmed = true,
},
},
};
var establishment = new Establishment
{
IsMember = true,
EmailDomains = new[] { new EstablishmentEmailDomain { Value = "@domain.tld" }, },
};
var passwords = new Mock<IStorePasswords>(MockBehavior.Strict);
passwords.Setup(m => m
.Exists(It.Is(IsSignedUpBasedOn(person))))
.Returns(true);
var entities = new Mock<IQueryEntities>(MockBehavior.Strict).Initialize();
entities.Setup(m => m.Query<Establishment>()).Returns(new[] { establishment }.AsQueryable);
entities.Setup(m => m.Query<Person>()).Returns(new[] { person }.AsQueryable);
var validator = new ForgotPasswordValidator(entities.Object, passwords.Object);
var results = validator.Validate(validated);
var error = results.Errors.SingleOrDefault(e => e.PropertyName == PropertyName);
error.ShouldBeNull();
}
public void IsInvalidWhen_MatchesUnconfirmedEmailAddress()
{
var validated = new ForgotPasswordForm
{
EmailAddress = "*****@*****.**",
};
var person = new Person
{
User = new User
{
Name = "*****@*****.**",
},
Emails = new[]
{
new EmailAddress
{
Value = validated.EmailAddress,
},
},
};
var establishment = new Establishment
{
IsMember = true,
EmailDomains = new[] { new EstablishmentEmailDomain { Value = "@domain.tld" }, },
};
var passwords = new Mock<IStorePasswords>(MockBehavior.Strict);
passwords.Setup(m => m
.Exists(It.Is(IsSignedUpBasedOn(person))))
.Returns(true);
var entities = new Mock<IQueryEntities>(MockBehavior.Strict).Initialize();
entities.Setup(m => m.Query<Establishment>()).Returns(new[] { establishment }.AsQueryable);
entities.Setup(m => m.Query<Person>()).Returns(new[] { person }.AsQueryable);
var validator = new ForgotPasswordValidator(entities.Object, passwords.Object);
var results = validator.Validate(validated);
results.IsValid.ShouldBeFalse();
results.Errors.Count.ShouldBeInRange(1, int.MaxValue);
var error = results.Errors.SingleOrDefault(e => e.PropertyName == PropertyName);
error.ShouldNotBeNull();
// ReSharper disable PossibleNullReferenceException
error.ErrorMessage.ShouldEqual(string.Format(
ValidateEmailAddress.FailedBecauseIsNotConfirmed,
validated.EmailAddress));
// ReSharper restore PossibleNullReferenceException
}
public void IsInvalidWhen_MatchesPerson_WithSamlUser()
{
var validated = new ForgotPasswordForm
{
EmailAddress = "*****@*****.**",
};
var person = new Person
{
User = new User
{
EduPersonTargetedId = "something",
},
Emails = new[] { new EmailAddress { Value = validated.EmailAddress, }, },
};
var establishment = new Establishment
{
IsMember = true,
EmailDomains = new[] { new EstablishmentEmailDomain { Value = "@domain.tld" }, },
};
var entities = new Mock<IQueryEntities>(MockBehavior.Strict).Initialize();
entities.Setup(m => m.Query<Establishment>()).Returns(new[] { establishment }.AsQueryable);
entities.Setup(m => m.Query<Person>()).Returns(new[] { person }.AsQueryable);
var validator = new ForgotPasswordValidator(entities.Object, null);
var results = validator.Validate(validated);
results.IsValid.ShouldBeFalse();
results.Errors.Count.ShouldBeInRange(1, int.MaxValue);
var error = results.Errors.SingleOrDefault(e => e.PropertyName == PropertyName);
error.ShouldNotBeNull();
// ReSharper disable PossibleNullReferenceException
error.ErrorMessage.ShouldEqual(string.Format(
ForgotPasswordValidator.FailedBecauseEduPersonTargetedIdWasNotEmpty,
validated.EmailAddress.GetEmailDomain()));
// ReSharper restore PossibleNullReferenceException
}
public void IsInvalidWhen_MatchesNoPerson()
{
var validated = new ForgotPasswordForm
{
EmailAddress = "*****@*****.**",
};
var establishment = new Establishment
{
IsMember = true,
};
var entities = new Mock<IQueryEntities>(MockBehavior.Strict).Initialize();
entities.Setup(m => m.Query<Establishment>()).Returns(new[] { establishment }.AsQueryable);
entities.Setup(m => m.Query<Person>()).Returns(new Person[] { }.AsQueryable);
var validator = new ForgotPasswordValidator(entities.Object, null);
var results = validator.Validate(validated);
results.IsValid.ShouldBeFalse();
results.Errors.Count.ShouldBeInRange(1, int.MaxValue);
var error = results.Errors.SingleOrDefault(e => e.PropertyName == PropertyName);
error.ShouldNotBeNull();
// ReSharper disable PossibleNullReferenceException
error.ErrorMessage.ShouldEqual(string.Format(
ForgotPasswordValidator.FailedBecauseUserNameMatchedNoLocalMember,
validated.EmailAddress));
// ReSharper restore PossibleNullReferenceException
}
