public async Task <HttpResponseMessage> CustomerRegister(CustomerRegistrationRequest request)
{
HttpResponseMessage httpResponse = null;
Customer cuz = null;
string uri = string.Empty;
var rmsCustomer = await this.mainService.RegisterNewCustomerInProjectAsync(request);
IResultServiceModel <CustomerRegistrationResponse> response = new ResultServiceModel <CustomerRegistrationResponse>();
if (rmsCustomer.Success)
{
cuz = rmsCustomer.Value;
this.mainService.SendEmailNewCustomerSignUp(cuz, this.GetBaseUrl());
response.OnSuccess(new CustomerRegistrationResponse()
{
CustomerId = cuz.Id, ProjectId = rmsCustomer.Value.ProjectId
});
}
else
{
response.OnError(rmsCustomer.ErrorMessage, rmsCustomer.ErrorCode);
}
httpResponse = Request.CreateResponse <IResultServiceModel <CustomerRegistrationResponse> >(HttpStatusCode.Created, response);
uri = Url.Link("CustomerInfo", new { id = response.ErrorCode });
httpResponse.Headers.Location = new Uri(uri);
return(httpResponse);
}
public ActionResult Create(CustomerCreateModel model)
{
var roles = _customerService.GetAllCustomerRoles();
model.AvailableRoles = roles.ToSelectItems();
if (!ModelState.IsValid)
{
return(View(model));
}
var customer = new Customer
{
Username = model.UserName,
CreatedOn = DateTime.Now,
MobilePhone = model.PhoneNumber,
RealName = model.RealName,
CustomerRoleId = model.CustomerRoleId,
Active = model.IsActive,
LastActivityDate = DateTime.Now
};
var customerRequest = new CustomerRegistrationRequest(customer, model.UserName, model.PassWord,
PasswordFormat.Hashed);
var reponse = _customerRegistrationService.RegisterCustomer(customerRequest);
if (reponse.Success)
{
return(RedirectToAction("ListCustomer"));
}
reponse.Errors.ForEach(d => { ModelState.AddModelError(string.Empty, d); });
return(View(model));
}
/// <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 IActionResult RegisterNewUser(ExternalAuthenticationParameters parameters, string returnUrl)
{
//check whether the specified email has been already registered
if (_customerService.GetCustomerByEmail(parameters.Email) != null)
{
var alreadyExistsError = string.Format("Email地址“{0}”已经存在", parameters.ExternalDisplayIdentifier);
return(ErrorAuthentication(new[] { alreadyExistsError }, returnUrl));
}
//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.Clear,
registrationIsApproved);
//whether registration request has been completed successfully
var registrationResult = _customerRegistrationService.RegisterCustomer(registrationRequest);
if (!registrationResult.Success)
{
return(ErrorAuthentication(registrationResult.Errors, returnUrl));
}
//allow to save other customer values by consuming this event
_eventPublisher.Publish(new CustomerAutoRegisteredByExternalMethodEvent(_workContext.CurrentCustomer, parameters));
//raise vustomer registered event
_eventPublisher.Publish(new CustomerRegisteredEvent(_workContext.CurrentCustomer));
//associate external account with registered user
AssociateExternalAccountWithUser(_workContext.CurrentCustomer, parameters);
//authenticate
if (registrationIsApproved)
{
_authenticationService.SignIn(_workContext.CurrentCustomer, false);
return(new RedirectToRouteResult("RegisterResult", new { resultId = (int)UserRegistrationType.Standard }));
}
//registration is succeeded but isn't activated
if (_customerSettings.UserRegistrationType == UserRegistrationType.EmailValidation)
{
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 }));
}
return(ErrorAuthentication(new[] { "Error on registration" }, returnUrl));
}
public CustomerRegistrationResponse CustomerRegistration(CustomerRegistrationRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
return(SendGetRequest <CustomerRegistrationRequest, CustomerRegistrationResponse>(request, "CustomerRegistration"));
}
public async Task <IActionResult> RegisterClient([FromBody] CustomerRegistrationRequest request)
{
var registrationResult = await mediator.Send(request);
return(registrationResult.Succeeded switch
{
true => Ok(registrationResult.Response),
false => BadRequest(new BadRequestModel(registrationResult.Errors))
});
public async Task <ActionResult> Registration(CustomerRegistrationRequest registration)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _userRepository.Create(registration);
return(Ok("account created"));
}
public async Task <ActionResult> Login(CustomerRegistrationRequest registration)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _userRepository.Login(registration);
return(Ok(result));
}
public ActionResult Insert(BankModel model, GridCommand command)
{
ModelState.Remove("Id");
if (!ModelState.IsValid)
{
var modelStateErrors = ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage);
return(Content(modelStateErrors.FirstOrDefault()));
}
var customer = new Customer();
customer.CreatedOnUtc = DateTime.UtcNow;
customer.CustomerGuid = Guid.NewGuid();
customer.LastActivityDateUtc = DateTime.UtcNow;
_customerService.InsertCustomer(customer);
var request = new CustomerRegistrationRequest(customer, model.Email, model.Email, "123456", _customerSettings.DefaultPasswordFormat);
var result = _customerRegistrationService.RegisterCustomer(request);
if (result.Success)
{
customer.CompanyName = model.BankTitle;
customer.Email = model.Email;
customer.Username = model.Email;
if (model.Rating != 0)
{
customer.Rating = model.Rating;
}
if (model.PictureId != 0)
{
customer.ProviderLogoId = model.PictureId;
}
customer.CustomerRoles.Add(_customerService.GetCustomerRoleBySystemName("Sellers"));
_customerService.UpdateCustomer(customer);
}
else
{
_customerService.DeleteCustomerPermamently(customer);
foreach (var error in result.Errors)
{
if (error == _localizationService.GetResource("Account.Register.Errors.EmailAlreadyExists"))
{
ModelState.AddModelError("Email", error);
}
ModelState.AddModelError("", error);
}
var modelStateErrors = ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage);
return(Content(modelStateErrors.FirstOrDefault()));
}
return(List(command));
}
public virtual AuthorizationResult Authorize(OpenAuthenticationParameters parameters)
{
var userFound = _openAuthenticationService.GetUser(parameters);
var userLoggedIn = _workContext.CurrentCustomer;
if (AccountAlreadyExists(userFound, userLoggedIn))
{
_authenticationService.SignIn(userFound, false);
}
else
{
#region Register user
var currentCustomer = _workContext.CurrentCustomer;
var details = new Nop.Plugin.ExternalAuth.Weixin.Authentication.External.RegistrationDetails(parameters);
var randomPassword = CommonHelper.GenerateRandomDigitCode(20);
var registrationRequest = new CustomerRegistrationRequest(currentCustomer, string.Empty, details.UserName, randomPassword, PasswordFormat.Clear, _storeContext.CurrentStore.Id, true);
var registrationResult = _customerRegistrationService.RegisterCustomer(registrationRequest);
if (registrationResult.Success)
{
//store other parameters (form fields)
if (!String.IsNullOrEmpty(details.NickName))
{
_genericAttributeService.SaveAttribute(currentCustomer, SystemCustomerAttributeNames.FirstName, details.NickName);
}
userFound = currentCustomer;
_openAuthenticationService.AssociateExternalAccountWithUser(currentCustomer, parameters);
ExternalAuthorizerHelper.RemoveParameters();
//authenticate
_authenticationService.SignIn(userFound ?? userLoggedIn, false);
}
else
{
ExternalAuthorizerHelper.RemoveParameters();
var result = new AuthorizationResult(OpenAuthenticationStatus.Error);
foreach (var error in registrationResult.Errors)
{
result.AddError(string.Format(error));
}
return(result);
}
#endregion
}
return(new AuthorizationResult(OpenAuthenticationStatus.Authenticated));
}
public async Task UserService_Doesnt_Create_User_With_Invalid_Password()
{
var user = new CustomerRegistrationRequest()
{
FirstName = "Steve",
LastName = "Corney",
Password = "******"
};
Result <Customer> creationResult = await customerManager.CreateAsync(user);
Assert.False(creationResult.Succeeded, "Customer should not be created since password is not invalid");
}
public async Task ICustomerManagerCreateAsyncWithEmtpyFirstAndLastName()
{
var customer = new CustomerRegistrationRequest()
{
FirstName = "",
LastName = "",
Password = "******"
};
Result <Customer> creationResult = await customerManager.CreateAsync(customer);
Assert.False(creationResult.Succeeded, "Customer should not be created since FirstName & Lastname is not invalid");
}
private async Task <Customer> CreateCustomerAsync(string first, string last)
{
var request = new CustomerRegistrationRequest(firstName: first,
lastName: last,
email: $"{first[0]}.{last}@example.com".ToLower(),
password: $"@#grapeWine{DateTime.Now.Ticks}");
return((await customerManager.CreateAsync(request)).Response ??
throw new DatabaseSeedingException <CustomerRegistrationRequest>
(request, "Unable to create customer"));
}
public CustomerRegistrationResponse CustomerRegistration(string merchantCustomerID)
{
if (merchantCustomerID == null)
{
throw new ArgumentNullException("merchantCustomerID");
}
var request = new CustomerRegistrationRequest
{
MerchantCustomerID = merchantCustomerID
};
return(CustomerRegistration(request));
}
public async Task MediatorHandleCustomerRegistrationRequest()
{
var customerRequest = new CustomerRegistrationRequest()
{
Email = $"sov.{new Random().Next(0, 987987)}@gmail.com",
FirstName = "Steve",
LastName = "Corney",
Password = "******"
};
var result = await mediator.Send(customerRequest);
Assert.True(result.Succeeded, "IMediator should handle CustomerRegistrationRequest successfully");
}
public async Task <Result <Customer> > RegisterCustomerAsync(CustomerRegistrationRequest request)
{
#region Creating User
Result <Customer> createionResult = await customerManager.CreateAsync(request);
if (!createionResult.Succeeded)
{
logger.LogWarning("IAuthService. Registraion failed: Customer provided invalid registration values. " +
"Customer.Email {customerEmail}. Validation Errors: {@Errors}",
request.Email, createionResult.Errors);
return(createionResult);
}
Customer newCustomer = createionResult.Response;
logger.LogInformation("IAuthService. Registration succeeded: New customer have been registered." +
"Customer.Id {customerId}, Email {customerEmail}",
newCustomer.Id, newCustomer.UserInfo.Email);
#endregion
#region Sending Email
string token = await emailConfirmationManager.GenerateTokenAsync(newCustomer);
bool emailSent = await emailConfirmationManager.SendConfirmationEmailAsync(newCustomer, token);
if (!emailSent)
{
logger.LogWarning("IAuthService. Sending confirmation email failed: CustomerId {customerId}, Email {customerEmail}",
newCustomer.Id, newCustomer.UserInfo.Email);
return(Result <Customer> .Failure("Sending confirmation email failed"));
}
logger.LogInformation("IAuthService. Confirmation email sent to new registered customer: " +
"CustomerId {customerId}, Email {customerEmail}",
newCustomer.Id, newCustomer.UserInfo.Email);
#endregion
return(newCustomer);
}
public bool RegisterUser(RegistrationViewModel model)
{
bool isApproved = _customerSettings.UserRegistrationType == UserRegistrationType.Standard;
Customer customer = model.CurrentCustomer;
string customerAttributesXml = PrepareCustomerAttributes(model);
var registrationRequest = new CustomerRegistrationRequest(
customer,
model.SelfIdentificationViewModel.Email,
_customerSettings.UsernamesEnabled ? model.Username : model.SelfIdentificationViewModel.Email,
model.SelfIdentificationViewModel.Password,
_customerSettings.DefaultPasswordFormat,
_storeContext.CurrentStore.Id,
isApproved);
var registrationResult = _customerRegistrationService.RegisterCustomer(registrationRequest);
if (registrationResult.Success)
{
//save customer attributes
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.FirstName,
model.SelfIdentificationViewModel.FirstName);
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.LastName,
model.SelfIdentificationViewModel.LastName);
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.Phone,
model.SelfIdentificationViewModel.Phone);
_genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.CustomCustomerAttributes,
customerAttributesXml);
//login customer now
if (isApproved)
{
_authenticationService.SignIn(customer, true);
}
// delay registration until enrollment is complete
// if (model.IsEnrollment) return true;
return(AnnounceRegistation(customer));
}
return(false);
}
public async Task <bool> Create(CustomerRegistrationRequest customer)
{
var user = new AppUser {
UserName = customer.UserName, Email = customer.Email
};
var result = await _userManager.CreateAsync(user, customer.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "Agent");
return(true);
}
return(false);
}
private static void CheckValidationResult(CustomerRegistrationRequest request, params Tuple <string, string>[] errorMessages)
{
var result = Validator.Validate(request);
var isValid = errorMessages.Length == 0;
result.IsValid.Should().Be(isValid);
result.Errors.Should().HaveCount(errorMessages.Length);
for (var i = 0; i != errorMessages.Length; i++)
{
var error = result.Errors[i];
error.PropertyName.Should().Be(errorMessages[i].Item1);
error.ErrorMessage.Should().Be(errorMessages[i].Item2);
}
}
public async Task ICustomerDoesntCreatedWithExistentEmail()
{
var request = new CustomerRegistrationRequest()
{
FirstName = "Steve",
LastName = "Corney",
Email = $"{Guid.NewGuid().ToString()}@example.com",
Password = "******",
};
var result = await customerManager.CreateAsync(request);
Assert.True(result.Succeeded, "Customer must be created");
result = await customerManager.CreateAsync(request);
Assert.False(result.Succeeded, "Customer should not be created since we already have one with this email and username");
}
public async Task <TokenResponse> Login(CustomerRegistrationRequest customer)
{
var user = await _userManager.FindByEmailAsync(customer.Email);
if (user != null)
{
var result = await _signInManager.CheckPasswordSignInAsync(user, customer.Password, false);
if (result.Succeeded)
{
var refreshDbToken = _context.RefreshTokens.FirstOrDefault(x => x.UserId == user.Id);
if (refreshDbToken != null)
{
_context.RefreshTokens.Remove(refreshDbToken);
await _context.SaveChangesAsync();
}
var newRefreshToken = new RefreshToken
{
UserId = user.Id,
Token = Guid.NewGuid().ToString(),
IssuedUtc = DateTime.Now.ToUniversalTime(),
ExpiresUtc = DateTime.Now.AddMinutes(5)
};
_context.RefreshTokens.Add(newRefreshToken);
await _context.SaveChangesAsync();
var token = await GenerateToken(user);
var response = new TokenResponse
{
AccessToken = new JwtSecurityTokenHandler().WriteToken(token),
RefreshToken = newRefreshToken.Token,
UserName = user.UserName,
Email = user.Email,
TokenExpiration = token.ValidTo
};
return(response);
}
}
throw new Exception("user not found");
}
public async Task RegisterCustomer(CustomerRegistrationRequest request)
{
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
var user = await _userService.RegisterUser(request);
var customer = new Customer
{
User = user,
FirstName = request.FirstName,
LastName = request.LastName,
};
await _repository.Insert(customer);
await _repository.Save();
scope.Complete();
}
}
public virtual IActionResult Register([FromBody] RegisterRequest model)
{
var response = new RegisterResponse {
Result = ResultType.Error
};
if (ModelState.IsValid)
{
model.Mobile = model.Mobile.Trim();
var registrationRequest = new CustomerRegistrationRequest(
model.Mobile,
model.Password,
_customerSettings.DefaultPasswordFormat);
var registrationResult = _customerRegistrationService.RegisterCustomer(registrationRequest);
if (registrationResult.Success)
{
//email validation message
var verifyCode = CommonHelper.GenerateSmsVerificationCode();
_genericAttributeService.SaveAttribute(registrationRequest.Customer, BopCustomerDefaults.AccountActivationTokenAttribute,
verifyCode);
//_workflowMessageService.SendcustomerPhoneValidationMessage(customer, _workContext.WorkingLanguage.Id);
//result
response.Result = ResultType.Success;
response.Messages.Add($"{_localizationService.GetResource("account.accountactivation.activation.code")} : {verifyCode}");
//raise event
_eventPublisher.Publish(new CustomerRegisteredEvent(registrationRequest.Customer));
return(Ok(response));
}
//errors
foreach (var error in registrationResult.Errors)
{
response.Messages.Add(error);
}
}
response.Messages.AddRange(ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage));
return(UnprocessableEntity(response));
}
public string NFCCustomerRegistration(string queryString)
{
var input = queryString.Split(_functSplitter);
var inputRequest = Convert.ToInt64(input[0]);
var registrationInputs = input[1].Split(_inputSplitter);
CustomerRegistrationRequest registrationRequest = (CustomerRegistrationRequest)inputRequest;
switch (registrationRequest)
{
case CustomerRegistrationRequest.ShopKeeperToCustomer:
return(_customerController.NFCCardRegistration(registrationInputs[0], true));
case CustomerRegistrationRequest.ShopKeeperToCustomerPush:
return(_customerController.NFCCardRegistration(registrationInputs[0]));
default:
return(null);
}
}
public async Task ProperlyPopulatedCustomerRegistrationRequestReturns200AndCustomerRegistrationCreatedObject()
{
var request = new CustomerRegistrationRequest
{
FirstName = "Bob",
Surname = "Smith",
DateOfBirth = new DateTime(2000, 1, 1),
EmailAddress = "*****@*****.**",
PolicyNumber = "AB-123456"
};
var response = await PostCustomerRegistrationRequest(request);
response.StatusCode.Should().Be((int)HttpStatusCode.OK);
var responseBody = await response.Content.ReadAsStringAsync();
var responseObject = JsonSerializer.Deserialize <CustomerRegistrationCreated>(responseBody, _jsonOptions);
responseObject.CustomerId.Should().BeGreaterThan(0);
}
public IActionResult RegisterCustomer(CustomerRegistrationRequest request)
{
var validator = new CustomerRegistrationRequestValidator();
var results = validator.Validate(request);
if (results.IsValid)
{
// save the details to the db
var response = new CustomerRegistrationResponse();
// todo: set the Id in the response based on the db record id
return(Ok(response));
}
else
{
var response = new CustomerRegistrationResponse
{
Errors = results.Errors.Select(x => x.ErrorMessage).ToArray()
};
return(BadRequest(response));
}
}
public async Task <CustomerRegistrationResult> Handle(SubAccountAddCommand request, CancellationToken cancellationToken)
{
var customer = await PrepareCustomer(request);
var registrationRequest = new CustomerRegistrationRequest(customer, request.Model.Email,
request.Model.Email, request.Model.Password,
_customerSettings.DefaultPasswordFormat, request.Store.Id, request.Model.Active);
var customerRegistrationResult = await _customerRegistrationService.RegisterCustomer(registrationRequest);
if (!customerRegistrationResult.Success)
{
await _customerService.DeleteCustomer(customer, true);
}
else
{
await _genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.FirstName, request.Model.FirstName);
await _genericAttributeService.SaveAttribute(customer, SystemCustomerAttributeNames.LastName, request.Model.LastName);
}
return(customerRegistrationResult);
}
public async Task <User> RegisterUser(CustomerRegistrationRequest request)
{
// Check if the username already exists
var hasAlreadyExistingUser = await _repository.Any <User>(x => x.UserName == request.MobileNumber);
if (!hasAlreadyExistingUser)
{
var hashedPassword = _passwordHasher.HashPassword(new User(), request.Password);
var user = new User
{
UserName = request.MobileNumber,
Email = request.Email,
Password = hashedPassword
};
await _repository.Insert(user);
await _repository.Save();
return(user);
}
throw new InValidInputException("UserName already exists");
}
public async Task InvalidCustomerRegistrationRequestReturnsErrors()
{
var unitOfWorkMock = new Mock <IUnitOfWork>();
var service = new CustomerRegistrationService(unitOfWorkMock.Object, new CustomerRegistrationRequestValidator());
var request = new CustomerRegistrationRequest();
var result = await service.Register(request);
result.IsSuccessful.Should().BeFalse();
result.CustomerId.Should().BeNull();
result.ValidationMessages.Length.Should().Be(4);
result.ValidationMessages[0].Property.Should().Be("FirstName");
result.ValidationMessages[0].Message.Should().Be("'First Name' must not be empty.");
result.ValidationMessages[1].Property.Should().Be("Surname");
result.ValidationMessages[1].Message.Should().Be("'Surname' must not be empty.");
result.ValidationMessages[2].Property.Should().Be("PolicyNumber");
result.ValidationMessages[2].Message.Should().Be("'Policy Number' must not be empty.");
result.ValidationMessages[3].Property.Should().Be("");
result.ValidationMessages[3].Message.Should().Be("'Date Of Birth' or 'Email Address' must not be empty.");
}
public async Task InvalidCustomerRegistrationRequestReturns400AndValidationMessageObjects()
{
var request = new CustomerRegistrationRequest();
var response = await PostCustomerRegistrationRequest(request);
response.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
var responseBody = await response.Content.ReadAsStringAsync();
var responseObject = JsonSerializer.Deserialize <ValidationMessage[]>(responseBody, _jsonOptions);
responseObject[0].Property.Should().Be("FirstName");
responseObject[0].Message.Should().Be("'First Name' must not be empty.");
responseObject[1].Property.Should().Be("Surname");
responseObject[1].Message.Should().Be("'Surname' must not be empty.");
responseObject[2].Property.Should().Be("PolicyNumber");
responseObject[2].Message.Should().Be("'Policy Number' must not be empty.");
responseObject[3].Property.Should().Be("");
responseObject[3].Message.Should().Be("'Date Of Birth' or 'Email Address' must not be empty.");
}
/// <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 IActionResult RegisterNewUser(ExternalAuthenticationParameters parameters, string returnUrl)
{
//check whether the specified email has been already registered
if (_customerService.GetCustomerByEmail(parameters.Email) != null)
{
var alreadyExistsError = string.Format(_localizationService.GetResource("Account.AssociatedExternalAuth.EmailAlreadyExists"),
!string.IsNullOrEmpty(parameters.ExternalDisplayIdentifier) ? parameters.ExternalDisplayIdentifier : parameters.ExternalIdentifier);
return(ErrorAuthentication(new[] { alreadyExistsError }, returnUrl));
}
//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.Clear,
_storeContext.CurrentStore.Id,
registrationIsApproved);
//whether registration request has been completed successfully
var registrationResult = _customerRegistrationService.RegisterCustomer(registrationRequest);
if (!registrationResult.Success)
{
return(ErrorAuthentication(registrationResult.Errors, returnUrl));
}
//allow to save other customer values by consuming this event
_eventPublisher.Publish(new CustomerAutoRegisteredByExternalMethodEvent(_workContext.CurrentCustomer, parameters));
//raise customer registered event
_eventPublisher.Publish(new CustomerRegisteredEvent(_workContext.CurrentCustomer));
//store owner notifications
if (_customerSettings.NotifyNewCustomerRegistration)
{
_workflowMessageService.SendCustomerRegisteredNotificationMessage(_workContext.CurrentCustomer, _localizationSettings.DefaultAdminLanguageId);
}
//associate external account with registered user
AssociateExternalAccountWithUser(_workContext.CurrentCustomer, parameters);
//authenticate
if (registrationIsApproved)
{
_authenticationService.SignIn(_workContext.CurrentCustomer, false);
_workflowMessageService.SendCustomerWelcomeMessage(_workContext.CurrentCustomer, _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
_genericAttributeService.SaveAttribute(_workContext.CurrentCustomer, GSCustomerDefaults.AccountActivationTokenAttribute, Guid.NewGuid().ToString());
_workflowMessageService.SendCustomerEmailValidationMessage(_workContext.CurrentCustomer, _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 }));
}
return(ErrorAuthentication(new[] { "Error on registration" }, returnUrl));
}
