/// <summary>
/// Load active external authentication methods
/// </summary>
/// <param name="User">Load records allowed only to a specified User; pass null to ignore ACL permissions</param>
/// <param name="storeId">Load records allowed only in a specified store; pass 0 to load all records</param>
/// <returns>Payment methods</returns>
//public virtual IList<IExternalAuthenticationMethod> LoadActiveExternalAuthenticationMethods(User User = null, int storeId = 0)
//{
// return LoadAllExternalAuthenticationMethods(User, storeId)
// .Where(provider => _externalAuthenticationSettings.ActiveAuthenticationMethodSystemNames
// .Contains(provider.PluginDescriptor.SystemName, StringComparer.InvariantCultureIgnoreCase)).ToList();
//}
/// <summary>
/// Load external authentication method by system name
/// </summary>
/// <param name="systemName">System name</param>
/// <returns>Found external authentication method</returns>
//public virtual IExternalAuthenticationMethod LoadExternalAuthenticationMethodBySystemName(string systemName)
//{
// var descriptor = _pluginFinder.GetPluginDescriptorBySystemName<IExternalAuthenticationMethod>(systemName);
// if (descriptor != null)
// return descriptor.Instance<IExternalAuthenticationMethod>();
// return null;
//}
/// <summary>
/// Load all external authentication methods
/// </summary>
/// <param name="User">Load records allowed only to a specified User; pass null to ignore ACL permissions</param>
/// <param name="storeId">Load records allowed only in a specified store; pass 0 to load all records</param>
/// <returns>External authentication methods</returns>
//public virtual IList<IExternalAuthenticationMethod> LoadAllExternalAuthenticationMethods(User User = null, int storeId = 0)
//{
// return _pluginFinder.GetPlugins<IExternalAuthenticationMethod>(User: User, storeId: storeId).ToList();
//}
#endregion
/// <summary>
/// Accociate external account with User
/// </summary>
/// <param name="User">User</param>
/// <param name="parameters">Open authentication parameters</param>
public virtual void AssociateExternalAccountWithUser(User User, OpenAuthenticationParameters parameters)
{
if (User == null)
{
throw new ArgumentNullException("User");
}
//find email
string email = null;
if (parameters.UserClaims != null)
{
foreach (var userClaim in parameters.UserClaims
.Where(x => x.Contact != null && !String.IsNullOrEmpty(x.Contact.Email)))
{
//found
email = userClaim.Contact.Email;
break;
}
}
var externalAuthenticationRecord = new ExternalAuthenticationRecord
{
UserId = User.Id,
Email = email,
ExternalIdentifier = parameters.ExternalIdentifier,
ExternalDisplayIdentifier = parameters.ExternalDisplayIdentifier,
OAuthToken = parameters.OAuthToken,
OAuthAccessToken = parameters.OAuthAccessToken,
ProviderSystemName = parameters.ProviderSystemName,
};
_externalAuthenticationRecordRepository.Insert(externalAuthenticationRecord);
}
/// <summary>
/// Remove the association
/// </summary>
/// <param name="parameters">Open authentication parameters</param>
public virtual void RemoveAssociation(OpenAuthenticationParameters parameters)
{
var record = _externalAuthenticationRecordRepository.Table
.FirstOrDefault(o => o.ExternalIdentifier == parameters.ExternalIdentifier &&
o.ProviderSystemName == parameters.ProviderSystemName);
if (record != null)
{
_externalAuthenticationRecordRepository.Delete(record);
}
}
/// <summary>
/// Get the particular user with specified parameters
/// </summary>
/// <param name="parameters">Open authentication parameters</param>
/// <returns>User</returns>
public virtual User GetUser(OpenAuthenticationParameters parameters)
{
var record = _externalAuthenticationRecordRepository.Table
.FirstOrDefault(o => o.ExternalIdentifier == parameters.ExternalIdentifier &&
o.ProviderSystemName == parameters.ProviderSystemName);
if (record != null)
{
return(_UserService.GetUserById(record.UserId));
}
return(null);
}
/// <summary>
/// Check that account exists
/// </summary>
/// <param name="parameters">Open authentication parameters</param>
/// <returns>True if it exists; otherwise false</returns>
public virtual bool AccountExists(OpenAuthenticationParameters parameters)
{
return(GetUser(parameters) != null);
}
public virtual AuthorizationResult Authorize(OpenAuthenticationParameters parameters)
{
var userFound = _openAuthenticationService.GetUser(parameters);
var userLoggedIn = _workContext.CurrentUser.IsRegistered() ? _workContext.CurrentUser : null;
if (AccountAlreadyExists(userFound, userLoggedIn))
{
if (AccountIsAssignedToLoggedOnAccount(userFound, userLoggedIn))
{
// The person is trying to log in as himself.. bit weird
return(new AuthorizationResult(OpenAuthenticationStatus.Authenticated));
}
var result = new AuthorizationResult(OpenAuthenticationStatus.Error);
result.AddError("Account is already assigned");
return(result);
}
if (AccountDoesNotExistAndUserIsNotLoggedOn(userFound, userLoggedIn))
{
ExternalAuthorizerHelper.StoreParametersForRoundTrip(parameters);
if (AutoRegistrationIsEnabled())
{
#region Register user
var currentUser = _workContext.CurrentUser;
var details = new RegistrationDetails(parameters);
var randomPassword = CommonHelper.GenerateRandomDigitCode(20);
bool isApproved =
//standard registration
(_UserSettings.UserRegistrationType == UserRegistrationType.Standard) ||
//skip email validation?
(_UserSettings.UserRegistrationType == UserRegistrationType.EmailValidation &&
!_externalAuthenticationSettings.RequireEmailValidation);
var registrationRequest = new UserRegistrationRequest(currentUser,
details.EmailAddress,
_UserSettings.UsernamesEnabled ? details.UserName : details.EmailAddress,
randomPassword,
PasswordFormat.Clear,
_storeContext.CurrentStore.Id,
isApproved);
var registrationResult = _UserRegistrationService.RegisterUser(registrationRequest);
if (registrationResult.Success)
{
//store other parameters (form fields)
if (!String.IsNullOrEmpty(details.FirstName))
{
_genericAttributeService.SaveAttribute(currentUser, SystemUserAttributeNames.FirstName, details.FirstName);
}
if (!String.IsNullOrEmpty(details.LastName))
{
_genericAttributeService.SaveAttribute(currentUser, SystemUserAttributeNames.LastName, details.LastName);
}
userFound = currentUser;
_openAuthenticationService.AssociateExternalAccountWithUser(currentUser, parameters);
ExternalAuthorizerHelper.RemoveParameters();
//code below is copied from UserController.Register method
//authenticate
if (isApproved)
{
_authenticationService.SignIn(userFound ?? userLoggedIn, false);
}
//notifications
if (_UserSettings.NotifyNewUserRegistration)
{
_workflowMessageService.SendUserRegisteredNotificationMessage(currentUser, _localizationSettings.DefaultAdminLanguageId);
}
//raise event
_eventPublisher.Publish(new UserRegisteredEvent(currentUser));
if (isApproved)
{
//standard registration
//or
//skip email validation
//send User welcome message
_workflowMessageService.SendUserWelcomeMessage(currentUser, _workContext.WorkingLanguage.Id);
//result
return(new AuthorizationResult(OpenAuthenticationStatus.AutoRegisteredStandard));
}
else if (_UserSettings.UserRegistrationType == UserRegistrationType.EmailValidation)
{
//email validation message
_genericAttributeService.SaveAttribute(currentUser, SystemUserAttributeNames.AccountActivationToken, Guid.NewGuid().ToString());
_workflowMessageService.SendUserEmailValidationMessage(currentUser, _workContext.WorkingLanguage.Id);
//result
return(new AuthorizationResult(OpenAuthenticationStatus.AutoRegisteredEmailValidation));
}
else if (_UserSettings.UserRegistrationType == UserRegistrationType.AdminApproval)
{
//result
return(new AuthorizationResult(OpenAuthenticationStatus.AutoRegisteredAdminApproval));
}
}
else
{
ExternalAuthorizerHelper.RemoveParameters();
var result = new AuthorizationResult(OpenAuthenticationStatus.Error);
foreach (var error in registrationResult.Errors)
{
result.AddError(string.Format(error));
}
return(result);
}
#endregion
}
else if (RegistrationIsEnabled())
{
return(new AuthorizationResult(OpenAuthenticationStatus.AssociateOnLogon));
}
else
{
ExternalAuthorizerHelper.RemoveParameters();
var result = new AuthorizationResult(OpenAuthenticationStatus.Error);
result.AddError("Registration is disabled");
return(result);
}
}
if (userFound == null)
{
_openAuthenticationService.AssociateExternalAccountWithUser(userLoggedIn, parameters);
}
//migrate shopping cart
//_shoppingCartService.MigrateShoppingCart(_workContext.CurrentUser, userFound ?? userLoggedIn, true);
//authenticate
_authenticationService.SignIn(userFound ?? userLoggedIn, false);
//raise event
_eventPublisher.Publish(new UserLoggedinEvent(userFound ?? userLoggedIn));
//activity log
_UserActivityService.InsertActivity("PublicStore.Login", _localizationService.GetResource("ActivityLog.PublicStore.Login"),
userFound ?? userLoggedIn);
return(new AuthorizationResult(OpenAuthenticationStatus.Authenticated));
}
public static void StoreParametersForRoundTrip(OpenAuthenticationParameters parameters)
{
var session = GetSession();
session["nop.externalauth.parameters"] = parameters;
}
