/// <summary>
/// Changes the password.
/// </summary>
/// <param name="userProfileId"> The user profile id. </param>
/// <param name="oldClearPassword"> The old clear password. </param>
/// <param name="newClearPassword"> The new clear password. </param>
/// <exception cref="IncorrectPasswordException"/>
/// <exception cref="InstanceNotFoundException"/>
public void ChangePassword(long userProfileId, string oldClearPassword,
string newClearPassword)
{
UserProfile userProfile = UserProfileDao.Find(userProfileId);
String storedPassword = userProfile.enPassword;
if (!PasswordEncrypter.IsClearPasswordCorrect(oldClearPassword,
storedPassword))
{
throw new IncorrectPasswordException(userProfile.loginName);
}
userProfile.enPassword =
PasswordEncrypter.Crypt(newClearPassword);
UserProfileDao.Update(userProfile);
}
private IList <string> ParseLoginCommand()
{
var userData = new List <string>();
this.writer.WriteLine("Enter a username : "******"Enter a password : ");
var encryptedPassword = PasswordEncrypter.GetConsolePassword(writer);
Validator.ValidateUsernameOrPassword(encryptedPassword, this.writer);
userData.Add(encryptedPassword);
return(userData);
}
public void RegisterUserTest()
{
// Register user and find profile
long userId =
userService.RegisterUser(loginName, clearPassword,
new UserProfileDetails(firstName, lastName, email, language, country));
UserProfile userProfile = userProfileDao.Find(userId);
// Check data
Assert.AreEqual(userId, userProfile.usrId);
Assert.AreEqual(loginName, userProfile.loginName);
Assert.AreEqual(PasswordEncrypter.Crypt(clearPassword), userProfile.enPassword);
Assert.AreEqual(firstName, userProfile.firstName);
Assert.AreEqual(lastName, userProfile.lastName);
Assert.AreEqual(email, userProfile.email);
Assert.AreEqual(language, userProfile.language);
Assert.AreEqual(country, userProfile.country);
}
public long RegisterUser(string loginName, string clearPassword,
UserProfileDetails userProfileDetails)
{
try
{
UserProfileDao.FindByLoginName(loginName);
throw new DuplicateInstanceException(loginName,
typeof(UserProfile).FullName);
}
catch (InstanceNotFoundException)
{
try
{
UserProfileDao.FindByEmail(userProfileDetails.Email);
throw new DuplicateEmailException(userProfileDetails.Email);
}
catch (InstanceNotFoundException)
{
String encryptedPassword = PasswordEncrypter.Crypt(clearPassword);
UserProfile userProfile = new UserProfile();
userProfile.loginName = loginName;
userProfile.enPassword = encryptedPassword;
userProfile.firstName = userProfileDetails.FirstName;
userProfile.lastName = userProfileDetails.Lastname;
userProfile.email = userProfileDetails.Email;
userProfile.language = userProfileDetails.Language;
userProfile.country = userProfileDetails.Country;
userProfile.postalAddress = userProfileDetails.PostalAddress;
try
{
UserProfileDao.Create(userProfile);
}
catch (SqlException)
{
throw new SqlException("");
}
return(userProfile.usrId);
}
}
}
public void MyTestInitialize()
{
transaction = new TransactionScope();
userProfile = new UserProfile();
userProfile.loginName = userLoginName;
userProfile.enPassword = PasswordEncrypter.Crypt(clearPassword);
userProfile.firstName = firstName;
userProfile.lastName = lastName;
userProfile.email = email;
userProfile.language = language;
userProfile.country = country;
//userProfile.Recommendations = new List<Recommendation>();
//userProfile.UserGroups = new List<UserGroup1>();
//userProfile.Comments = new List<Comment>();
userProfileDao.Create(userProfile);
category = new Category();
category.name = categoryName;
categoryDao.Create(category);
myEvent = new Event();
myEvent.categoryId = category.categoryId;
myEvent.name = name;
myEvent.eventDate = date;
myEvent.review = review;
myEvent.Category = category;
//myEvent.Recommendations = new List<Recommendation>();
eventDao.Create(myEvent);
comment = new Comment();
comment.content = content;
comment.Event = myEvent;
//comment.Labels = new List<Label>();
comment.UserProfile = userProfile;
comment.loginName = userLoginName;
commentDao.Create(comment);
}
public long Register(string loginName, string clearPassword, string firstName, string lastName, string email, string languageCode, string countryCode)
{
if (UserProfileDao.ExistsWithLoginName(loginName))
{
throw new DuplicateInstanceException <UserProfileDetails>("loginName", loginName);
}
UserProfile userProfile = UserProfile.CreateUserProfile(0, loginName, PasswordEncrypter.Crypt(clearPassword), firstName, lastName, email, languageCode, countryCode);
try
{
UserProfileDao.Create(userProfile);
}
catch (DuplicateInstanceException <UserProfile> ex)
{
throw new DuplicateInstanceException <UserProfileDetails>(ex.Properties);
}
return(userProfile.userId);
}
public void LoginEncryptedPasswordTest()
{
using (var scope = new TransactionScope())
{
// Register user
var userId = userService.RegisterUser(loginName, clearPassword,
new UserProfileDetails(firstName, lastName, email, language, country, role, address));
var expected = new LoginResult(userId, firstName,
PasswordEncrypter.Crypt(clearPassword), language, country, role, address);
// Login with encrypted password
var obtained =
userService.Login(loginName,
PasswordEncrypter.Crypt(clearPassword), true);
// Check data
Assert.AreEqual(expected, obtained);
}
}
private static string GetPassword(Assembly assembly, string fullPath)
{
using (Stream fileStream = assembly.GetManifestResourceStream(fullPath))
{
string result = "";
if (fileStream == null)
{
Logger.LogActivity("Password file resource not found (Expected: {0})", fullPath);
}
else
{
StreamReader fileStreamReader = new StreamReader(fileStream);
string line = fileStreamReader.ReadLine();
result = PasswordEncrypter.Decrypt(line);
}
return(result);
}
}
public async override Task <CreateIdentityResult> Handle(CreateIdentityQuery request, CancellationToken cancellationToken)
{
var response = new CreateIdentityResult();
try
{
var result = await _context.Identities.Where(e => e.Login == request.Login).FirstOrDefaultAsync();
if (result == null)
{
var hashResult = PasswordEncrypter.Hash(request.Password);
var operationResult = await _context.AddAsync(new Domain.Identity.Identity
{
Login = request.Login,
Password = hashResult.Hash,
Salt = hashResult.Salt
});
if (operationResult.IsKeySet)
{
operationResult.Entity.Profile = new Domain.Identity.Profile();
response.Id = operationResult.Entity.Id;
await _context.SaveChangesAsync(cancellationToken);
response.Result = true;
response.Message = $"Identity for \"{request.Login}\" created";
}
}
else
{
response.Result = false;
response.Message = $"\"{request.Login}\" already exists";
}
}
catch (Exception e)
{
HandleException(response, e);
}
return(response);
}
public void LoginClearPasswordTest()
{
using (var scope = new TransactionScope())
{
// Register user
var userId = userService.RegisterUser(loginName, clearPassword,
new UserProfileDetails(firstName, lastName, email, language, country));
var expected = new LoginResult(userId, firstName,
PasswordEncrypter.Crypt(clearPassword), language, country);
// Login with clear password
var actual =
userService.Login(loginName,
clearPassword, false);
// Check data
Assert.AreEqual(expected, actual);
// transaction.Complete() is not called, so Rollback is executed.
}
}
public void LoginEncryptedPasswordTest()
{
using (TransactionScope scope = new TransactionScope())
{
// Register user
long userId = userService.RegisterUser(loginName, clearPassword,
new UserProfileDetails(firstName, lastName, email, language, country, postalAddress));
LoginResult expected = new LoginResult(userId, firstName,
PasswordEncrypter.Crypt(clearPassword), language, country);
// Login with encrypted password
LoginResult obtained =
userService.Login(loginName,
PasswordEncrypter.Crypt(clearPassword), true);
// Check data
Assert.AreEqual(expected, obtained);
// transaction.Complete() is not called, so Rollback is executed.
}
}
public async override Task <UpdateIdentityResult> Handle(UpdateIdentityQuery request, CancellationToken cancellationToken)
{
var response = new UpdateIdentityResult();
try
{
var entity = await _context.Identities.FirstOrDefaultAsync(x => x.Id == request.Id);
if (entity == null)
{
response.Result = false;
response.Message = $"Identity with id \"{request.Id}\" not found";
}
else
{
if (!string.IsNullOrEmpty(request.Login))
{
entity.Login = request.Login;
}
if (!string.IsNullOrEmpty(request.Password))
{
entity.Password = PasswordEncrypter.Hash(request.Password, entity.Salt);
}
_context.Update(entity);
await _context.SaveChangesAsync();
response.Result = true;
response.Message = $"Entity \"{entity.Login}\" updated";
}
}
catch (Exception e)
{
HandleException(response, e);
}
return(response);
}
public virtual void Authorization(string email, string password, Action wrongEmail, Action wrongPassword, Action authorized)
{
Action WrongEmail = wrongEmail;
Action WrongPassword = wrongPassword;
Action Authorized = authorized;
var curUser = Users.SingleOrDefault(u => u.Email == email);
if (curUser == null)
{
WrongEmail?.Invoke();
}
else if (curUser.Password != PasswordEncrypter.Encrypt(password))
{
WrongPassword?.Invoke();
}
else
{
_authorizedUser = curUser;
Authorized?.Invoke();
}
}
public GeneralMapping()
{
AllowNullDestinationValues = true;
AllowNullCollections = true;
CreateMap <Supplier, SupplierDto>()
.ReverseMap();
CreateMap <Supplier, CreateSupplierCommand>().ReverseMap();
CreateMap <Supplier, UpdateSupplierCommand>().ReverseMap();
CreateMap <Users, UserDto>();
CreateMap <UserDto, Users>()
.ForMember(x => x.Password, y => y.MapFrom(z => PasswordEncrypter.Encrypt(z.Password)))
;
CreateMap <Users, CreateUserCommand>().ReverseMap();
CreateMap <Users, UpdateUserCommand>().ReverseMap();
CreateMap <Order, OrderDto>()
.ForMember(x => x.SupplierName, y => y.MapFrom(z => z.Supplier.Name))
.ForMember(x => x.CreatedUserFullName, y => y.MapFrom(z => z.CreatedUser.FirstName + " " + z.CreatedUser.LastName));
CreateMap <OrderDto, Order>();
CreateMap <Order, CreateOrderCommand>().ReverseMap();
CreateMap <Order, UpdateOrderCommand>().ReverseMap();
CreateMap <OrderItem, OrderItemDto>()
.ForMember(x => x.CreatedUserFullName, y => y.MapFrom(z => z.CreatedUser.FirstName + " " + z.CreatedUser.LastName))
.ForMember(x => x.OrderName, y => y.MapFrom(z => z.Order.Name ?? ""));
CreateMap <OrderItemDto, OrderItem>();
CreateMap <OrderItem, CreateOrderItemCommand>().ReverseMap();
CreateMap <OrderItem, UpdateOrderItemCommand>().ReverseMap();
}
public LoginResult Login(String loginName, String password,
Boolean passwordIsEncrypted)
{
UserProfile userProfile =
UserProfileDao.FindByLoginName(loginName);
String storedPassword = userProfile.enPassword;
if (passwordIsEncrypted)
{
if (!password.Equals(storedPassword))
{
throw new IncorrectPasswordException(loginName);
}
}
else
{
if (!PasswordEncrypter.IsClearPasswordCorrect(password,
storedPassword))
{
throw new IncorrectPasswordException(loginName);
}
}
try
{
CreditCard card = creditCardDao.FindDefaultUserIdCard(userProfile.usrId);
return(new LoginResult(userProfile.usrId, userProfile.firstName,
storedPassword, userProfile.language, userProfile.country, userProfile.role, userProfile.address,
card.cardId, card.cardNumber));
}
catch (InstanceNotFoundException)
{
return(new LoginResult(userProfile.usrId, userProfile.firstName,
storedPassword, userProfile.language, userProfile.country, userProfile.role, userProfile.address));
}
}
public void RegisterUserTest()
{
using (TransactionScope scope = new TransactionScope())
{
// Register user and find profile
long userId =
userService.RegisterUser(loginName, clearPassword,
new UserProfileDetails(firstName, lastName, email, language, country, postalAddress));
UserProfile userProfile = userProfileDao.Find(userId);
// Check data
Assert.AreEqual(userId, userProfile.usrId);
Assert.AreEqual(loginName, userProfile.loginName);
Assert.AreEqual(PasswordEncrypter.Crypt(clearPassword), userProfile.enPassword);
Assert.AreEqual(firstName, userProfile.firstName);
Assert.AreEqual(lastName, userProfile.lastName);
Assert.AreEqual(email, userProfile.email);
Assert.AreEqual(language, userProfile.language);
Assert.AreEqual(country, userProfile.country);
// transaction.Complete() is not called, so Rollback is executed.
}
}
public override void Authorization(string email, string password, Action wrongEmail, Action wrongPassword, Action authorized)
{
Action WrongEmail = wrongEmail;
Action WrongPassword = wrongPassword;
Action Authorized = authorized;
var curUser = _context.Users.Include("Preferences").SingleOrDefault(u => u.Email == email);
if (curUser == null)
{
WrongEmail?.Invoke();
}
else if (curUser.Password != PasswordEncrypter.Encrypt(password))
{
WrongPassword?.Invoke();
}
else
{
_stations = _context.Stations.ToList();
_authorizedUser = curUser;
_routes = _context.Routes.Include("Stations").ToList();
Authorized?.Invoke();
}
}
public LoginResult Login(string loginName, string password, bool passwordIsEncrypted)
{
UserProfile userProfile;
try
{
userProfile = UserProfileDao.FindByLoginName(loginName);
}
catch (InstanceNotFoundException <UserProfile> ex)
{
throw new InstanceNotFoundException <UserProfileDetails>(ex.Properties);
}
catch (DuplicateInstanceException <UserProfile> ex)
{
throw new InternalErrorException(ex);
}
String storedPassword = userProfile.password;
if (passwordIsEncrypted)
{
if (!password.Equals(storedPassword))
{
throw new IncorrectPasswordException(loginName);
}
}
else
{
if (!PasswordEncrypter.IsClearPasswordCorrect(password, storedPassword))
{
throw new IncorrectPasswordException(loginName);
}
}
return(new LoginResult(userProfile.userId, userProfile.firstName, storedPassword, userProfile.languageCode, userProfile.countryCode));
}
private IList <string> ParseRegisterCommand()
{
var userData = new List <string>();
this.writer.WriteLine("Enter a username : "******"Enter a password : "******"Enter a first name : ");
var firstName = this.reader.Read();
userData.Add(firstName);
this.writer.WriteLine("Enter a last name : ");
var lastName = this.reader.Read();
userData.Add(lastName);
return(userData);
}
public void RegisterUserTest()
{
using (var scope = new TransactionScope())
{
// Register user and find profile
var userId =
userService.RegisterUser(loginName, clearPassword,
new UserProfileDetails(firstName, lastName, email, language, country, role, address));
var userProfile = userProfileDao.Find(userId);
// Check data
Assert.AreEqual(userId, userProfile.usrId);
Assert.AreEqual(loginName, userProfile.loginName);
Assert.AreEqual(PasswordEncrypter.Crypt(clearPassword), userProfile.enPassword);
Assert.AreEqual(firstName, userProfile.firstName);
Assert.AreEqual(lastName, userProfile.lastName);
Assert.AreEqual(email, userProfile.email);
Assert.AreEqual(language, userProfile.language);
Assert.AreEqual(country, userProfile.country);
Assert.AreEqual(role, userProfile.role);
Assert.AreEqual(address, userProfile.address);
}
}
public static bool SameAs(this string hashed, string raw, string salt, int hashLength, int iterations)
{
return(hashed.Equals(PasswordEncrypter.Hash(raw, salt, hashLength, iterations), StringComparison.InvariantCulture));
}
public async Task <User> AuthenticateAsync(AuthenticationUser authUser)
{
if (String.IsNullOrWhiteSpace(authUser.Login) || String.IsNullOrWhiteSpace(authUser.Password))
{
throw new ArgumentException("Login or Password is Empty");
}
var users = await _storage.GetAllAsync();
// user`s pswd
var dbUser = users.FirstOrDefault(user => user.Login == authUser.Login && PasswordEncrypter.Decrypt(user.Password) == authUser.Password);
if (dbUser == null)
{
throw new Exception("Wrong Login or Password");
}
LoginedUser.User = dbUser;
return(new User(dbUser.Guid, dbUser.FirstName, dbUser.LastName, dbUser.Email, dbUser.Login));
}
//public UserRegistrationDelegate UserRegistered;
private void Button_Submit_Click(object sender, RoutedEventArgs e)
{
emptySurnameMessage.Visibility = System.Windows.Visibility.Collapsed;
emptyEmailMessage.Visibility = System.Windows.Visibility.Collapsed;
emptyNameMessage.Visibility = System.Windows.Visibility.Collapsed;
emptyPasswordMessage.Visibility = System.Windows.Visibility.Collapsed;
invalidPasswordMessage.Visibility = System.Windows.Visibility.Collapsed;
bool emptyName = string.IsNullOrEmpty(textBoxName.Text.Trim());
bool emptySurname = string.IsNullOrEmpty(textBoxSurname.Text.Trim());
bool emptyEmail = string.IsNullOrEmpty(textBoxEmail.Text.Trim());
bool emptyPassword = string.IsNullOrEmpty(passwordBoxPassword.Password.Trim());
if (emptyEmail || emptyEmail || emptyPassword || emptySurname)
{
if (emptySurname)
{
emptySurnameMessage.Visibility = System.Windows.Visibility.Visible;
}
if (emptyPassword)
{
emptyPasswordMessage.Visibility = System.Windows.Visibility.Visible;
}
if (emptyName)
{
emptyNameMessage.Visibility = System.Windows.Visibility.Visible;
}
if (emptyEmail)
{
emptyEmailMessage.Visibility = System.Windows.Visibility.Visible;
}
}
else if (passwordBoxPassword.Password.Length < 7)
{
invalidPasswordMessage.Visibility = System.Windows.Visibility.Visible;
}
else
{
if (!_repo.RegisterUser(textBoxName.Text, textBoxSurname.Text, textBoxEmail.Text, PasswordEncrypter.Encrypt(passwordBoxPassword.Password), OnUserRegistered))
{
existingEmailMessage.Visibility = System.Windows.Visibility.Visible;
}
}
}
public void TestHashEncoding(string expectedHashCode, string stringToHashCode)
{
var c = PasswordEncrypter.Encrypt(stringToHashCode);
Assert.AreEqual(expectedHashCode, c);
}
public ActionResult Register(RegisterModel regModel)
{
if (string.IsNullOrEmpty(regModel.Email) || string.IsNullOrEmpty(regModel.FirstName) || string.IsNullOrEmpty(regModel.LastName) || string.IsNullOrEmpty(regModel.Password))
{
ViewBag.error = "შეავსე ყველა ველი";
return(View());
}
else if (regModel.Password.Length < 4)
{
ViewBag.error = "პაროლი უნდა აღემატებოდეს 3 სიმბოლოს ";
return(View());
}
else if (_user.CheckMail(regModel.Email))
{
ViewBag.error = "ესეთი Email უკვე არსებობს";
return(View());
}
else
{
_user.Add(_user.CreateUser(regModel.FirstName, regModel.LastName, regModel.Email, PasswordEncrypter.CreateMD5(regModel.Password), regModel.Avatar));
_user.Commit();
return(RedirectToAction("Login", "Account"));
}
}
public ActionResult addAnvändare(AnvändareModel model, HttpPostedFileBase File1)
{
try
{
var ctx = new AnvändareDbContext();
var passwordEncrypter = new PasswordEncrypter();
var födelse = model.Födelsedatum;
var datumarray = födelse.Split('-');
var året = datumarray[0]; // Kollar så personen har vettig ålder
var intåret = Int32.Parse(året);
if (intåret < 1920 || intåret > 2002)
{
ViewData["errorfödelse"] = "Angivit fel födelsedatum, bara mellan 1920 till 2002 tillåtet";
return(View("CreateAcc"));
}
if (model.Lössenord == null || model.Lössenord == "")
{
return(View("CreateAcc"));
}
if (File1 == null)
{
ViewData["error"] = "Du måste ladda upp en bild";
return(View("CreateAcc"));
}
if (File1 != null && File1.ContentLength > 0 && File1.ContentType.Equals("image/jpeg") || File1.ContentType.Equals("image/png"))
{
var encryptedPass = passwordEncrypter.EncryptPassword(model.Lössenord);
model.Lössenord = encryptedPass; // krypterar lösenordet
model.Förnamn = model.Förnamn.Substring(0, 1).ToUpper() + model.Förnamn.Substring(1);
model.Efternamn = model.Efternamn.Substring(0, 1).ToUpper() + model.Efternamn.Substring(1); // Gör att förnamn och efternamn första bokstav sparas som en stor bokstav
model.Profilbild = new byte[File1.ContentLength]; // Gör om filen man valt till En byte[]
File1.InputStream.Read(model.Profilbild, 0, File1.ContentLength);
ctx.användare.Add(model);
ctx.SaveChanges(); // kollar så att filen är av jpeg, png och att det finns en fil
// sparar hela användaren i databasen
var nyaanvändarenMedID = new AnvändareModel();
foreach (var användare in ctx.användare)
{
if (användare.AnvändarNamn.Equals(model.AnvändarNamn))
{
nyaanvändarenMedID = användare; // hämtar den nya användaren från databasen och skickar
} // till bekräftelse
}
TempData["NyAnvändare"] = nyaanvändarenMedID;
return(RedirectToAction("Bekräftelse", "Användare"));
}
ViewData["error"] = "Fel format på bilden, Bara .jpg och .png är tillåtna";
return(View("CreateAcc"));
}
catch (Exception)
{
throw;
}
}
public ActionResult EditUser(AnvändareModel model, HttpPostedFileBase File1)
{
try
{
AnvändareDbContext db = new AnvändareDbContext();
AnvändareModel användare1 = db.användare.FirstOrDefault(a => a.AnvändarNamn.Equals(model.AnvändarNamn));
AnvändareModel användare2 = db.användare.FirstOrDefault(a => a.Epost.Equals(model.Epost));
// Hämtar model för epost respektive användarnamn
var födelse = model.Födelsedatum;
var datumarray = födelse.Split('-');
var året = datumarray[0]; // Kollar så personen har vettig ålder
var intåret = Int32.Parse(året);
if (intåret < 1920 || intåret > 2002)
{
ViewData["errorfödelse"] = "Angivit fel födelsedatum, bara mellan 1920 till 2002 tillåtet";
return(View("EditUser"));
}
var förnamn = model.Förnamn = model.Förnamn.Substring(0, 1).ToUpper() + model.Förnamn.Substring(1); //Gör om första bokstaven till stor ifall man angav liten
var efternamn = model.Efternamn.Substring(0, 1).ToUpper() + model.Efternamn.Substring(1);
var pattern = "^([A-ZÅÄÖa-zåäö]+)$"; //Regex som kontrollerar förnamn/efternamn tecken a-ö
Regex rgx = new Regex(pattern);
if (!rgx.IsMatch(förnamn))
{
return(View("EditUser"));
}
if (!rgx.IsMatch(efternamn))
{
return(View("EditUser"));
}
if (model.Förnamn == null || model.Förnamn == "")
{
return(View("EditUser")); // validerar så att det inte är tomt
}
if (model.Efternamn == null || model.Efternamn == "")
{
return(View("EditUser"));
}
if (model.AnvändarNamn == null || model.AnvändarNamn == "")
{
return(View("EditUser"));
}
if (model.Lössenord == null || model.Lössenord == "")
{
return(View("EditUser"));
}
if (db.användare.Any(a => a.AnvändarNamn.Equals(model.AnvändarNamn)) && AnvändareInloggadVerifeierare.användaren.ID != användare1.ID)
{
ViewData["erroranvändarnamn"] = "Användarnamn upptaget";
return(View("EditUser")); // Kollar så att man inte ändrar till ett användarnamn som finns
}
if (db.användare.Any(a => a.Epost.Equals(model.Epost)) && AnvändareInloggadVerifeierare.användaren.ID != användare2.ID)
{
ViewData["errorepost"] = "Epost upptaget";
return(View("EditUser")); // Kollar så att man inte ändrar till en epost som finns
}
if (ModelState.IsValid && File1 == null) // om användare inte väljer ny bild
{
int id = model.ID;
AnvändareModel användare = db.användare.FirstOrDefault(a => a.ID.Equals(id)); // Hämta användare
användare.Efternamn = model.Efternamn;
användare.Förnamn = model.Förnamn;
användare.Födelsedatum = model.Födelsedatum; // uppdatera i databasen
användare.Epost = model.Epost;
användare.AnvändarNamn = model.AnvändarNamn;
//Kryptera det nya lössenordet
var encrypter = new PasswordEncrypter();
var nyttPwEncrypted = encrypter.EncryptPassword(model.Lössenord);
användare.Lössenord = nyttPwEncrypted;
AnvändareInloggadVerifeierare.användaren.Förnamn = förnamn;
AnvändareInloggadVerifeierare.användaren.Efternamn = efternamn;
AnvändareInloggadVerifeierare.användaren.Epost = model.Epost; // uppdaterar direkt
AnvändareInloggadVerifeierare.användaren.Födelsedatum = model.Födelsedatum;
AnvändareInloggadVerifeierare.användaren.AnvändarNamn = model.AnvändarNamn;
AnvändareInloggadVerifeierare.användaren.Lössenord = model.Lössenord;
AnvändareInloggadVerifeierare.användaren.IsActive = model.IsActive;
db.Entry(användare).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("UserPage"));
}
if (ModelState.IsValid && File1 != null && File1.ContentLength > 0 && File1.ContentType.Equals("image/jpeg") || File1.ContentType.Equals("image/png"))
{
int id = model.ID; // om användaren väljer att byta bild + annan information så körs denna if sats
AnvändareModel användare = db.användare.FirstOrDefault(a => a.ID.Equals(id)); // Hämta användare
model.Profilbild = new byte[File1.ContentLength]; // Gör om filen man valt till En byte[]
File1.InputStream.Read(model.Profilbild, 0, File1.ContentLength);
användare.Profilbild = model.Profilbild;
AnvändareInloggadVerifeierare.användaren.Profilbild = model.Profilbild;
användare.Efternamn = model.Efternamn;
användare.Förnamn = model.Förnamn;
användare.Födelsedatum = model.Födelsedatum; // uppdatera i databasen
användare.Epost = model.Epost;
användare.Lössenord = model.Lössenord;
användare.IsActive = model.IsActive;
användare.AnvändarNamn = model.AnvändarNamn;
AnvändareInloggadVerifeierare.användaren.Förnamn = model.Förnamn;
AnvändareInloggadVerifeierare.användaren.Efternamn = model.Efternamn;
AnvändareInloggadVerifeierare.användaren.Epost = model.Epost; // uppdaterar direkt
AnvändareInloggadVerifeierare.användaren.Födelsedatum = model.Födelsedatum;
AnvändareInloggadVerifeierare.användaren.AnvändarNamn = model.AnvändarNamn;
AnvändareInloggadVerifeierare.användaren.Lössenord = model.Lössenord;
AnvändareInloggadVerifeierare.användaren.IsActive = model.IsActive;
db.Entry(användare).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("UserPage"));
}
else if (File1 != null && File1.ContentLength > 0 && !File1.ContentType.Equals("image/jpeg") || !File1.ContentType.Equals("image/png"))
{ // om det är fel format på bilden
ViewData["error"] = "Fel format på bilden, Bara .jpg och .png är tillåtna";
return(View("EditUser"));
}
return(RedirectToAction("UserPage"));
}
catch (Exception)
{
throw;
}
}
public UserValidator()
{
passwordEncrypter = new PasswordEncrypter();
}
public AuthenticationService()
{
PasswordEncrypter.InitEncryptionKey();
}
public DebtorsController(ApplicationDbContext context)
{
_context = context;
_settings = _context.Settings.FirstOrDefault();
encryption = new PasswordEncrypter();
}
