예제 #1
0
 /**
  * @Route("/register", options={"zkNoBundlePrefix"=1})
  * @Method({"GET", "POST"})
  *
  * Display the registration form.
  *
  * @param Request $request
  *
  * Parameters passed via GET:
  * --------------------------
  * None.
  *
  * Parameters passed via POST:
  * ---------------------------
  * See the definition of {@link FormData\RegistrationForm}.
  *
  * Parameters passed via SERVER:
  * ------------------------------
  * string HTTP_USER_AGENT The browser user agent string, for comparison with illegal user agent strings.
  *
  * @return Response|RedirectResponse symfony response object
  *
  * @throws AccessDeniedException Thrown if the user doesn't have read access to the module or
  *                                          if the registration information hasn't been passed correctly through the authentication module or
  *                                          if an illegal user agent was detected
  * @throws FatalErrorException Thrown if there was a problem reading the registration information or
  *                                     if the authentication module couldn't be found or
  *                                     if the registration process reaches an unknown state
  */
 public function registerAction(Request $request)
 {
     // Should not be here if logged in.
     if (UserUtil::isLoggedIn()) {
         return new RedirectResponse($this->get('router')->generate('zikulausersmodule_user_index', array(), RouterInterface::ABSOLUTE_URL));
     }
     // we do not check permissions here (see #1874)
     /*if (!SecurityUtil::checkPermission($this->name .'::', '::', ACCESS_READ)) {
           throw new AccessDeniedException();
       }*/
     // Check if registration is enabled
     if (!$this->getVar(UsersConstant::MODVAR_REGISTRATION_ENABLED, UsersConstant::DEFAULT_REGISTRATION_ENABLED)) {
         return new Response($this->view->fetch('User/registration_disabled.tpl'));
     }
     // Initialize state for the state machine later on.
     $state = 'error';
     if ($request->isMethod('GET')) {
         // An HTTP GET, meaning either we are reentering the function from an external authenticator,
         // or we are entering the function for the very first time.
         $reentrantTokenReceived = $request->query->get('reentranttoken', false);
         if ($reentrantTokenReceived) {
             // We got here by reentering from an external authenticator. Grab the data we stored in session variables.
             $sessionVars = $request->getSession()->get('User_register', false, UsersConstant::SESSION_VAR_NAMESPACE);
             if ($sessionVars) {
                 $reentrantToken = isset($sessionVars['reentranttoken']) ? $sessionVars['reentranttoken'] : false;
                 $authenticationInfo = isset($sessionVars['authentication_info']) ? $sessionVars['authentication_info'] : array();
                 $selectedAuthenticationMethod = isset($sessionVars['authentication_method']) ? $sessionVars['authentication_method'] : array();
                 if ($reentrantToken != $reentrantTokenReceived) {
                     throw new AccessDeniedException();
                 }
             } else {
                 throw new FatalErrorException($this->__('An internal error occurred. Failed to retrieve stored registration state.'));
             }
             $state = 'authenticate';
         } else {
             // We are entering this function for the very first time.
             $selectedAuthenticationMethod = array();
             $authenticationInfo = array();
             $state = 'start';
         }
     } elseif ($request->isMethod('POST')) {
         // An HTTP POST, so a form was submitted in order to get into the function. There are three possibilities.
         // It could be that the user selected an authentication method, and we need to switch to that method.
         // It could be that the user supplied authentication info to send to an authentication method, and we need to do that.
         // It could be that the user submitted the actual registration form.
         $this->checkCsrfToken();
         if ($request->request->get('authentication_method_selector', false)) {
             // The user selected an authentication method, so we need to switch to it.
             $selectedAuthenticationMethod = $request->request->get('authentication_method', false);
             $authenticationInfo = array();
             $state = 'authentication_method_selector';
         } elseif ($request->request->get('registration_authentication_info', false)) {
             // The user submitted authentication information that needs to be processed by the authentication module.
             $authenticationInfo = $request->request->get('authentication_info', array());
             $selectedAuthenticationMethod = $request->request->get('authentication_method', array());
             $reentrantToken = substr(SecurityUtil::generateCsrfToken(), 0, 10);
             $state = 'authenticate';
         } elseif ($request->request->get('registration_info', false)) {
             // The user submitted the acutal registration form, so we need to validate the entries and register him.
             $selectedAuthenticationMethod = json_decode($request->request->get('authentication_method_ser', false), true);
             $removePasswordReminderValidation = false;
             if ($selectedAuthenticationMethod['modname'] != 'ZikulaUsersModule') {
                 $removePasswordReminderValidation = true;
             }
             $formData = new FormData\RegistrationForm('users_register', $this->getContainer(), $removePasswordReminderValidation);
             $formData->setFromRequestCollection($request->request);
             $authenticationInfo = json_decode($request->request->get('authentication_info_ser', false), true);
             $state = 'validate';
         }
     }
     // The state machine that handles the processing of the data from the initialization above.
     while ($state != 'stop') {
         switch ($state) {
             case 'start':
                 // Initial starting point for registration - a GET request without a reentrant token
                 // Check for illegal user agents trying to register.
                 $userAgent = $request->server->get('HTTP_USER_AGENT', '');
                 $illegalUserAgents = $this->getVar(UsersConstant::MODVAR_REGISTRATION_ILLEGAL_AGENTS, '');
                 // Convert the comma-separated list into a regexp pattern.
                 $pattern = array('/^(\\s*,\\s*)+/D', '/\\b(\\s*,\\s*)+\\b/D', '/(\\s*,\\s*)+$/D');
                 $replace = array('', '|', '');
                 $illegalUserAgents = preg_replace($pattern, $replace, preg_quote($illegalUserAgents, '/'));
                 // Check for emptiness here, in case there were just spaces and commas in the original string.
                 if (!empty($illegalUserAgents) && preg_match("/^({$illegalUserAgents})/iD", $userAgent)) {
                     throw new AccessDeniedException($this->__('Sorry! The user agent you are using (the browser or other software you are using to access this site) is banned from the registration process.'));
                 }
                 // Notify that we are beginning a registration session.
                 $event = new GenericEvent();
                 $this->getDispatcher()->dispatch('module.users.ui.registration.started', $event);
                 // Get a list of authentication methods available for registration
                 $authenticationMethodList = new AuthenticationMethodListHelper($this, array(), Zikula_Api_AbstractAuthentication::FILTER_REGISTRATION_ENABLED);
                 if ($authenticationMethodList->countEnabledForRegistration() == 1 && $authenticationMethodList[0]->modname == $this->name) {
                     // There is only the default ZikulaUsersModule method available. Skip method selection.
                     $selectedAuthenticationMethod = array('modname' => $authenticationMethodList[0]->modname, 'method' => $authenticationMethodList[0]->method);
                     $state = 'display_registration';
                 } else {
                     // There are other authentication modules with methods that are enabled for registration. Display
                     // the choices to the user.
                     $state = 'display_method_selector';
                 }
                 break;
             case 'display_registration':
                 // An authentication method has been selected (or defaulted), or there were errors with the last
                 // submission of the registration form.
                 // Display the registration form to the user.
                 if (!isset($formData)) {
                     $formData = new FormData\RegistrationForm('users_register', $this->getContainer());
                 }
                 $state = 'stop';
                 $arguments = array('authentication_method' => $selectedAuthenticationMethod, 'authentication_info' => $authenticationInfo, 'registration_info' => isset($registrationInfo) ? $registrationInfo : array(), 'errorFields' => isset($errorFields) ? $errorFields : array(), 'errorMessages' => isset($errorMessages) ? $errorMessages : array());
                 return new Response($this->view->assign_by_ref('formData', $formData)->assign($arguments)->fetch('User/register.tpl'));
                 break;
             case 'display_method_selector':
                 // An authentication method to use with the user's registration has not been selected.
                 // Present the choices to the user.
                 $authenticationMethodList = new AuthenticationMethodListHelper($this, array(), Zikula_Api_AbstractAuthentication::FILTER_REGISTRATION_ENABLED);
                 // TODO - The order and availability should be set by configuration
                 $authenticationMethodDisplayOrder = array();
                 foreach ($authenticationMethodList as $am) {
                     if ($am->isEnabledForRegistration()) {
                         $authenticationMethodDisplayOrder[] = array('modname' => $am->modname, 'method' => $am->method);
                     }
                 }
                 $state = 'stop';
                 $arguments = array('authentication_info' => isset($authenticationInfo) ? $authenticationInfo : array(), 'selected_authentication_method' => $selectedAuthenticationMethod, 'authentication_method_display_order' => $authenticationMethodDisplayOrder);
                 return new Response($this->view->assign($arguments)->fetch('User/registration_method.tpl'));
                 break;
             case 'authentication_method_selector':
                 // One of the authentication method selectors on the registration methods page was clicked.
                 if (!$selectedAuthenticationMethod || !is_array($selectedAuthenticationMethod) || empty($selectedAuthenticationMethod) || !isset($selectedAuthenticationMethod['modname']) || !is_string($selectedAuthenticationMethod['modname']) || empty($selectedAuthenticationMethod['modname']) || !isset($selectedAuthenticationMethod['method']) || !is_string($selectedAuthenticationMethod['method']) || empty($selectedAuthenticationMethod['method'])) {
                     throw new \InvalidArgumentException($this->__('An invalid authentication method was selected.'));
                 }
                 if ($selectedAuthenticationMethod['modname'] == $this->name) {
                     $state = 'display_registration';
                 } else {
                     $state = 'display_method_selector';
                 }
                 break;
             case 'authenticate':
                 // The user provided and submitted the authentication information form on the registration methods page in order
                 // to authenticate his credentials with the authentication method in order to proceed to the main registration page,
                 // OR the user is reentering the registration process after exiting to the external authentication service to
                 // authenticate his credentials.
                 // Save the submitted information in case the authentication method is external and reentrant.
                 // We're using sessions here, even though anonymous sessions might be turned off for anonymous users.
                 // If the user is trying to regiuster, then he's going to get a session if he's successful and logs in,
                 // so using sessions on the anonymous user just before registration should be ok.
                 SessionUtil::requireSession();
                 $sessionVars = array('authentication_info' => $authenticationInfo, 'authentication_method' => $selectedAuthenticationMethod, 'reentranttoken' => $reentrantToken);
                 $request->getSession()->set('User_register', $sessionVars, UsersConstant::SESSION_VAR_NAMESPACE);
                 // The authentication method selected might be reentrant (it might send the user out to an external web site
                 // for authentication, and then send us back to finish the job). We need to tell the external system to where
                 // we would like to return.
                 $reentrantUrl = $this->get('router')->generate('zikulausersmodule_user_register', array('reentranttoken' => $reentrantToken), RouterInterface::ABSOLUTE_URL);
                 // The chosen authentication method might be reentrant, and this is the point were the user might be directed
                 // outside the Zikula system for external authentication.
                 $arguments = array('authentication_info' => $authenticationInfo, 'authentication_method' => $selectedAuthenticationMethod, 'reentrant_url' => $reentrantUrl);
                 $checkPasswordResult = ModUtil::apiFunc($selectedAuthenticationMethod['modname'], 'authentication', 'checkPasswordForRegistration', $arguments, 'Zikula_Api_AbstractAuthentication');
                 // Did we get a good user? If so, then we can proceed to hook-like event and hook validation.
                 if (isset($checkPasswordResult) && $checkPasswordResult && is_array($checkPasswordResult)) {
                     if (isset($checkPasswordResult['authentication_info'])) {
                         $arguments['authentication_info'] = $checkPasswordResult['authentication_info'];
                     }
                     $uid = ModUtil::apiFunc($selectedAuthenticationMethod['modname'], 'authentication', 'getUidForAuthenticationInfo', $arguments, 'Zikula_Api_AbstractAuthentication');
                     if ($uid === false) {
                         if (isset($checkPasswordResult['authentication_info'])) {
                             $authenticationInfo = $checkPasswordResult['authentication_info'];
                         }
                         $removePasswordReminderValidation = false;
                         if ($selectedAuthenticationMethod['modname'] != 'ZikulaUsersModule') {
                             $removePasswordReminderValidation = true;
                         }
                         $formData = new FormData\RegistrationForm('users_register', $this->getContainer(), $removePasswordReminderValidation);
                         $registrationInfo = isset($checkPasswordResult['registration_info']) && is_array($checkPasswordResult['registration_info']) ? $checkPasswordResult['registration_info'] : array();
                         if (!empty($registrationInfo)) {
                             if (isset($registrationInfo['uname']) && !empty($registrationInfo['uname'])) {
                                 $formData->setField('uname', $registrationInfo['uname']);
                             }
                             if (isset($registrationInfo['email']) && !empty($registrationInfo['email'])) {
                                 $formData->setField('email', $registrationInfo['email']);
                             }
                             if (isset($registrationInfo['hideEmail']) && $registrationInfo['hideEmail'] == true) {
                                 $formData->setField('emailagain', $registrationInfo['email']);
                                 $this->view->assign('hideEmail', true);
                             }
                             // @todo Add this as soon as #1330 is implemented.
                             //if (isset($registrationInfo['lang']) && !empty($registrationInfo['lang'])) {
                             //    $formData->setField('lang', $registrationInfo['lang']);
                             //}
                             // @todo React to emailVerified !
                             // $registrationInfo['emailVerified']
                         }
                         $state = 'display_registration';
                     } else {
                         $request->getSession()->getFlashBag()->add('error', $this->__('The credentials you provided are already associated with an existing user account or registration request.'));
                         $state = 'display_method_selector';
                     }
                 } else {
                     if (!$request->getSession()->hasMessages(Zikula_Session::MESSAGE_ERROR)) {
                         $request->getSession()->getFlashBag()->add('error', $this->__('We were unable to confirm your credentials with the selected service.'));
                     }
                     $state = 'display_method_selector';
                 }
                 // If we have gotten to this point in the same call to registrationMethod(), then the authentication method was not external
                 // and reentrant, so we should not need the session variable any more. If it is external and reentrant, and the
                 // user was required to exit the Zikula system for authentication on the external system, then we will not get
                 // to this point until the reentrant callback (at which point the variable should, again, not be needed
                 // anymore).
                 $request->getSession()->remove('Users_register', UsersConstant::SESSION_VAR_NAMESPACE);
                 break;
             case 'validate':
                 // The user filled in and submitted the main registration form and it needs to be validated.
                 // Get the form data
                 $formData->getField('uname')->setData(mb_strtolower($formData->getField('uname')->getData()));
                 $formData->getField('email')->setData(mb_strtolower($formData->getField('email')->getData()));
                 $formData->getField('emailagain')->setData(mb_strtolower($formData->getField('emailagain')->getData()));
                 // Set up the parameters for a call to Users_Api_Registration#getRegistrationErrors()
                 $antispamAnswer = $formData->getFieldData('antispamanswer');
                 $reginfo = $formData->toUserArray();
                 $arguments = array('checkmode' => 'new', 'reginfo' => $reginfo, 'passagain' => $formData->getFieldData('passagain'), 'emailagain' => $formData->getFieldData('emailagain'), 'antispamanswer' => isset($antispamAnswer) ? $antispamAnswer : '');
                 if ($formData->isValid()) {
                     $errorFields = ModUtil::apiFunc($this->name, 'registration', 'getRegistrationErrors', $arguments);
                 } else {
                     $errorFields = $formData->getErrorMessages();
                 }
                 // Validate the hook-like event.
                 $event = new GenericEvent($reginfo, array(), new ValidationProviders());
                 $validators = $this->getDispatcher()->dispatch('module.users.ui.validate_edit.new_registration', $event)->getData();
                 // Validate the hook
                 $hook = new ValidationHook($validators);
                 $this->dispatchHooks('users.ui_hooks.registration.validate_edit', $hook);
                 $validators = $hook->getValidators();
                 if (empty($errorFields) && !$validators->hasErrors()) {
                     // No errors, move on to registration.
                     $state = 'register';
                 } else {
                     // There were errors with the entries on the registration form. Redisplay it.
                     $state = 'display_registration';
                 }
                 break;
             case 'register':
                 // The registration validated, so do the actual registration.
                 $canLogIn = false;
                 $redirectUrl = '';
                 $registeredObj = ModUtil::apiFunc($this->name, 'registration', 'registerNewUser', array('reginfo' => $reginfo, 'usernotification' => true, 'adminnotification' => true));
                 if (isset($registeredObj) && $registeredObj) {
                     // The main registration completed successfully.
                     if ($selectedAuthenticationMethod['modname'] != $this->name) {
                         // The selected authentication module is NOT the Users module, so make sure the user is registered
                         // with the authentication module (associate the Users module record uid with the login information).
                         $arguments = array('authentication_method' => $selectedAuthenticationMethod, 'authentication_info' => $authenticationInfo, 'uid' => $registeredObj['uid']);
                         $authenticationRegistered = ModUtil::apiFunc($selectedAuthenticationMethod['modname'], 'authentication', 'register', $arguments, 'Zikula_Api_AbstractAuthentication');
                         if (!$authenticationRegistered) {
                             $request->getSession()->getFlashBag()->add('warning', $this->__('There was a problem associating your log-in information with your account. Please contact the site administrator.'));
                             $response = new RedirectResponse(System::normalizeUrl(System::getHomepageUrl()));
                             return $response;
                         }
                     } elseif ($this->getVar(UsersConstant::MODVAR_LOGIN_METHOD, UsersConstant::LOGIN_METHOD_UNAME) == UsersConstant::LOGIN_METHOD_EMAIL) {
                         // The authentication method IS the Users module, prepare for auto-login.
                         // The log-in user ID is the user's e-mail address.
                         $authenticationInfo = array('login_id' => $registeredObj['email'], 'pass' => $reginfo['pass']);
                     } else {
                         // The authentication method IS the Users module, prepare for auto-login.
                         // The log-in user ID is the user's user name.
                         $authenticationInfo = array('login_id' => $registeredObj['uname'], 'pass' => $reginfo['pass']);
                     }
                     // Allow hook-like events to process the registration...
                     $event = new GenericEvent($registeredObj);
                     $this->getDispatcher()->dispatch('module.users.ui.process_edit.new_registration', $event);
                     // ...and hooks to process the registration.
                     $hook = new ProcessHook($registeredObj['uid']);
                     $this->dispatchHooks('users.ui_hooks.registration.process_edit', $hook);
                     // If there were errors after the main registration, then make sure they can be displayed.
                     // TODO - Would this even happen?
                     if (!empty($registeredObj['regErrors'])) {
                         $this->view->assign('regErrors', $registeredObj['regErrors']);
                     }
                     // Register the appropriate status or error to be displayed to the user, depending on the account's
                     // activated status, whether registrations are moderated, whether e-mail addresses need to be verified,
                     // and other sundry conditions.
                     if ($registeredObj['activated'] == UsersConstant::ACTIVATED_PENDING_REG) {
                         // The account is saved and is pending either moderator approval, e-mail verification, or both.
                         $moderation = $this->getVar(UsersConstant::MODVAR_REGISTRATION_APPROVAL_REQUIRED, UsersConstant::DEFAULT_REGISTRATION_APPROVAL_REQUIRED);
                         $moderationOrder = $this->getVar(UsersConstant::MODVAR_REGISTRATION_APPROVAL_SEQUENCE, UsersConstant::DEFAULT_REGISTRATION_APPROVAL_SEQUENCE);
                         $verifyEmail = $this->getVar(UsersConstant::MODVAR_REGISTRATION_VERIFICATION_MODE, UsersConstant::DEFAULT_REGISTRATION_VERIFICATION_MODE);
                         if (!empty($registeredObj['regErrors'])) {
                             // There were errors. This message takes precedence.
                             $request->getSession()->getFlashBag()->add('error', $this->__('Your registration request has been saved, however the problems listed below were detected during the registration process. Please contact the site administrator regarding the status of your request.'));
                         } elseif ($moderation && $verifyEmail != UsersConstant::VERIFY_NO) {
                             // Pending both moderator approval, and e-mail verification. Set the appropriate message
                             // based on the order of approval/verification set.
                             if ($moderationOrder == UsersConstant::APPROVAL_AFTER) {
                                 // Verification then approval.
                                 $request->getSession()->getFlashBag()->add('status', $this->__('Done! Your registration request has been saved. Remember that your e-mail address must be verified and your request must be approved before you will be able to log in. Please check your e-mail for an e-mail address verification message. Your account will not be approved until after the verification process is completed.'));
                             } elseif ($moderationOrder == UsersConstant::APPROVAL_BEFORE) {
                                 // Approval then verification.
                                 $request->getSession()->getFlashBag()->add('status', $this->__('Done! Your registration request has been saved. Remember that your request must be approved and your e-mail address must be verified before you will be able to log in. Please check your e-mail periodically for a message from us. You will receive a message after we have reviewed your request.'));
                             } else {
                                 // Approval and verification in any order.
                                 $request->getSession()->getFlashBag()->add('status', $this->__('Done! Your registration request has been saved. Remember that your e-mail address must be verified and your request must be approved before you will be able to log in. Please check your e-mail for an e-mail address verification message.'));
                             }
                         } elseif ($moderation) {
                             // Pending moderator approval only.
                             $request->getSession()->getFlashBag()->add('status', $this->__('Done! Your registration request has been saved. Remember that your request must be approved before you will be able to log in. Please check your e-mail periodically for a message from us. You will receive a message after we have reviewed your request.'));
                         } elseif ($verifyEmail != UsersConstant::VERIFY_NO) {
                             // Pending e-mail address verification only.
                             $request->getSession()->getFlashBag()->add('status', $this->__('Done! Your registration request has been saved. Remember that your e-mail address must be verified before you will be able to log in. Please check your e-mail for an e-mail address verification message.'));
                         } else {
                             // Some unknown state! Should never get here, but just in case...
                             $request->getSession()->getFlashBag()->add('error', $this->__('Your registration request has been saved, however your current registration status could not be determined. Please contact the site administrator regarding the status of your request.'));
                         }
                     } elseif ($registeredObj['activated'] == UsersConstant::ACTIVATED_ACTIVE) {
                         // The account is saved, and is active (no moderator approval, no e-mail verification, and the user can log in now).
                         if (!empty($registeredObj['regErrors'])) {
                             // Errors. This message takes precedence.
                             $request->getSession()->getFlashBag()->add('error', $this->__('Your account has been created and you may now log in, however the problems listed below were detected during the registration process. Please contact the site administrator for more information.'));
                         } elseif ($this->getVar(UsersConstant::MODVAR_REGISTRATION_AUTO_LOGIN, UsersConstant::DEFAULT_REGISTRATION_AUTO_LOGIN)) {
                             // No errors and auto-login is turned on. A simple post-log-in message.
                             $request->getSession()->getFlashBag()->add('status', $this->__('Done! Your account has been created.'));
                         } else {
                             // No errors, and no auto-login. A simple message telling the user he may log in.
                             $request->getSession()->getFlashBag()->add('status', $this->__('Done! Your account has been created and you may now log in.'));
                         }
                         $canLogIn = true;
                     } else {
                         // Shouldn't really get here out of the registration process, but cover all the bases.
                         $request->getSession()->getFlashBag()->add('error', $this->__('Your registration request has been saved, however the problems listed below were detected during the registration process. Please contact the site administrator regarding the status of your request.'));
                         $registeredObj['regErrors'] = $this->__('Your account status will not permit you to log in at this time. Please contact the site administrator for more information.');
                     }
                     // Notify that we are completing a registration session.
                     $arguments = array('redirecturl' => $redirectUrl);
                     $event = new GenericEvent($registeredObj, $arguments);
                     $event = $this->getDispatcher()->dispatch('module.users.ui.registration.succeeded', $event);
                     $redirectUrl = $event->hasArgument('redirecturl') ? $event->getArgument('redirecturl') : $redirectUrl;
                     // Set up the next state to follow this one, along with any data needed.
                     if ($canLogIn && $this->getVar(UsersConstant::MODVAR_REGISTRATION_AUTO_LOGIN, UsersConstant::DEFAULT_REGISTRATION_AUTO_LOGIN)) {
                         // Next is auto-login. Make sure redirectUrl has a value so we know where to send the user.
                         if (empty($redirectUrl)) {
                             $redirectUrl = System::getHomepageUrl();
                         }
                         $state = 'auto_login';
                     } elseif (!empty($redirectUrl)) {
                         // No auto-login, but a redirect URL, so send the user there next.
                         $state = 'redirect';
                     } elseif (!$registeredObj || !empty($registeredObj['regErrors']) || !$canLogIn) {
                         // Either some sort of error, or the user cannot yet log in. Send him to a page to display
                         // the current status message or error message.
                         $state = 'display_status';
                     } else {
                         // No auto-login, no redirect URL, no errors, and the user can log in at this point.
                         // Send him to the login screen.
                         $redirectUrl = $this->get('router')->generate('zikulausersmodule_user_login', array(), RouterInterface::ABSOLUTE_URL);
                         $state = 'redirect';
                     }
                 } else {
                     // The main registration process failed.
                     $request->getSession()->getFlashBag()->add('error', $this->__('Error! Could not create the new user account or registration application. Please check with a site administrator before re-registering.'));
                     // Notify that we are completing a registration session.
                     $arguments = array('redirecturl' => $redirectUrl);
                     $event = new GenericEvent(null, $arguments);
                     $event = $this->getDispatcher()->dispatch('module.users.ui.registration.failed', $event);
                     $redirectUrl = $event->hasArgument('redirecturl') ? $event->getArgument('redirecturl') : $redirectUrl;
                     // Set the next state to folllow this one.
                     if (!empty($redirectUrl)) {
                         // A redirect URL, so send the user there.
                         $state = 'redirect';
                     } else {
                         // No redirect, so send the user to a page to show the current error message.
                         $state = 'display_status';
                     }
                 }
                 break;
             case 'display_status':
                 // At the end of the registration process with no where else to go.
                 // Show the user the current status message(s) or error message(s).
                 $state = 'stop';
                 return new Response($this->view->fetch('User/displaystatusmsg.tpl'));
                 break;
             case 'redirect':
                 // At the end of the registration process with a redirect URL. Send the user there.
                 $state = 'stop';
                 return new RedirectResponse(System::normalizeUrl($redirectUrl));
                 break;
             case 'auto_login':
                 // At the end of the registration process that was successful with the user in a state where
                 // he can log in, and auto-login enabled. Log the user in, sending him to the page specified.
                 $state = 'stop';
                 $post = array('authentication_method' => $selectedAuthenticationMethod, 'authentication_info' => $authenticationInfo, 'rememberme' => false, 'returnpage' => $redirectUrl);
                 $subRequest = $request->duplicate(array(), $post, ['_controller' => 'ZikulaUsersModule:User:login']);
                 $httpKernel = $this->get('http_kernel');
                 $response = $httpKernel->handle($subRequest, HttpKernelInterface::SUB_REQUEST);
                 return $response;
                 break;
             default:
                 // An unknown processing state.
                 $state = 'stop';
                 break;
         }
     }
     // If we got here then we exited the above state machine with a 'stop', but there was no return statement
     // in the terminal state. We don't know what to do.
     throw new FatalErrorException($this->__('The registration process has entered an unknown state.'));
 }