viewing paste Unknown #10539 | Text

Posted on the
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
<?php
if (!defined('FLUX_ROOT')) exit;
 
if (Flux::config('UseCaptcha') && Flux::config('EnableReCaptcha')) {
        require_once 'recaptcha/recaptchalib.php';
        $recaptcha = recaptcha_get_html(Flux::config('ReCaptchaPublicKey'));
}
 
$title = Flux::message('AccountCreateTitle');
 
$serverNames = $this->getServerNames();
 
if (count($_POST)) {
        require_once 'Flux/RegisterError.php';
        
        try {
                $server    = $params->get('server');
                $username  = $params->get('username');
                $password  = $params->get('password');
                $confirm   = $params->get('confirm_password');
                
            TODO: [MASTERID] This stuff belongs to some other place.
                $gender    = $params->get('gender');
                $birthdate = $params->get('birthdate_date');
                $code      = $params->get('security_code');
                
                if (!($server = Flux::getServerGroupByName($server))) {
                        throw new Flux_RegisterError('Invalid server', Flux_RegisterError::INVALID_SERVER);
                }
                
                // Woohoo! Register ;)
                $result = $server->loginServer->register($username, $password, $confirm, $email, $gender, $birthdate, $code);
 
                if ($result) {
                        if (Flux::config('RequireEmailConfirm')) {
                                require_once 'Flux/Mailer.php';
                                
                                $user = $username;
                                $code = md5(rand());
                                $name = $session->loginAthenaGroup->serverName;
                                $link = $this->url('account', 'confirm', array('_host' => true, 'code' => $code, 'user' => $username, 'login' => $name));
                                $mail = new Flux_Mailer();
                                $sent = $mail->send($email, 'Account Confirmation', 'confirm', array('AccountUsername' => $username, 'ConfirmationLink' => htmlspecialchars($link)));
                                
                                $createTable = Flux::config('FluxTables.AccountCreateTable');
                                $bind = array($code);
                                
                                // Insert confirmation code.
                                $sql  = "UPDATE {$server->loginDatabase}.{$createTable} SET ";
                                $sql .= "confirm_code = ?, confirmed = 0 ";
                                if ($expire=Flux::config('EmailConfirmExpire')) {
                                        $sql .= ", confirm_expire = ? ";
                                        $bind[] = date('Y-m-d H:i:s', time() + (60 * 60 * $expire));
                                }
                                
                                $sql .= " WHERE account_id = ?";
                                $bind[] = $result;
                                
                                $sth  = $server->connection->getStatement($sql);
                                $sth->execute($bind);
                                
                                $session->loginServer->permanentlyBan(null, sprintf(Flux::message('AccountConfirmBan'), $code), $result);
                                
                                if ($sent) {
                                        $message  = Flux::message('AccountCreateEmailSent');
                                }
                                else {
                                        $message  = Flux::message('AccountCreateFailed');
                                }
                                
                                $session->setMessageData($message);
                                $this->redirect();
                        }
                        else {
                                $session->login($server->serverName, $username, $password, false);
                                $session->setMessageData(Flux::message('AccountCreated'));
                                $this->redirect();
                        }
                }
                else {
                        exit('Uh oh, what happened?');
                }
        }
        catch (Flux_RegisterError $e) {
                switch ($e->getCode()) {
                        case Flux_RegisterError::USERNAME_ALREADY_TAKEN:
                                $errorMessage = Flux::message('UsernameAlreadyTaken');
                                break;
                        case Flux_RegisterError::USERNAME_TOO_SHORT:
                                $errorMessage = Flux::message('UsernameTooShort');
                                break;
                        case Flux_RegisterError::USERNAME_TOO_LONG:
                                $errorMessage = Flux::message('UsernameTooLong');
                                break;
                        case Flux_RegisterError::PASSWORD_HAS_USERNAME:
                                $errorMessage = Flux::message ('PasswordHasUsername');
                                break;
                        case Flux_RegisterError::PASSWORD_TOO_SHORT:
                                $errorMessage = sprintf(Flux::message('PasswordTooShort'), Flux::config('MinPasswordLength'), Flux::config('MaxPasswordLength'));
                                break;
                        case Flux_RegisterError::PASSWORD_TOO_LONG:
                                $errorMessage = sprintf(Flux::message('PasswordTooLong'), Flux::config('MinPasswordLength'), Flux::config('MaxPasswordLength'));
                                break;
                        case Flux_RegisterError::PASSWORD_MISMATCH:
                                $errorMessage = Flux::message('PasswordsDoNotMatch');
                                break;
                        case Flux_RegisterError::PASSWORD_NEED_UPPER:
                                $errorMessage = sprintf(Flux::message ('PasswordNeedUpper'), Flux::config('PasswordMinUpper'));
                                break;
                        case Flux_RegisterError::PASSWORD_NEED_LOWER:
                                $errorMessage = sprintf(Flux::message ('PasswordNeedLower'), Flux::config('PasswordMinLower'));
                                break;
                        case Flux_RegisterError::PASSWORD_NEED_NUMBER:
                                $errorMessage = sprintf(Flux::message ('PasswordNeedNumber'), Flux::config('PasswordMinNumber'));
                                break;
                        case Flux_RegisterError::PASSWORD_NEED_SYMBOL:
                                $errorMessage = sprintf(Flux::message ('PasswordNeedSymbol'), Flux::config('PasswordMinSymbol'));
                                break;
                        case Flux_RegisterError::EMAIL_ADDRESS_IN_USE:
                                $errorMessage = Flux::message('EmailAddressInUse');
                                break;
                        case Flux_RegisterError::INVALID_EMAIL_ADDRESS:
                                $errorMessage = Flux::message('InvalidEmailAddress');
                                break;
                        case Flux_RegisterError::INVALID_GENDER:
                                $errorMessage = Flux::message('InvalidGender');
                                break;
                        case Flux_RegisterError::INVALID_SERVER:
                                $errorMessage = Flux::message('InvalidServer');
                                break;
                        case Flux_RegisterError::INVALID_SECURITY_CODE:
                                $errorMessage = Flux::message('InvalidSecurityCode');
                                break;
                        case Flux_RegisterError::INVALID_USERNAME:
                                $errorMessage = sprintf(Flux::message('AccountInvalidChars'), Flux::config('UsernameAllowedChars'));
                                break;
                        case Flux_RegisterError::INVALID_PASSWORD:
                                $errorMessage = Flux::message ('InvalidPassword');
                                break;
                        case Flux_RegisterError::INVALID_BIRTHDATE:
                                $errorMessage = Flux::message('InvalidBirthdate');
                                break;
                        default:
                                $errorMessage = Flux::message('CriticalRegisterError');
                                break;
                }
        }
}
?>
Viewed 458 times, submitted by Guest.