# fluent-support/1.5.4/app/Http/Controllers/AuthController.php

Fluent Support – Helpdesk & Customer Support Ticket System, version 1.5.4. 271 lines.

- Page: https://pluginprobe.com/plugins/fluent-support/1.5.4/code/app/Http/Controllers/AuthController.php
- Raw: https://pluginprobe.com/plugins/fluent-support/1.5.4/raw/app/Http/Controllers/AuthController.php
- Modified: 2022-01-19T11:32:28+00:00

Line numbers below start at 1. Link to a line or a range by appending a fragment to the
page URL, for example `https://pluginprobe.com/plugins/fluent-support/1.5.4/code/app/Http/Controllers/AuthController.php#L10-L20`.

```php
<?php

namespace FluentSupport\App\Http\Controllers;

use FluentSupport\App\Services\Helper;
use FluentSupport\Framework\Support\Arr;
use FluentSupport\Framework\Request\Request;
use FluentSupport\App\Hooks\Handlers\AuthHandler;

class AuthController extends Controller
{
    public function signup(Request $request)
    {

        if (!wp_verify_nonce($request->get('_fsupport_signup_nonce'), 'fluent_support_signup_nonce')) {
            $this->sendError([
                'message' => __('Security verification failed. Please try again', 'fluent-support')
            ]);
        }

        $fields = AuthHandler::getSignupFields();

        $rules = $this->getRules($fields);

        $messages = $this->getMessages($rules);

        $formData = apply_filters('fluent_support/signup_form_data', $request->all());

        do_action('fluent_support/before_signup_validation', []);

        $this->validate($formData, $rules, $messages);

        do_action('fluent_support/after_signup_validation', $formData);

        $userId = $this->createUser($formData);

        if (is_wp_error($userId)) {
            return $this->response(
                apply_filters(
                    'fluent_support/signup_create_user_error',
                    ['error' => $userId->get_error_message()]
                ), 423);
        }

        do_action('fluent_support/after_creating_user');

        $this->maybeUpdateUser($userId, $formData);
        $this->assignRole($userId);
        $this->login($userId);

        return $this->response(
            apply_filters('fluent_support/signup_complete_response', [
                'message'  => __('Successfully registered to the site.', 'fluent-support'),
                'redirect' => Arr::get($formData, '__redirect_to', Helper::getPortalBaseUrl())
            ])
        );
    }

    public function handleLogin(Request $request)
    {
        if (!wp_verify_nonce($request->get('_support_login_nonce'), 'fsupport_login_nonce')) {
            return $this->response([
                'message' => __('Security verification failed', 'fluent-support')
            ], 403);
        }

        $data = $request->all();

        if (empty($data['pwd']) || empty($data['log'])) {
            return $this->response([
                'message' => __('Email and Password is required', 'fluent-support')
            ], 403);
        }

        $redirectUrl = Helper::getPortalBaseUrl();

        if (get_current_user_id()) { // user already registered
            return $this->sendSuccess([
                'redirect' => $redirectUrl
            ]);
        }

        $email = $data['log'];
        $password = $data['pwd'];

        if (is_email($email)) {
            $user = get_user_by('email', $email);
        } else {
            $user = get_user_by('login', $email);
        }

        if (!$user) {
            return $this->response([
                'message' => __('Email or Password is not valid. Please try again', 'fluent-support')
            ], 403);
        }

        $info = array(
            'user_login'    => sanitize_text_field(trim($_POST['log'])),
            'user_password' => trim($_POST['pwd']),
            'remember'      => isset($_POST['rememberme']),
        );

        if (apply_filters('fluent_support_use_native_login', true)) {
            return $this->nativeLoginHandler($user, $info, $redirectUrl);
        }

        if (wp_check_password($password, $user->user_pass, $user->ID)) {
            $this->login($user->ID);
            return $this->sendSuccess([
                'redirect' => $redirectUrl
            ]);
        }

        return $this->response([
            'message' => __('Email or Password is not valid. Please try again', 'fluent-support')
        ], 403);
    }

    private function nativeLoginHandler($user, $info, $redirectUrl = '')
    {
        if (!$redirectUrl) {
            $redirectUrl = Helper::getPortalBaseUrl();
        }

        $secure_cookie = is_ssl();
        if (!$secure_cookie && !force_ssl_admin()) {
            if (get_user_option('use_ssl', $user->ID)) {
                $secure_cookie = true;
                force_ssl_admin(true);
            }
        }

        if (class_exists('\Limit_Login_Attempts')) {
            global $limit_login_attempts_obj;
            $limit_login_attempts_try = $limit_login_attempts_obj->wp_authenticate_user($user, false);
            if (is_wp_error($limit_login_attempts_try)) {
                return $this->response([
                    'message' => implode('<br/>', $limit_login_attempts_try->get_error_messages())
                ], 403);
            }
        }

        $user_signon = wp_signon($info, $secure_cookie);

        if (!is_wp_error($user_signon) && empty($_COOKIE[LOGGED_IN_COOKIE])) {
            if (headers_sent()) {
                return $this->response([
                    'message' => sprintf(__('<strong>ERROR</strong>: Cookies are blocked due to unexpected output. For help, please see <a href="%1$s">this documentation</a> or try the <a href="%2$s">support forums</a>.'),
                        __('https://codex.wordpress.org/Cookies'), __('https://wordpress.org/support/'))
                ], 403);
            }
        }

        if (is_wp_error($user_signon)) {
            $errorMessage = __('Email or Password is not valid. Please try again', 'fluent-support');

            if (class_exists('Limit_Login_Attempts')) {
                global $limit_login_attempts_obj;
                if ($limit_login_attempts_obj) {
                    $limit_login_attempts_obj->limit_login_failed($user->user_login);
                    $msg = $limit_login_attempts_obj->get_message();
                    if ($msg) {
                        $errorMessage = $msg;
                    }
                }
            }

            return $this->response([
                'message' => $errorMessage
            ], 403);
        }

        // WP Last Login plugin compatibility
        if (class_exists('\Obenland_Wp_Last_Login')) {
            update_user_meta($user_signon->ID, 'wp-last-login', time());
        }

        return $this->sendSuccess([
            'redirect' => $redirectUrl
        ]);
    }

    protected function getRules($fields = [])
    {
        $rules = [];

        foreach ($fields as $fieldName => $field) {
            if (array_key_exists('required', $field)) {
                $rules[$fieldName] = 'required';
            }

            $pipe = array_key_exists($fieldName, $rules) ? '|' : '';

            if ($field['type'] === 'email') {
                $rules[$fieldName] = $rules[$fieldName] . $pipe . 'email';
            } elseif ($field['type'] === 'password') {
                $rules[$fieldName] = $rules[$fieldName] . $pipe . 'min:8';
            }
        }

        return apply_filters('fluent_support/signup_validation_rules', $rules);
    }

    protected function getMessages($rules = [])
    {
        return apply_filters('fluent_support/signup_validation_messages', [], $rules);
    }

    public function createUser($formData = [])
    {
        $email = apply_filters('fluent_support/signup_email', Arr::get($formData, 'email'));
        $userName = apply_filters('fluent_support/signup_username', Arr::get($formData, 'username'));

        if (empty($formData['password'])) {
            $password = wp_generate_password(8);
        } else {
            $password = $formData['password'];
        }

        $password = apply_filters('fluent_support/signup_password', $password);

        do_action('fluent_support/before_creating_user', $userName, $password, $email);

        return wp_create_user($userName, $password, $email);
    }

    public function maybeUpdateUser($userId, $formData)
    {
        $name = trim(Arr::get($formData, 'first_name') . ' ' . Arr::get($formData, 'last_name'));

        $data = array_filter([
            'ID'            => $userId,
            'user_nicename' => $name,
            'display_name'  => $name,
            'first_name'    => Arr::get($formData, 'first_name'),
            'last_name'     => Arr::get($formData, 'last_name'),
        ]);

        if ($name) {
            do_action('fluent_support/before_updating_user', $data);

            wp_update_user(apply_filters('fluent_support/update_user_data', $data));

            do_action('fluent_support/after_updating_user', $data);
        }
    }

    protected function assignRole($userId)
    {
        $user = new \WP_User($userId);

        do_action('fluent_support/before_assigning_role', $user);

        $user->set_role(apply_filters('fluent_support/user_role', 'subscriber'));

        do_action('fluent_support/after_assigning_role', $user);
    }

    protected function login($userId)
    {
        do_action('fluent_support/before_logging_in_user', $userId);

        wp_clear_auth_cookie();
        wp_set_current_user($userId);
        wp_set_auth_cookie($userId);

        do_action('fluent_support/after_logging_in_user', $userId);
    }
}

```