/// <summary>
/// Gets the PasswordOptions Settings.
/// </summary>
/// <param name="settings">Settings for which PasswordOptions are required.</param>
/// <returns>PasswordOptions object to be attached to settings.</returns>
public Task <PasswordOptions> GetUserPasswordOptionsAsync(Settings settings)
{
return(Task.Factory.StartNew(() =>
{
if (ValidationService.Instance().Settings(settings))
{
return PasswordOptionsData.Instance().GetPasswordOptionsBySettings(settings);
}
else
{
return null;
}
}));
}
/// <summary>
/// Populates the User with Passwords and Settings.
/// </summary>
/// <param name="user">User to be populated.</param>
/// <returns>User: User with its Passwords and Settings.</returns>
public User PopulateUserData(User user)
{
if (ValidationService.Instance().User(user))
{
user.Passwords = CryptoService.Instance().DecryptUserPasswords(user, PasswordsData.Instance().GetUserPasswords(user));
//user.Settings = (SettingsData.Instance().GetUserSettings(user) == null) ? Globals.Defaults.Settings : SettingsData.Instance().GetUserSettings(user);
user.Settings = SettingsData.Instance().GetUserSettings(user);
user.Settings.PasswordOptions = PasswordOptionsData.Instance().GetPasswordOptionsBySettings(user.Settings);
return(user);
}
else
{
return(null);
}
}
/// <summary>
/// Populates the User with Passwords and Settings.
/// </summary>
/// <param name="user">User to be populated.</param>
/// <returns>User: User with its Passwords and Settings.</returns>
public Task <User> PopulateUserDataAsync(User user)
{
return(Task.Factory.StartNew(() =>
{
if (ValidationService.Instance().User(user))
{
user.Passwords = CryptoService.Instance().DecryptUserPasswords(user, PasswordsData.Instance().GetUserPasswords(user));
user.Settings = SettingsData.Instance().GetUserSettings(user);
user.Settings.PasswordOptions = PasswordOptionsData.Instance().GetPasswordOptionsBySettings(user.Settings);
return user;
}
else
{
return null;
}
}));
}
/// <summary>
/// Updates the PasswordOptions for supplied User Settings
/// </summary>
/// <param name="user">User for Settings Access.</param>
/// <param name="settings">Settings to be updated with PasswordOptions.</param>
/// <param name="passwordOptions">PasswordOptions to be updated.</param>
/// <returns>User: User with the updated Settings and PasswordOptions.</returns>
public Task <User> UpdateUserPasswordOptionsAsync(User user, Settings settings, PasswordOptions passwordOptions)
{
return(Task.Factory.StartNew(() =>
{
if (ValidationService.Instance().User(user) && ValidationService.Instance().Settings(settings) && ValidationService.Instance().PasswordOptions(passwordOptions))
{
if (PasswordOptionsData.Instance().UpdatePasswordOptionsBySettings(settings, passwordOptions) > 0)
{
user.Settings.PasswordOptions = passwordOptions;
return user;
}
else
{
return null;
}
}
else
{
return null;
}
}));
}
/// <summary>
/// Generates a new Random Password
/// </summary>
/// <param name="user">User whose PasswordOptions settings is used.</param>
/// <returns>String: Random Characters to be used as Password.</returns>
public Task <string> GeneratePasswordAsync(User user)
{
return(Task.Factory.StartNew(() =>
{
PasswordOptions passwordOptions = null;
if (ValidationService.Instance().User(user))
{
passwordOptions = PasswordOptionsData.Instance().GetPasswordOptionsBySettings(user.Settings);
}
else
{
passwordOptions = Globals.Defaults.PasswordOptions;
}
// Make a list of allowed characters.
string allowed = "";
if (passwordOptions.AllowLowercaseCharacters)
{
allowed += passwordOptions.LowercaseCharacters;
}
if (passwordOptions.AllowUppercaseCharacters)
{
allowed += passwordOptions.UppercaseCharacters;
}
if (passwordOptions.AllowNumberCharacters)
{
allowed += passwordOptions.NumberCharacters;
}
if (passwordOptions.AllowSpecialCharacters)
{
allowed += passwordOptions.SpecialCharacters;
}
if (passwordOptions.AllowUnderscoreCharacters)
{
allowed += passwordOptions.UnderscoreCharacters;
}
if (passwordOptions.AllowSpaceCharacters)
{
allowed += passwordOptions.SpaceCharacters;
}
if (passwordOptions.AllowOtherCharacters)
{
allowed += passwordOptions.OtherCharacters;
}
Random random = new Random();
int RequiredLength = random.Next(passwordOptions.MinimumCharacters, passwordOptions.MaximumCharacters);
// Satisfy requirements.
string password = "";
password = GenerateRandomWord(RequiredLength - (int)(RequiredLength * 0.5));
if (passwordOptions.RequireLowercaseCharacters &&
(password.IndexOfAny(passwordOptions.LowercaseCharacters.ToCharArray()) == -1))
{
password += RandomCharacter(passwordOptions.LowercaseCharacters, random);
}
if (passwordOptions.RequireUppercaseCharacters &&
(password.IndexOfAny(passwordOptions.UppercaseCharacters.ToCharArray()) == -1))
{
password = AddUpperCaseOnString(password);
}
if (passwordOptions.RequireNumberCharacters &&
(password.IndexOfAny(passwordOptions.NumberCharacters.ToCharArray()) == -1))
{
password += RandomCharacter(passwordOptions.NumberCharacters, random);
}
if (passwordOptions.RequireSpecialCharacters &&
(password.IndexOfAny(passwordOptions.SpecialCharacters.ToCharArray()) == -1))
{
password = RandomCharacter(passwordOptions.SpecialCharacters, random) + password;
}
if (passwordOptions.RequireUnderscoreCharacters &&
(password.IndexOfAny(passwordOptions.UnderscoreCharacters.ToCharArray()) == -1))
{
password += passwordOptions.UnderscoreCharacters;
}
if (passwordOptions.RequireSpaceCharacters &&
(password.IndexOfAny(passwordOptions.SpaceCharacters.ToCharArray()) == -1))
{
password += passwordOptions.SpaceCharacters;
}
if (passwordOptions.RequireOtherCharacters &&
(password.IndexOfAny(passwordOptions.OtherCharacters.ToCharArray()) == -1))
{
password += passwordOptions.OtherCharacters;
}
password = GenerateRandomWord(RequiredLength - password.Length) + password;
while (password.Length < RequiredLength)
{
password += allowed.Substring(
random.Next(0, allowed.Length - 1), 1);
}
return password;
}));
}
