//[HttpPost]
public async Task <IActionResult> ResetPasswordAsync(ResetPasswordModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
CertificateUser user = null;
user = await userManager.FindByEmailAsync(model.email);
if (user == null)
{
ModelState.AddModelError("All", $"user not found, email may be incorrect {model.email}");
}
var result = await userManager.ResetPasswordAsync(user, model.token, model.password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("All", error.ToString());
}
}
return(RedirectToAction("login", "auth"));
}
public async Task <IActionResult> EditAsync([FromForm] CertificateUser model, [FromForm] string cropped)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var Profile = await userManager.FindByNameAsync(User.Identity.Name);
if (Profile == null)
{
return(View());
}
//Update database
Profile.FirstName = model.FirstName;
Profile.LastName = model.LastName;
Profile.Description = model.Description;
Profile.Country = model.Country;
Profile.Occupation = model.Occupation;
Profile.Website = model.Website;
Profile.isPrivate = model.isPrivate;
//convert base64 image to byte array
if (!String.IsNullOrWhiteSpace(cropped))
{
cropped = cropped.Replace("data:image/png;base64,", "");
cropped = cropped.Trim();
byte[] imageBytes = Convert.FromBase64String(cropped);
Profile.ProfilePicture = imageBytes;
}
await userManager.UpdateAsync(Profile);
return(RedirectToAction("User", new { Profile.Id }));
}
public string GetImageUrl(CertificateUser profile)
{
string imageDataBytes = Convert.ToBase64String(profile.ProfilePicture);
string imageUrl = string.Format("data:/image/jpeg;base64,{0}", imageDataBytes);
return(imageUrl);
}
public async Task <IActionResult> UserAsync()
{
CertificateUser user = await userManager.FindByNameAsync(User.Identity.Name);
//
// when database is reset the user may still be logged in
// If user tries to enter a restricted page, he or she will be
// signed out
if (user == null)
{
return(RedirectToAction("logout", "auth"));
}
FavoriteAndCertificateModel viewModel = new FavoriteAndCertificateModel {
certificate = CertificateHandler.GetByUserId(user.Id),
profile = user
};
foreach (var cert in viewModel.certificate.ToList())
{
bool isFavorite = favoriteHandler.CheckUserFavortite(user.Id, cert.CertificateId);
viewModel.isFavorite.Add(isFavorite);
}
if (user.ProfilePicture != null)
{
viewModel.ProfileImageUrl = GetImageUrl(user.ProfilePicture);
}
return(View(viewModel));
}
public async Task <long> UpdateCertificateUserAsync(CertificateUser certificateUser, string mappingScheme)
{
certificateUserMappingSchemeRegistrator.Register();
var updatedCertificateUser = unitOfWork.Add(certificateUser, mappingScheme);
await unitOfWork.SaveAsync();
return(updatedCertificateUser.Id);
}
public async Task <long> UpdateCertificateUserAsync(CertificateUserDto certificateCertificateUserDto)
{
var certificateCertificateUser = new CertificateUser();
Mapper.Map(certificateCertificateUserDto, certificateCertificateUser);
var rowsUpdated = await certificateUserRepository.UpdateCertificateUserAsync(certificateCertificateUser, certificateCertificateUserDto.MappingScheme);
return(rowsUpdated);
}
public async Task <CertificateUser> GetAuthorByIdAsync(int id)
{
var query = from entity in db.Certificates
where entity.CertificateId == id
select entity.UserFk;
Console.WriteLine("Query: ");
Console.WriteLine(query.FirstOrDefault());
CertificateUser user = await userManager.FindByIdAsync(query.FirstOrDefault());
return(user);
}
public async Task <IActionResult> forgotpasswordAsync(ForgotPasswordModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
CertificateUser user = null;
if (!string.IsNullOrWhiteSpace(model.email))
{
user = await userManager.FindByEmailAsync(model.email);
}
else if (!string.IsNullOrWhiteSpace(model.userName))
{
user = await userManager.FindByNameAsync(model.userName);
}
else
{
ModelState.AddModelError("All", "Enter a valid email or username");
}
if (user == null)
{
ModelState.AddModelError("All", "No user found with that mail or username");
return(View(model));
}
var token = await userManager.GeneratePasswordResetTokenAsync(user);
var resetUrl = Url.Action("ResetPassword", "Auth", new { token = token, email = user.Email }, Request.Scheme);
//System.IO.File.WriteAllText("resetLink.txt", resetUrl);
//Send email to user
List <string> emailList = new List <string> {
user.Email
};
await emailSender.SendEmailAsync(emailList, "Certificate.Wiki PASSWORD RESET",
"<h1>Reset password</h1> <br> <hr> <br>" +
$" <a href=\"{resetUrl}\"> <h3> Click here to reset password </h3> </a>" +
"<style>" +
"h3 {" +
"color: cyan;" +
"}" +
"</style>"
);
Console.WriteLine("reset password email sent");
return(View());
}
public async Task <IActionResult> registerAsync(RegisterModel model)
{
if (!ModelState.IsValid)
{
Console.WriteLine("modelstate failed"); //Remove
return(View(model));
}
var user = await userManager.FindByEmailAsync(model.Email);
if (user != null)
{
ModelState.AddModelError("Email", "User Already exists"); return(View(model));
}
//Register user
user = new CertificateUser {
Id = Guid.NewGuid().ToString(),
UserName = model.UserName, /*Username cannot be null in Identity*/
NormalizedEmail = userManager.NormalizeEmail(model.Email), /*Username cannot be null in Identity*/
Email = model.Email,
isPrivate = true
};
//user.ProfilePicture = RandomProfilePicture();
var result = await userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors.ToList())
{
ModelState.AddModelError("All", error.Description.ToString());
}
return(View(model));
}
//If you get here, registration was successful
await signInManager.PasswordSignInAsync(user.UserName, model.Password, true, false);
return(RedirectToAction("edit", "profile"));
}
