/// <summary>
/// Register new user
/// </summary>
/// <param name="parameters">Authentication parameters received from external authentication method</param>
/// <param name="returnUrl">URL to which the user will return after authentication</param>
/// <returns>Result of an authentication</returns>
protected virtual async Task <IActionResult> RegisterNewUser(ExternalAuthenticationParameters parameters, string returnUrl)
{
//if auto registration is disabled redirect to login page
//TODO remove this setting
if (!_externalAuthenticationSettings.AutoRegisterEnabled)
{
ExternalAuthorizerHelper.StoreParametersForRoundTrip(parameters, _httpContextAccessor);
return(new RedirectToActionResult("Login", "Customer", !string.IsNullOrEmpty(returnUrl) ? new { ReturnUrl = returnUrl } : null));
}
//or try to auto register new user
//registration is approved if validation isn't required
var registrationIsApproved = _customerSettings.UserRegistrationType == UserRegistrationType.Standard ||
(_customerSettings.UserRegistrationType == UserRegistrationType.EmailValidation && !_externalAuthenticationSettings.RequireEmailValidation);
//create registration request
var registrationRequest = new CustomerRegistrationRequest(_workContext.CurrentCustomer,
parameters.Email, parameters.Email,
CommonHelper.GenerateRandomDigitCode(20),
PasswordFormat.Hashed,
_storeContext.CurrentStore.Id,
registrationIsApproved);
//whether registration request has been completed successfully
var registrationResult = await _customerRegistrationService.RegisterCustomer(registrationRequest);
if (!registrationResult.Success)
{
return(Error(registrationResult.Errors, returnUrl));
}
//allow to save other customer values by consuming this event
await _mediator.Publish(new CustomerAutoRegisteredByExternalMethodEvent(_workContext.CurrentCustomer, parameters));
//raise vustomer registered event
await _mediator.Publish(new CustomerRegisteredEvent(_workContext.CurrentCustomer));
//store owner notifications
if (_customerSettings.NotifyNewCustomerRegistration)
{
await _workflowMessageService.SendCustomerRegisteredNotificationMessage(_workContext.CurrentCustomer, _storeContext.CurrentStore, _localizationSettings.DefaultAdminLanguageId);
}
//associate external account with registered user
await AssociateExternalAccountWithUser(_workContext.CurrentCustomer, parameters);
//authenticate
if (registrationIsApproved)
{
await _authenticationService.SignIn(_workContext.CurrentCustomer, false);
await _workflowMessageService.SendCustomerWelcomeMessage(_workContext.CurrentCustomer, _storeContext.CurrentStore, _workContext.WorkingLanguage.Id);
return(new RedirectToRouteResult("RegisterResult", new { resultId = (int)UserRegistrationType.Standard }));
}
//registration is succeeded but isn't activated
if (_customerSettings.UserRegistrationType == UserRegistrationType.EmailValidation)
{
//email validation message
await _genericAttributeService.SaveAttribute(_workContext.CurrentCustomer, SystemCustomerAttributeNames.AccountActivationToken, Guid.NewGuid().ToString());
await _workflowMessageService.SendCustomerEmailValidationMessage(_workContext.CurrentCustomer, _storeContext.CurrentStore, _workContext.WorkingLanguage.Id);
return(new RedirectToRouteResult("RegisterResult", new { resultId = (int)UserRegistrationType.EmailValidation }));
}
//registration is succeeded but isn't approved by admin
if (_customerSettings.UserRegistrationType == UserRegistrationType.AdminApproval)
{
return(new RedirectToRouteResult("RegisterResult", new { resultId = (int)UserRegistrationType.AdminApproval }));
}
//TODO create locale for error
return(Error(new[] { "Error on registration" }, returnUrl));
}
/// <summary>
/// Accociate external account with customer
/// </summary>
/// <param name="customer">Customer</param>
/// <param name="parameters">External authentication parameters</param>
public virtual async Task AssociateExternalAccountWithUser(Customer customer, ExternalAuthenticationParameters parameters)
{
if (customer == null)
{
throw new ArgumentNullException("customer");
}
var externalAuthenticationRecord = new ExternalAuthenticationRecord
{
CustomerId = customer.Id,
Email = parameters.Email,
ExternalIdentifier = parameters.ExternalIdentifier,
ExternalDisplayIdentifier = parameters.ExternalDisplayIdentifier,
OAuthAccessToken = parameters.AccessToken,
ProviderSystemName = parameters.ProviderSystemName,
};
await _externalAuthenticationRecordRepository.InsertAsync(externalAuthenticationRecord);
}
/// <summary>
/// Authenticate current user and associate new external account with user
/// </summary>
/// <param name="currentLoggedInUser">Current logged-in user</param>
/// <param name="parameters">Authentication parameters received from external authentication method</param>
/// <param name="returnUrl">URL to which the user will return after authentication</param>
/// <returns>Result of an authentication</returns>
protected virtual async Task <IActionResult> AuthenticateNewUser(Customer currentLoggedInUser, ExternalAuthenticationParameters parameters, string returnUrl)
{
//associate external account with logged-in user
if (currentLoggedInUser != null)
{
await AssociateExternalAccountWithUser(currentLoggedInUser, parameters);
if (String.IsNullOrEmpty(returnUrl))
{
return(new RedirectToRouteResult("HomePage", new { area = "" }));
}
return(new RedirectResult(returnUrl));
}
//or try to register new user
if (_customerSettings.UserRegistrationType != UserRegistrationType.Disabled)
{
return(await RegisterNewUser(parameters, returnUrl));
}
//registration is disabled
//TODO create locale for error
return(Error(new[] { "Registration is disabled" }, returnUrl));
}
public CustomerAutoRegisteredByExternalMethodEvent(Customer customer, ExternalAuthenticationParameters parameters)
{
this.Customer = customer;
this.AuthenticationParameters = parameters;
}
public static void StoreParametersForRoundTrip(ExternalAuthenticationParameters parameters, IHttpContextAccessor httpContextAccessor)
{
httpContextAccessor.HttpContext?.Session?.Set(EXTERNAL_AUTHENTICATION_PARAMETERS, parameters);
}
/// <summary>
/// Get the particular user with specified parameters
/// </summary>
/// <param name="parameters">External authentication parameters</param>
/// <returns>Customer</returns>
public virtual async Task <Customer> GetUserByExternalAuthenticationParameters(ExternalAuthenticationParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var associationRecord = await _externalAuthenticationRecordRepository.Table.FirstOrDefaultAsync(record =>
record.ExternalIdentifier.Equals(parameters.ExternalIdentifier) && record.ProviderSystemName.Equals(parameters.ProviderSystemName));
if (associationRecord == null)
{
return(null);
}
return(await _customerService.GetCustomerById(associationRecord.CustomerId));
}
public static void StoreParametersForRoundTrip(ExternalAuthenticationParameters parameters)
{
EngineContext.Current.Resolve <IHttpContextAccessor>().HttpContext?.Session?.Set(EXTERNAL_AUTHENTICATION_PARAMETERS, parameters);
}