/// <summary>
/// Initializes a new instance of the <see cref="CreateUpdateAuthorizationUserInfoAction" /> class.
/// </summary>
/// <param name="authorization">The authorization.</param>
/// <param name="userInfo">The user info.</param>
/// <param name="provider">The provider.</param>
public CreateUpdateAuthorizationUserInfoAction(AuthorizationInformation authorization, UserInformation userInfo,
MembershipProviderBase provider)
: base(provider)
{
this.authorization = authorization;
this.userInfo = userInfo;
}
/// <summary>
/// Creates a BackOfficeUserManager instance with all default options and the default BackOfficeUserManager
/// </summary>
/// <param name="options"></param>
/// <param name="userService"></param>
/// <param name="memberTypeService"></param>
/// <param name="entityService"></param>
/// <param name="externalLoginService"></param>
/// <param name="membershipProvider"></param>
/// <param name="contentSectionConfig"></param>
/// <param name="globalSettings"></param>
/// <returns></returns>
public static BackOfficeUserManager Create(
IdentityFactoryOptions <BackOfficeUserManager> options,
IUserService userService,
IMemberTypeService memberTypeService,
IEntityService entityService,
IExternalLoginService externalLoginService,
MembershipProviderBase membershipProvider,
IContentSection contentSectionConfig,
IGlobalSettings globalSettings)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (userService == null)
{
throw new ArgumentNullException("userService");
}
if (memberTypeService == null)
{
throw new ArgumentNullException("memberTypeService");
}
if (externalLoginService == null)
{
throw new ArgumentNullException("externalLoginService");
}
var manager = new BackOfficeUserManager(
new BackOfficeUserStore(userService, memberTypeService, entityService, externalLoginService, globalSettings, membershipProvider));
manager.InitUserManager(manager, membershipProvider, contentSectionConfig, options);
return(manager);
}
/// <summary>
/// Configure a custom UserStore with the Identity User Manager for Umbraco
/// </summary>
/// <param name="app"></param>
/// <param name="appContext"></param>
/// <param name="userMembershipProvider"></param>
/// <param name="customUserStore"></param>
public static void ConfigureUserManagerForUmbracoBackOffice(this IAppBuilder app,
ApplicationContext appContext,
MembershipProviderBase userMembershipProvider,
BackOfficeUserStore customUserStore)
{
if (appContext == null)
{
throw new ArgumentNullException("appContext");
}
if (userMembershipProvider == null)
{
throw new ArgumentNullException("userMembershipProvider");
}
if (customUserStore == null)
{
throw new ArgumentNullException("customUserStore");
}
//Configure Umbraco user manager to be created per request
app.CreatePerOwinContext <BackOfficeUserManager>(
(options, owinContext) => BackOfficeUserManager.Create(
options,
customUserStore,
userMembershipProvider));
//Create a sign in manager per request
app.CreatePerOwinContext <BackOfficeSignInManager>((options, context) => BackOfficeSignInManager.Create(options, context, app.CreateLogger(typeof(BackOfficeSignInManager).FullName)));
}
/// <summary>
/// Configure a custom UserStore with the Identity User Manager for Umbraco
/// </summary>
/// <param name="app"></param>
/// <param name="runtimeState"></param>
/// <param name="globalSettings"></param>
/// <param name="userMembershipProvider"></param>
/// <param name="customUserStore"></param>
/// <param name="contentSettings"></param>
public static void ConfigureUserManagerForUmbracoBackOffice(this IAppBuilder app,
IRuntimeState runtimeState,
IContentSection contentSettings,
IGlobalSettings globalSettings,
MembershipProviderBase userMembershipProvider,
BackOfficeUserStore customUserStore)
{
if (runtimeState == null)
{
throw new ArgumentNullException(nameof(runtimeState));
}
if (userMembershipProvider == null)
{
throw new ArgumentNullException(nameof(userMembershipProvider));
}
if (customUserStore == null)
{
throw new ArgumentNullException(nameof(customUserStore));
}
//Configure Umbraco user manager to be created per request
app.CreatePerOwinContext <BackOfficeUserManager>(
(options, owinContext) => BackOfficeUserManager.Create(
options,
customUserStore,
userMembershipProvider,
contentSettings));
app.SetBackOfficeUserManagerType <BackOfficeUserManager, BackOfficeIdentityUser>();
//Create a sign in manager per request
app.CreatePerOwinContext <BackOfficeSignInManager>((options, context) => BackOfficeSignInManager.Create(options, context, globalSettings, app.CreateLogger(typeof(BackOfficeSignInManager).FullName)));
}
/// <summary>
/// Configure Default Identity User Manager for Umbraco
/// </summary>
/// <param name="app"></param>
/// <param name="services"></param>
/// <param name="contentSettings"></param>
/// <param name="globalSettings"></param>
/// <param name="userMembershipProvider"></param>
public static void ConfigureUserManagerForUmbracoBackOffice(this IAppBuilder app,
ServiceContext services,
IContentSection contentSettings,
IGlobalSettings globalSettings,
MembershipProviderBase userMembershipProvider)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (userMembershipProvider == null)
{
throw new ArgumentNullException(nameof(userMembershipProvider));
}
//Configure Umbraco user manager to be created per request
app.CreatePerOwinContext <BackOfficeUserManager>(
(options, owinContext) => BackOfficeUserManager.Create(
options,
services.UserService,
services.MemberTypeService,
services.EntityService,
services.ExternalLoginService,
userMembershipProvider,
contentSettings,
globalSettings));
app.SetBackOfficeUserManagerType <BackOfficeUserManager, BackOfficeIdentityUser>();
//Create a sign in manager per request
app.CreatePerOwinContext <BackOfficeSignInManager>((options, context) => BackOfficeSignInManager.Create(options, context, globalSettings, app.CreateLogger <BackOfficeSignInManager>()));
}
/// <summary>
/// Creates a BackOfficeUserManager instance with all default options and the default BackOfficeUserManager
/// </summary>
/// <param name="options"></param>
/// <param name="userService"></param>
/// <param name="externalLoginService"></param>
/// <param name="membershipProvider"></param>
/// <returns></returns>
public static FortressBackOfficeUserManager Create(
IdentityFactoryOptions <FortressBackOfficeUserManager> options,
IUserService userService,
IExternalLoginService externalLoginService,
MembershipProviderBase membershipProvider)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (userService == null)
{
throw new ArgumentNullException("userService");
}
if (externalLoginService == null)
{
throw new ArgumentNullException("externalLoginService");
}
var manager = new FortressBackOfficeUserManager(new FortressBackOfficeUserStore(userService, externalLoginService, membershipProvider));
manager.InitUserManager(manager, membershipProvider, options.DataProtectionProvider);
//Here you can specify the 2FA providers that you want to implement,
//in this demo we are using the custom AcceptAnyCodeProvider - which literally accepts any code - do not actually use this!
var dataProtectionProvider = options.DataProtectionProvider;
manager.RegisterTwoFactorProvider("SMS", new SMSCodeProvider(dataProtectionProvider.Create("SMS")));
manager.RegisterTwoFactorProvider("GoogleAuthenticator", new GoogleAuthenticatorProvider(dataProtectionProvider.Create("GoogleAuthenticator")));
return(manager);
}
public AccountMembershipService(
MembershipProviderBase membership,
RoleProviderBase roles)
{
_membership = membership;
_roles = roles;
}
public UserPasswordPolicy(MembershipProviderBase provider, IUmbracoSettingsSection umbracoSettings) : base(provider)
{
if (umbracoSettings != null)
{
ForgotPasswordLinkAvailable = umbracoSettings.Security.AllowPasswordReset;
DisableAlternativeTemplates = umbracoSettings.WebRouting.DisableAlternativeTemplates;
DisableFindContentById = umbracoSettings.WebRouting.DisableFindContentByIdPath;
}
if (int.TryParse(ConfigurationManager.AppSettings["umbracoTimeOutInMinutes"], out int timeout))
{
UmbracoTimeoutInMinutes = timeout;
}
if (bool.TryParse(ConfigurationManager.AppSettings["umbracoUseSSL"], out bool umbracoUseSSL))
{
UmbracoUseSSL = umbracoUseSSL;
}
if (ConfigurationManager.GetSection("system.web/httpRuntime") is HttpRuntimeSection httpRuntimeSection)
{
MaxRequestLength = httpRuntimeSection.MaxRequestLength;
}
// TODO: MaxAllowedContentLength
// TODO: MaxRequestLengthUmbraco
// TODO: MaxAllowedContentLengthUmbraco
}
/// <summary>
/// Configure Default Identity User Manager for Umbraco
/// </summary>
/// <param name="app"></param>
/// <param name="appContext"></param>
/// <param name="userMembershipProvider"></param>
public static void ConfigureUserManagerForUmbracoBackOffice(this IAppBuilder app,
ApplicationContext appContext,
MembershipProviderBase userMembershipProvider)
{
if (appContext == null)
{
throw new ArgumentNullException("appContext");
}
if (userMembershipProvider == null)
{
throw new ArgumentNullException("userMembershipProvider");
}
//Configure Umbraco user manager to be created per request
app.CreatePerOwinContext <BackOfficeUserManager>(
(options, owinContext) => BackOfficeUserManager.Create(
options,
appContext.Services.UserService,
appContext.Services.EntityService,
appContext.Services.ExternalLoginService,
userMembershipProvider,
UmbracoConfig.For.UmbracoSettings().Content));
app.SetBackOfficeUserManagerType <BackOfficeUserManager, BackOfficeIdentityUser>();
//Create a sign in manager per request
app.CreatePerOwinContext <BackOfficeSignInManager>((options, context) => BackOfficeSignInManager.Create(options, context, app.CreateLogger <BackOfficeSignInManager>()));
}
/// <summary>
/// Initializes a new instance of the <see cref="RefreshAccessTokenAction" /> class.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="membershipProvider">The membership provider.</param>
public RefreshAccessTokenAction(UserInformation user, MembershipProviderBase membershipProvider)
: base(membershipProvider)
{
this.user = user;
this.clientId = this.Provider.GoogleClientId;
this.clientSecret = this.Provider.GoogleClientSecret;
this.authorization = this.user.Authorization;
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateGoogleClientAction"/> class.
/// </summary>
/// <param name="authorizationDescription"></param>
/// <param name="membershipProvider">The build motion provider.</param>
public CreateGoogleClientAction(AuthorizationServerDescription authorizationDescription, MembershipProviderBase membershipProvider)
: base(membershipProvider)
{
this.authorizationDescription = authorizationDescription;
//PATTERN: setup in constructor to allow for action validation on fields/properties;
this.clientId = this.Provider.GoogleClientId;
this.clientSecret = this.Provider.GoogleClientSecret;
}
public PasswordPolicyBase(MembershipProviderBase provider)
{
MinRequiredPasswordLength = provider.MinRequiredPasswordLength;
MinRequiredNonAlphanumericCharacters = provider.MinRequiredNonAlphanumericCharacters;
MaxInvalidPasswordAttempts = provider.MaxInvalidPasswordAttempts;
UseLegacyEncoding = provider.UseLegacyEncoding;
PasswordStorageFormat = provider.PasswordFormat.ToString();
}
public AccountMembershipService(
MembershipProviderBase membership,
RoleProviderBase roles,
IEmailManager emailManager)
{
_membership = membership;
_roles = roles;
_emailManager = emailManager;
}
/// <summary>
/// Initializes the user manager with the correct options
/// </summary>
/// <param name="manager"></param>
/// <param name="membershipProvider"></param>
/// <param name="contentSectionConfig"></param>
/// <param name="options"></param>
/// <returns></returns>
protected void InitUserManager(
BackOfficeUserManager manager,
MembershipProviderBase membershipProvider,
IContentSection contentSectionConfig,
IdentityFactoryOptions <BackOfficeUserManager> options)
{
//NOTE: This method is mostly here for backwards compat
base.InitUserManager(manager, membershipProvider, options.DataProtectionProvider, contentSectionConfig);
}
/// <summary>
/// Creates a BackOfficeUserManager instance with all default options and a custom BackOfficeUserManager instance
/// </summary>
/// <param name="options"></param>
/// <param name="customUserStore"></param>
/// <param name="membershipProvider"></param>
/// <param name="contentSectionConfig"></param>
/// <returns></returns>
public static BackOfficeUserManager Create(
IdentityFactoryOptions <BackOfficeUserManager> options,
BackOfficeUserStore customUserStore,
MembershipProviderBase membershipProvider,
IContentSection contentSectionConfig)
{
var manager = new BackOfficeUserManager(customUserStore, options, membershipProvider, contentSectionConfig);
return(manager);
}
public BackOfficeUserManager(
IUserStore <BackOfficeIdentityUser, int> store,
IdentityFactoryOptions <BackOfficeUserManager> options,
MembershipProviderBase membershipProvider,
IContentSection contentSectionConfig)
: base(store)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
InitUserManager(this, membershipProvider, contentSectionConfig, options);
}
public void Check_Salt_Length()
{
var lastLength = 0;
for (var i = 0; i < 10000; i++)
{
var result = MembershipProviderBase.GenerateSalt();
if (i > 0)
{
Assert.AreEqual(lastLength, result.Length);
}
lastLength = result.Length;
}
}
public void Format_Pass_For_Storage_Hashed()
{
var providerMock = new Mock <MembershipProviderBase>()
{
CallBase = true
};
var provider = providerMock.Object;
provider.Initialize("test", new NameValueCollection {
{ "passwordFormat", "Hashed" }, { "hashAlgorithmType", "HMACSHA256" }
});
var salt = MembershipProviderBase.GenerateSalt();
var stored = "ThisIsAHashedPassword";
var result = provider.FormatPasswordForStorage(stored, salt);
Assert.AreEqual(salt + "ThisIsAHashedPassword", result);
}
public void Format_Pass_For_Storage_Clear()
{
var providerMock = new Mock <MembershipProviderBase>()
{
CallBase = true
};
var provider = providerMock.Object;
provider.Initialize("test", new NameValueCollection {
{ "passwordFormat", "Clear" }
});
var salt = MembershipProviderBase.GenerateSalt();
var stored = "ThisIsAClearPassword";
var result = provider.FormatPasswordForStorage(stored, salt);
Assert.AreEqual("ThisIsAClearPassword", result);
}
/// <summary>
/// Creates a BackOfficeUserManager instance with all default options and the default BackOfficeUserManager
/// </summary>
/// <param name="options"></param>
/// <param name="userService"></param>
/// <param name="entityService"></param>
/// <param name="externalLoginService"></param>
/// <param name="membershipProvider"></param>
/// <returns></returns>
public static TwoFactorBackOfficeUserManager Create(
IdentityFactoryOptions <TwoFactorBackOfficeUserManager> options,
IUserService userService,
IEntityService entityService,
IExternalLoginService externalLoginService,
MembershipProviderBase membershipProvider)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (userService == null)
{
throw new ArgumentNullException("userService");
}
if (entityService == null)
{
throw new ArgumentNullException("entityService");
}
if (externalLoginService == null)
{
throw new ArgumentNullException("externalLoginService");
}
var manager = new TwoFactorBackOfficeUserManager(new TwoFactorBackOfficeUserStore(userService, externalLoginService, entityService, membershipProvider));
manager.InitUserManager(manager, membershipProvider, options.DataProtectionProvider, UmbracoConfig.For.UmbracoSettings().Content);
//Here you can specify the 2FA providers that you want to implement
var dataProtectionProvider = options.DataProtectionProvider;
manager.RegisterTwoFactorProvider(Constants.YubiKeyProviderName,
new TwoFactorValidationProvider(dataProtectionProvider.Create(Constants.YubiKeyProviderName)));
manager.RegisterTwoFactorProvider(Constants.GoogleAuthenticatorProviderName,
new TwoFactorValidationProvider(dataProtectionProvider.Create(Constants.GoogleAuthenticatorProviderName)));
return(manager);
}
public void Sets_Defaults()
{
var providerMock = new Mock <MembershipProviderBase>()
{
CallBase = true
};
var provider = providerMock.Object;
provider.Initialize("test", new NameValueCollection());
Assert.AreEqual("test", provider.Name);
Assert.AreEqual(MembershipProviderBase.GetDefaultAppName(), provider.ApplicationName);
Assert.AreEqual(false, provider.EnablePasswordRetrieval);
Assert.AreEqual(true, provider.EnablePasswordReset);
Assert.AreEqual(false, provider.RequiresQuestionAndAnswer);
Assert.AreEqual(true, provider.RequiresUniqueEmail);
Assert.AreEqual(5, provider.MaxInvalidPasswordAttempts);
Assert.AreEqual(10, provider.PasswordAttemptWindow);
Assert.AreEqual(provider.DefaultMinPasswordLength, provider.MinRequiredPasswordLength);
Assert.AreEqual(provider.DefaultMinNonAlphanumericChars, provider.MinRequiredNonAlphanumericCharacters);
Assert.AreEqual(null, provider.PasswordStrengthRegularExpression);
Assert.AreEqual(provider.DefaultUseLegacyEncoding, provider.UseLegacyEncoding);
Assert.AreEqual(MembershipPasswordFormat.Hashed, provider.PasswordFormat);
}
public MemberPasswordPolicy(MembershipProviderBase provider) : base(provider)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="AddEmailToRoleAction"/> class.
/// </summary>
/// <param name="email">The email.</param>
/// <param name="roleId">The role id.</param>
/// <param name="membershipProvider">The build motion provider.</param>
public AddEmailToRoleAction(string email, int roleId, MembershipProviderBase membershipProvider)
: base(membershipProvider)
{
this.email = email;
this.roleId = roleId;
}
public FortressBackOfficeUserStore(IUserService userService, IExternalLoginService externalLoginService, MembershipProviderBase usersMembershipProvider)
: base(userService, externalLoginService, usersMembershipProvider)
{
}
public TwoFactorBackOfficeUserStore(IUserService userService, IMemberTypeService memberService, IExternalLoginService externalLoginService,
IEntityService entityService, MembershipProviderBase usersMembershipProvider, IGlobalSettings globalSettings, UmbracoMapper umbracoMapper)
: base(userService, memberService, entityService, externalLoginService, globalSettings, usersMembershipProvider, umbracoMapper)
{
}
public RemoveRolesFromUserAction(List<Role> removeRoles, UserInformation user, MembershipProviderBase membershipProvider)
: base(membershipProvider)
{
this.removeRoles = removeRoles;
this.user = user;
}
/// <summary>
/// Initializes a new instance of the <see cref="UpdateUserAction"/> class.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="membershipProvider">The membership provider.</param>
public UpdateUserAction(UserInformation user, MembershipProviderBase membershipProvider)
: base(membershipProvider)
{
this.user = user;
}
/// <summary>
/// Initializes a new instance of the <see cref="RetrieveEmailInRolesAction"/> class.
/// </summary>
/// <param name="emailAddress">The email address.</param>
/// <param name="provider">The provider.</param>
public RetrieveEmailInRolesAction(string emailAddress, MembershipProviderBase provider)
: base(provider)
{
this.emailAddress = emailAddress;
}
/// <summary>
/// Initializes a new instance of the <see cref="AddUserToRoleAction"/> class.
/// </summary>
/// <param name="emailInRole">The email in role.</param>
/// <param name="membershipProvider">The membership provider.</param>
public AddUserToRoleAction(EmailInRole emailInRole, MembershipProviderBase membershipProvider)
: base(membershipProvider)
{
this.emailInRole = emailInRole;
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateRoleAction"/> class.
/// </summary>
/// <param name="role">The role.</param>
/// <param name="membershipProvider">The membership provider.</param>
public CreateRoleAction(Role role, MembershipProviderBase membershipProvider)
: base(membershipProvider)
{
this.role = role;
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateFormsAuthenticationCookieAction" /> class.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="provider">The provider.</param>
/// <exception cref="System.NotImplementedException"></exception>
public CreateFormsAuthenticationCookieAction(UserInformation user, MembershipProviderBase provider)
: base(provider)
{
this.user = user;
this.rolesUserDate = this.Provider.RetrieveUserRolesString(this.user.Email);
}
/// <summary>
/// Initializes a new instance of the <see cref="UserDomainIsValidAction"/> class.
/// </summary>
/// <param name="domain">The domain.</param>
/// <param name="membershipProvider">The membership provider.</param>
public UserDomainIsValidAction(string domain, MembershipProviderBase membershipProvider)
: base(membershipProvider)
{
this.domain = domain;
}
/// <summary>
/// Initializes a new instance of the <see cref="RemoveUserInRoleAction" /> class.
/// </summary>
/// <param name="emailInRole">The email in role.</param>
/// <param name="membershipProvider">The membership provider.</param>
public RemoveUserInRoleAction(EmailInRole emailInRole, MembershipProviderBase membershipProvider)
: base(membershipProvider)
{
this.emailInRole = emailInRole;
}
/// <summary>
/// Initializes a new instance of the <see cref="RetrieveRoleAction" /> class.
/// </summary>
/// <param name="roleId">The role id.</param>
/// <param name="membershipProvider">The membership provider.</param>
public RetrieveRoleAction(int roleId, MembershipProviderBase membershipProvider)
: base(membershipProvider)
{
this.roleId = roleId;
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionBase" /> class.
/// </summary>
/// <param name="provider">The provider.</param>
public ActionBase(MembershipProviderBase provider)
{
this.provider = provider;
this.repository = provider.Repository;
}
/// <summary>
/// Initializes a new instance of the <see cref="RetrieveTokenInfoAction"/> class.
/// </summary>
/// <param name="accessToken">The access token.</param>
/// <param name="membershipProvider">The build motion provider.</param>
public RetrieveTokenInfoAction(string accessToken, MembershipProviderBase membershipProvider)
: base(membershipProvider)
{
this.accessToken = accessToken;
}
private void EmailCustomValidator_OnServerValidate(object source, ServerValidateEventArgs args)
{
args.IsValid = MembershipProviderBase.IsEmailValid(email.Text.Trim());
}
/// <summary>
/// Initializes a new instance of the <see cref="RetrieveUserInformationAction"/> class.
/// </summary>
/// <param name="emailAddress">The email address.</param>
/// <param name="provider">The provider.</param>
public RetrieveUserInformationAction(string emailAddress, MembershipProviderBase provider)
: base(provider)
{
this.emailAddress = emailAddress;
}
/// <summary>
/// Initializes a new instance of the <see cref="RetrieveUserRolesAction"/> class.
/// </summary>
/// <param name="email">The email.</param>
/// <param name="provider">The provider.</param>
public RetrieveUserRolesAction(string email, MembershipProviderBase provider)
: base(provider)
{
this.email = email;
}
/// <summary>
/// Initializes a new instance of the <see cref="RetrieveRolesAction"/> class.
/// </summary>
/// <param name="membershipProvider">The membership provider.</param>
public RetrieveRolesAction(MembershipProviderBase membershipProvider)
: base(membershipProvider)
{
}
protected void EmailValidator_OnServerValidate(object source, ServerValidateEventArgs args)
{
args.IsValid = MembershipProviderBase.IsEmailValid(args.Value);
}
public void Valid_Password(string password, int minRequiredNonAlphanumericChars, string strengthRegex, int minLength, bool pass)
{
var result = MembershipProviderBase.IsPasswordValid(password, minRequiredNonAlphanumericChars, strengthRegex, minLength);
Assert.AreEqual(pass, result.Success);
}
/// <summary>
/// Initializes a new instance of the <see cref="RetrieveGoogleUserInformationAction"/> class.
/// </summary>
/// <param name="accessToken">The access token.</param>
/// <param name="provider">The provider.</param>
/// <exception cref="System.NotImplementedException"></exception>
public RetrieveGoogleUserInformationAction(string accessToken, MembershipProviderBase provider)
: base(provider)
{
this.accessToken = accessToken;
}
private bool isValid = true; //let's assume the token is valid;
/// <summary>
/// Initializes a new instance of the <see cref="ValidateTokenAction"/> class.
/// </summary>
/// <param name="accessToken">The access token.</param>
/// <param name="provider">The provider.</param>
public ValidateTokenAction(string accessToken, MembershipProviderBase provider) : base(provider)
{
this.accessToken = accessToken;
}
/// <summary>
/// Initializes a new instance of the <see cref="AddRolesToUserAction"/> class.
/// </summary>
/// <param name="addRoles">The add roles.</param>
/// <param name="user">The user.</param>
/// <param name="provider">The provider.</param>
public AddRolesToUserAction(List<Role> addRoles, UserInformation user, MembershipProviderBase provider)
: base(provider)
{
this.addRoles = addRoles;
this.user = user;
}
public TwoFactorBackOfficeUserStore(IUserService userService, IExternalLoginService externalLoginService,
IEntityService entityService, MembershipProviderBase usersMembershipProvider)
: base(userService, entityService, externalLoginService, usersMembershipProvider)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RetrieveCurrentAccessTokenAction"/> class.
/// </summary>
/// <param name="emailAddress">The email address.</param>
/// <param name="membershipProvider">The membership provider.</param>
public RetrieveCurrentAccessTokenAction(string emailAddress, MembershipProviderBase membershipProvider)
: base(membershipProvider)
{
this.emailAddress = emailAddress;
}
