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)); }