public override System.Web.Security.MembershipUserCollection FindUsersByName(string usernameToMatch, int pageIndex, int pageSize, out int totalRecords)
{
SecUtility.CheckParameter(ref usernameToMatch, true, true, false, 0x100, "usernameToMatch");
if (pageIndex < 0)
{
throw new ArgumentException("PageIndex_bad", "pageIndex");
}
if (pageSize < 1)
{
throw new ArgumentException("PageSize_bad", "pageSize");
}
var query = from user in db.Users
where user.UserName.Contains(usernameToMatch)
orderby user.Id
select user;
totalRecords = query.Count();
var col = new MembershipUserCollection();
foreach (var item in query.Skip(pageSize * pageIndex).Take(pageSize))
{
col.Add(UserMapper.Map(this.Name, item, _ReturnEFMembershipUser));
}
return(col);
}
internal static void CheckArrayParameter(ref string[] param, bool checkForNull, bool checkIfEmpty, bool checkForCommas, int maxSize, string paramName)
{
if (param == null)
{
throw new ArgumentNullException(paramName);
}
if (param.Length < 1)
{
throw new ArgumentException("Parameter_array_empty, paramName, " + paramName);
}
Hashtable values = new Hashtable(param.Length);
for (int i = param.Length - 1; i >= 0; i--)
{
SecUtility.CheckParameter(ref param[i], checkForNull, checkIfEmpty, checkForCommas, maxSize,
paramName + "[ " + i.ToString(CultureInfo.InvariantCulture) + " ]");
if (values.Contains(param[i]))
{
throw new ArgumentException("Parameter_duplicate_array_element, " + paramName + ", " + paramName);
}
else
{
values.Add(param[i], param[i]);
}
}
}
public override bool ChangePassword(string username, string oldPassword, string newPassword)
{
SecUtility.CheckParameter(ref username, true, true, true, 0x100, "username");
SecUtility.CheckParameter(ref oldPassword, true, true, false, 0x80, "oldPassword");
SecUtility.CheckParameter(ref newPassword, true, true, false, 0x80, "newPassword");
var salt = string.Empty;
var passwordFormat = 1;
var user = default(User);
if (!CheckPassword(username, oldPassword, false, false, out salt, out passwordFormat, out user))
{
return(false);
}
user.Password = EncodePassword(newPassword, passwordFormat, salt);
user.LastPasswordChangedDate = DateTime.Now;
user.FailedPasswordAnswerAttemptCount = 0;
user.FailedPasswordAttemptCount = 0;
db.SaveChanges();
return(true);
}
public override void UpdateUser(System.Web.Security.MembershipUser user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
string temp = user.UserName;
SecUtility.CheckParameter(ref temp, true, true, true, 256, "UserName");
temp = user.Email;
SecUtility.CheckParameter(ref temp,
RequiresUniqueEmail,
RequiresUniqueEmail,
false,
256,
"Email");
user.Email = temp;
var query = from u in db.Users
where u.Id == (int)user.ProviderUserKey
select u;
var usr = query.FirstOrDefault();
if (usr == null)
{
throw new ProviderException(GetExceptionText(1));
}
if (RequiresUniqueEmail)
{
var q = from u in db.Users
where u.Id != (int)user.ProviderUserKey &&
u.Email == user.Email
select u;
if (q.Any())
{
throw new ProviderException(GetExceptionText(7));
}
}
usr.Email = user.Email;
usr.Comment = user.Comment;
usr.IsApproved = user.IsApproved;
usr.LastLoginDate = user.LastLoginDate;
if (user is MembershipUser)
{
var muser = (MembershipUser)user;
usr.FirstName = muser.FirstName;
usr.LastName = muser.LastName;
}
db.SaveChanges();
}
public override string GetUserNameByEmail(string email)
{
SecUtility.CheckParameter(ref email, false, false, false, 0x100, "email");
var usr = (from u in db.Users where u.Email == email select u.UserName).FirstOrDefault();
return(usr);
}
public override string[] GetUsersInRole(string roleName)
{
SecUtility.CheckParameter(ref roleName, true, true, true, 256, "roleName");
var query = from u in db.Users
from r in db.Roles
where r.RoleName == roleName
select u.UserName;
return(query.ToArray());
}
public override string[] GetRolesForUser(string username)
{
SecUtility.CheckParameter(ref username, true, false, true, 256, "username");
var query = from u in db.Users
from r in u.Roles
where u.UserName == username
select r.RoleName;
return(query.ToArray());
}
public override string[] FindUsersInRole(string roleName, string usernameToMatch)
{
SecUtility.CheckParameter(ref roleName, true, true, true, 256, "roleName");
SecUtility.CheckParameter(ref usernameToMatch, true, true, false, 256, "usernameToMatch");
var query = from r in db.Roles
from u in r.Users
where r.RoleName == roleName && u.UserName.Contains(usernameToMatch)
select u.UserName;
return(query.ToArray());
}
public override bool UnlockUser(string userName)
{
SecUtility.CheckParameter(ref userName, true, true, true, 256, "username");
try
{
var user = GetDBUser(userName);
if (user == null)
{
return(false);
}
user.Status = (byte)A1fxCrm.Web.Framework.Model.Enumerations.UserStatus.Approved;
user.LastLockoutDate = DateTime.UtcNow;
db.SaveChanges();
return(true);
}
catch { return(false); }
}
public override bool IsUserInRole(string username, string roleName)
{
SecUtility.CheckParameter(ref roleName, true, true, true, 256, "roleName");
SecUtility.CheckParameter(ref username, true, false, true, 256, "username");
if (username.Length < 1)
{
return(false);
}
var query = from u in db.Users
from r in u.Roles
where r.RoleName == roleName &&
u.UserName == username
select u.UserName;
return(query.Any());
}
public override void AddUsersToRoles(string[] usernames, string[] roleNames)
{
SecUtility.CheckArrayParameter(ref roleNames, true, true, true, 256, "roleNames");
SecUtility.CheckArrayParameter(ref usernames, true, true, true, 256, "usernames");
var users = db.Users.Include("Roles").Where(c => usernames.Contains(c.UserName)).ToList();
var roles = db.Roles.Where(c => roleNames.Contains(c.RoleName)).ToList();
foreach (var user in users)
{
foreach (var role in roles)
{
if (!user.Roles.Contains(role))
{
user.Roles.Add(role);
}
}
}
db.SaveChanges();
}
public override bool DeleteUser(string username, bool deleteAllRelatedData)
{
SecUtility.CheckParameter(ref username, true, true, true, 0x100, "username");
var user = db.Users.Include("Roles").FirstOrDefault(u => u.UserName == username);
if (user == null)
{
return(false);
}
foreach (var role in user.Roles)
{
user.Roles.Remove(role);
}
db.Users.Remove(user);
db.SaveChanges();
return(true);
}
public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)
{
SecUtility.CheckArrayParameter(ref roleNames, true, true, true, 256, "roleNames");
SecUtility.CheckArrayParameter(ref usernames, true, true, true, 256, "usernames");
foreach (var username in usernames)
{
var user = db.Users.Include("Roles").Where(u => u.UserName == username).FirstOrDefault();
if (user != null)
{
foreach (var rolename in roleNames)
{
var role = user.Roles.FirstOrDefault(r => r.RoleName == rolename);
if (role != null)
{
user.Roles.Remove(role);
}
}
}
}
db.SaveChanges();
}
public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
{
SecUtility.CheckParameter(ref roleName, true, true, true, 256, "roleName");
var query = from r in db.Roles
where r.RoleName == roleName
select new { r, child = r.Users.Count() };
if (query.Any())
{
var r = query.First();
if (r.child > 0 && throwOnPopulatedRole)
{
throw new ProviderException("Role_is_not_empty");
}
db.Roles.Remove(r.r);
db.SaveChanges();
return(true);
}
return(false);
}
public override bool RoleExists(string roleName)
{
SecUtility.CheckParameter(ref roleName, true, true, true, 256, "roleName");
return(db.Roles.Where(r => r.RoleName == roleName).Any());
}
public override string ResetPassword(string username, string answer)
{
if (!EnablePasswordReset)
{
throw new NotSupportedException("Not_configured_to_support_password_resets");
}
SecUtility.CheckParameter(ref username, true, true, true, 256, "username");
var user = GetDBUser(username);
var passwordAnswer = answer;
string encodedPasswordAnswer;
if (passwordAnswer != null)
{
passwordAnswer = passwordAnswer.Trim();
}
if (!string.IsNullOrEmpty(passwordAnswer))
{
encodedPasswordAnswer = EncodePassword(passwordAnswer.ToLower(CultureInfo.InvariantCulture), user.PasswordFormat, user.PasswordSalt);
}
else
{
encodedPasswordAnswer = passwordAnswer;
}
SecUtility.CheckParameter(ref encodedPasswordAnswer, RequiresQuestionAndAnswer, RequiresQuestionAndAnswer, false, 128, "passwordAnswer");
string newPassword = GeneratePassword();
ValidatePasswordEventArgs e = new ValidatePasswordEventArgs(username, newPassword, false);
OnValidatingPassword(e);
if (e.Cancel)
{
if (e.FailureInformation != null)
{
throw e.FailureInformation;
}
else
{
throw new ProviderException("Membership_Custom_Password_Validation_Failure");
}
}
var utc = DateTime.UtcNow;
if (!answer.Equals(user.PasswordAnswer, StringComparison.CurrentCultureIgnoreCase))
{
if (utc > user.FailedPasswordAnswerAttemptWindowStart.AddMinutes(PasswordAttemptWindow))
{
user.FailedPasswordAnswerAttemptCount = 1;
}
else
{
user.FailedPasswordAnswerAttemptCount++;
}
user.FailedPasswordAnswerAttemptWindowStart = utc;
if (user.FailedPasswordAnswerAttemptCount > MaxInvalidPasswordAttempts)
{
user.LastLockoutDate = DateTime.UtcNow;
user.Status = (byte)A1fxCrm.Web.Framework.Model.Enumerations.UserStatus.Locked;
}
db.SaveChanges();
return(null);
}
user.FailedPasswordAnswerAttemptCount = 0;
user.FailedPasswordAnswerAttemptWindowStart = new DateTime(1754, 01, 01);
user.FailedPasswordAttemptCount = 0;
user.FailedPasswordAttemptWindowStart = user.FailedPasswordAnswerAttemptWindowStart;
user.Password = EncodePassword(newPassword, user.PasswordFormat, user.PasswordSalt);
db.SaveChanges();
return(newPassword);
}
public override void Initialize(string name, NameValueCollection config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (string.IsNullOrEmpty(config["description"]))
{
config.Remove("description");
config.Add("description", "MembershipSqlProvider_description");
}
base.Initialize(name, config);
_SchemaVersionCheck = 0;
_ReturnEFMembershipUser = SecUtility.GetBooleanValue(config, "returnEFMembershipUser", false);
_AutoInstall = SecUtility.GetBooleanValue(config, "autoInstall", true);
_EnablePasswordRetrieval = SecUtility.GetBooleanValue(config, "enablePasswordRetrieval", false);
_EnablePasswordReset = SecUtility.GetBooleanValue(config, "enablePasswordReset", true);
_RequiresQuestionAndAnswer = SecUtility.GetBooleanValue(config, "requiresQuestionAndAnswer", false);
_RequiresUniqueEmail = SecUtility.GetBooleanValue(config, "requiresUniqueEmail", true);
_MaxInvalidPasswordAttempts = SecUtility.GetIntValue(config, "maxInvalidPasswordAttempts", 5, false, 0);
_PasswordAttemptWindow = SecUtility.GetIntValue(config, "passwordAttemptWindow", 10, false, 0);
_MinRequiredPasswordLength = SecUtility.GetIntValue(config, "minRequiredPasswordLength", 3, false, 128);
_MinRequiredNonalphanumericCharacters = SecUtility.GetIntValue(config, "minRequiredNonalphanumericCharacters", 0, true, 128);
_PasswordStrengthRegularExpression = config["passwordStrengthRegularExpression"];
if (_PasswordStrengthRegularExpression != null)
{
_PasswordStrengthRegularExpression = _PasswordStrengthRegularExpression.Trim();
if (_PasswordStrengthRegularExpression.Length != 0)
{
try
{
Regex regex = new Regex(_PasswordStrengthRegularExpression);
}
catch (ArgumentException e)
{
throw new ProviderException(e.Message, e);
}
}
}
else
{
_PasswordStrengthRegularExpression = string.Empty;
}
if (_MinRequiredNonalphanumericCharacters > _MinRequiredPasswordLength)
{
throw new HttpException("MinRequiredNonalphanumericCharacters_can_not_be_more_than_MinRequiredPasswordLength");
}
_CommandTimeout = SecUtility.GetIntValue(config, "commandTimeout", 30, true, 0);
string strTemp = config["passwordFormat"];
if (strTemp == null)
{
strTemp = "Hashed";
}
switch (strTemp)
{
case "Clear":
_PasswordFormat = MembershipPasswordFormat.Clear;
break;
case "Encrypted":
_PasswordFormat = MembershipPasswordFormat.Encrypted;
break;
case "Hashed":
_PasswordFormat = MembershipPasswordFormat.Hashed;
break;
default:
throw new ProviderException("Provider_bad_password_format");
}
if (PasswordFormat == MembershipPasswordFormat.Hashed && EnablePasswordRetrieval)
{
throw new ProviderException("Provider_can_not_retrieve_hashed_password");
}
string passwordCompactMode = config["passwordCompatMode"];
if (!string.IsNullOrEmpty(passwordCompactMode))
{
this._LegacyPasswordCompatibilityMode = (MembershipPasswordCompatibilityMode)Enum.Parse(typeof(MembershipPasswordCompatibilityMode), passwordCompactMode);
}
config.Remove("returnEFMembershipUser");
config.Remove("autoInstall");
config.Remove("returnEFMembershipUser");
config.Remove("connectionStringName");
config.Remove("enablePasswordRetrieval");
config.Remove("enablePasswordReset");
config.Remove("requiresQuestionAndAnswer");
config.Remove("requiresUniqueEmail");
config.Remove("maxInvalidPasswordAttempts");
config.Remove("passwordAttemptWindow");
config.Remove("commandTimeout");
config.Remove("passwordFormat");
config.Remove("name");
config.Remove("minRequiredPasswordLength");
config.Remove("minRequiredNonalphanumericCharacters");
config.Remove("passwordStrengthRegularExpression");
if (config.Count > 0)
{
string attribUnrecognized = config.GetKey(0);
if (!String.IsNullOrEmpty(attribUnrecognized))
{
throw new ProviderException("Provider_unrecognized_attribute, attribUnrecognized");
}
}
}
