public override void AddUsersToRoles(string[] usernames, string[] roleNames)
 {
     using (WebApp4Context context = new WebApp4Context())
     {
         var users = context.User.Where(usr => usernames.Contains(usr.Username)).ToList();
         var roles = context.Role.Where(rl => roleNames.Contains(rl.RoleName)).ToList();
         foreach (User user_loopVariable in users)
         {
             var user = user_loopVariable;
             foreach (Role role_loopVariable in roles)
             {
                 var role = role_loopVariable;
                 if (!user.Roles.Contains(role))
                 {
                     user.Roles.Add(role);
                 }
             }
         }
         context.SaveChanges();
     }
 }
 public override void CreateRole(string roleName)
 {
     if (string.IsNullOrEmpty(roleName))
     {
         throw CreateArgumentNullOrEmptyException("roleName");
     }
     using (WebApp4Context context = new WebApp4Context())
     {
         dynamic role = context.Role.FirstOrDefault(Rl => Rl.RoleName == roleName);
         if (role != null)
         {
             throw new InvalidOperationException(string.Format("Role exists: {0}", roleName));
         }
         Role NewRole = new Role
         {
             //Id = Guid.NewGuid(),
             RoleName = roleName
         };
         NewRole.GenerateNewIdentity();
         context.Role.Add(NewRole);
         context.SaveChanges();
     }
 }
 public override bool ChangePassword(string userName, string oldPassword, string newPassword)
 {
     if (string.IsNullOrEmpty(userName))
     {
         throw CreateArgumentNullOrEmptyException("userName");
     }
     if (string.IsNullOrEmpty(oldPassword))
     {
         throw CreateArgumentNullOrEmptyException("oldPassword");
     }
     if (string.IsNullOrEmpty(newPassword))
     {
         throw CreateArgumentNullOrEmptyException("newPassword");
     }
     using (WebApp4Context context = new WebApp4Context())
     {
         dynamic user = context.User.FirstOrDefault(Usr => Usr.Username == userName);
         if (user == null)
         {
             return false;
         }
         dynamic hashedPassword = user.Password;
         bool verificationSucceeded = (hashedPassword != null && CodeFirstCrypto.VerifyHashedPassword(hashedPassword, oldPassword));
         if (verificationSucceeded)
         {
             user.PasswordFailuresSinceLastSuccess = 0;
         }
         else
         {
             int failures = user.PasswordFailuresSinceLastSuccess;
             if (failures != -1)
             {
                 user.PasswordFailuresSinceLastSuccess += 1;
                 user.LastPasswordFailureDate = DateTime.Now;
             }
             context.SaveChanges();
             return false;
         }
         dynamic newhashedPassword = CodeFirstCrypto.HashPassword(newPassword);
         if (newhashedPassword.Length > 128)
         {
             throw new ArgumentException("Password too long");
         }
         user.Password = newhashedPassword;
         user.PasswordChangedDate = DateTime.Now;
         context.SaveChanges();
         return true;
     }
 }
 public override bool ResetPasswordWithToken(string token, string newPassword)
 {
     if (string.IsNullOrEmpty(newPassword))
     {
         throw CreateArgumentNullOrEmptyException("newPassword");
     }
     using (WebApp4Context context = new WebApp4Context())
     {
         dynamic user = context.User.FirstOrDefault(Usr => Usr.PasswordVerificationToken == token && Usr.PasswordVerificationTokenExpirationDate > DateTime.Now);
         if (user != null)
         {
             dynamic newhashedPassword = CodeFirstCrypto.HashPassword(newPassword);
             if (newhashedPassword.Length > 128)
             {
                 throw new ArgumentException("Password too long");
             }
             user.Password = newhashedPassword;
             user.PasswordChangedDate = DateTime.Now;
             user.PasswordVerificationToken = null;
             user.PasswordVerificationTokenExpirationDate = null;
             context.SaveChanges();
             return true;
         }
         else
         {
             return false;
         }
     }
 }
 public override string GeneratePasswordResetToken(string userName, int tokenExpirationInMinutesFromNow)
 {
     if (string.IsNullOrEmpty(userName))
     {
         throw CreateArgumentNullOrEmptyException("userName");
     }
     using (WebApp4Context context = new WebApp4Context())
     {
         dynamic user = context.User.FirstOrDefault(Usr => Usr.Username == userName);
         if (user == null)
         {
             throw new InvalidOperationException(string.Format("User not found: {0}", userName));
         }
         if (!user.IsConfirmed)
         {
             throw new InvalidOperationException(string.Format("User not found: {0}", userName));
         }
         string token = null;
         if (user.PasswordVerificationTokenExpirationDate > DateTime.Now)
         {
             token = user.PasswordVerificationToken;
         }
         else
         {
             token = CodeFirstCrypto.GenerateToken();
         }
         user.PasswordVerificationToken = token;
         user.PasswordVerificationTokenExpirationDate = DateTime.Now.AddMinutes(tokenExpirationInMinutesFromNow);
         context.SaveChanges();
         return token;
     }
 }
 public override string ExtendedValidateUser(string userNameOrEmail, string password)
 {
     if (string.IsNullOrEmpty(userNameOrEmail))
     {
         throw CreateArgumentNullOrEmptyException("userNameOrEmail");
     }
     if (string.IsNullOrEmpty(password))
     {
         throw CreateArgumentNullOrEmptyException("password");
     }
     using (WebApp4Context context = new WebApp4Context())
     {
         User user = null;
         user = context.User.FirstOrDefault(Usr => Usr.Username == userNameOrEmail);
         if (user == null)
         {
             user = context.User.FirstOrDefault(Usr => Usr.Email == userNameOrEmail);
         }
         if (user == null)
         {
             return string.Empty;
         }
         if (!user.IsConfirmed)
         {
             return string.Empty;
         }
         dynamic hashedPassword = user.Password;
         bool verificationSucceeded = (hashedPassword != null && CodeFirstCrypto.VerifyHashedPassword(hashedPassword, password));
         if (verificationSucceeded)
         {
             user.PasswordFailuresSinceLastSuccess = 0;
         }
         else
         {
             int failures = user.PasswordFailuresSinceLastSuccess;
             if (failures != -1)
             {
                 user.PasswordFailuresSinceLastSuccess += 1;
                 user.LastPasswordFailureDate = DateTime.Now;
             }
         }
         context.SaveChanges();
         if (verificationSucceeded)
         {
             return user.Username;
         }
         else
         {
             return string.Empty;
         }
     }
 }
 public override bool DeleteAccount(string userName)
 {
     if (string.IsNullOrEmpty(userName))
     {
         throw CreateArgumentNullOrEmptyException("userName");
     }
     using (WebApp4Context context = new WebApp4Context())
     {
         dynamic user = context.User.FirstOrDefault(Usr => Usr.Username == userName);
         if (user == null)
         {
             return false;
         }
         context.User.Remove(user);
         context.SaveChanges();
         return true;
     }
 }
 public override string CreateAccount(string userName, string password, string email, bool requireConfirmationToken)
 {
     if (string.IsNullOrEmpty(password))
     {
         throw new MembershipCreateUserException(MembershipCreateStatus.InvalidPassword);
     }
     string hashedPassword = CodeFirstCrypto.HashPassword(password);
     if (hashedPassword.Length > 128)
     {
         throw new MembershipCreateUserException(MembershipCreateStatus.InvalidPassword);
     }
     if (string.IsNullOrEmpty(userName))
     {
         throw new MembershipCreateUserException(MembershipCreateStatus.InvalidUserName);
     }
     if (string.IsNullOrEmpty(email))
     {
         throw new MembershipCreateUserException(MembershipCreateStatus.InvalidEmail);
     }
     using (WebApp4Context context = new WebApp4Context())
     {
         dynamic user = context.User.FirstOrDefault(Usr => Usr.Username == userName);
         dynamic emailuser = context.User.FirstOrDefault(Usr => Usr.Email == email);
         if (user != null)
         {
             throw new MembershipCreateUserException(MembershipCreateStatus.DuplicateUserName);
         }
         if (emailuser != null)
         {
             throw new MembershipCreateUserException(MembershipCreateStatus.DuplicateEmail);
         }
         string token = null;
         if (requireConfirmationToken)
         {
             token = CodeFirstCrypto.GenerateToken();
         }
         int defaultNumPasswordFailures = 0;
         User NewUser = new User
         {
             //Id = Guid.NewGuid(),
             Username = userName,
             Password = hashedPassword,
             IsConfirmed = !requireConfirmationToken,
             Email = email,
             ConfirmationToken = token,
             PasswordChangedDate = DateTime.Now,
             PasswordFailuresSinceLastSuccess = defaultNumPasswordFailures,
             LastPasswordFailureDate = DateTime.Now
         };
         NewUser.GenerateNewIdentity();
         context.User.Add(NewUser);
         context.SaveChanges();
         return token;
     }
 }
 public override bool ConfirmAccount(string accountConfirmationToken)
 {
     if (string.IsNullOrEmpty(accountConfirmationToken))
     {
         throw CreateArgumentNullOrEmptyException("accountConfirmationToken");
     }
     using (WebApp4Context context = new WebApp4Context())
     {
         dynamic row = context.User.FirstOrDefault(Usr => Usr.ConfirmationToken == accountConfirmationToken);
         if (row != null)
         {
             row.IsConfirmed = true;
             context.SaveChanges();
             return true;
         }
         return false;
     }
 }
 public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
 {
     if (string.IsNullOrEmpty(roleName))
     {
         throw CreateArgumentNullOrEmptyException("roleName");
     }
     using (WebApp4Context context = new WebApp4Context())
     {
         dynamic role = context.Role.FirstOrDefault(Rl => Rl.RoleName == roleName);
         if (role == null)
         {
             throw new InvalidOperationException("Role not found");
         }
         if (throwOnPopulatedRole)
         {
             dynamic usersInRole = role.Users.Any;
             if (usersInRole)
             {
                 throw new InvalidOperationException(string.Format("Role populated: {0}", roleName));
             }
         }
         else
         {
             foreach (User usr_loopVariable in role.Users)
             {
                 var usr = usr_loopVariable;
                 context.User.Remove(usr);
             }
         }
         context.Role.Remove(role);
         context.SaveChanges();
         return true;
     }
 }
 public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)
 {
     using (WebApp4Context context = new WebApp4Context())
     {
         foreach (string username_loopVariable in usernames)
         {
             var username = username_loopVariable;
             string us = username;
             User user = context.User.FirstOrDefault(u => u.Username == us);
             if (user != null)
             {
                 foreach (string rolename_loopVariable in roleNames)
                 {
                     var rolename = rolename_loopVariable;
                     var rl = rolename;
                     Role role = user.Roles.FirstOrDefault(r => r.RoleName == rl);
                     if (role != null)
                     {
                         user.Roles.Remove(role);
                     }
                 }
             }
         }
         context.SaveChanges();
     }
 }