Авторизация в Ларавеле

# Illuminate\Auth\Console\AuthMakeCommand.php

public function handle()
{
    // Create directories and files to store the auth front-end interface
    // The template is stored under the stubs of AuthConsole
    $this->createDirectories();
    $this->exportViews();

    if (! $this->option('views')) {
        // Generate HomeController Controller Controller File
        file_put_contents(
            app_path('Http/Controllers/HomeController.php'),
            $this->compileControllerStub()
        );
        // Generating auth-related routing
    file_put_contents(
        base_path('routes/web.php'),
        file_get_contents(__DIR__.'/stubs/make/routes.stub'),
        FILE_APPEND
        );
    }
}

        function csrf_token()
    {
        $session = app('session');

        if (isset($session)) {
            return $session->token();
        }

        throw new RuntimeException('Application session store not set.');
    }

public function login(Request $request)
    {
                // Check Request Body
        $this->validateLogin($request);
                // Judging whether requests failed too many times
        if ($this->hasTooManyLoginAttempts($request)) {
            $this->fireLockoutEvent($request);

            return $this->sendLockoutResponse($request);
        }
                // Determine whether the validation has passed
        if ($this->attemptLogin($request)) {
            return $this->sendLoginResponse($request);
        }
                // Record the number of requests that failed
        $this->incrementLoginAttempts($request);

        return $this->sendFailedLoginResponse($request);
    }

protected function registerAuthenticator()
    {
        $this->app->singleton('auth', function ($app) {
            $app['auth.loaded'] = true;
                        // Generate an AuthManager instance
            return new AuthManager($app);
        });

        $this->app->singleton('auth.driver', function ($app) {
            return $app['auth']->guard();
        });
    }

protected function registerUserResolver()
    {
        $this->app->bind(
            AuthenticatableContract::class, function ($app) {
                return call_user_func($app['auth']->userResolver());
            }
        );
    }

protected function registerAccessGate()
    {
        $this->app->singleton(GateContract::class, function ($app) {
            return new Gate($app, function () use ($app) {
                return call_user_func($app['auth']->userResolver());
            });
        });
    }

protected function registerRequestRebindHandler()
    {
        $this->app->rebinding('request', function ($app, $request) {
            $request->setUserResolver(function ($guard = null) use ($app) {
                return call_user_func($app['auth']->userResolver(), $guard);
            });
        });
    }

public function __construct($app)
    {
                // Binding application instances
        $this->app = $app;
                // Bind a closure to parse the user.
                // Determine how users parse users by $guard
        $this->userResolver = function ($guard = null) {
            return $this->guard($guard)->user();
        };
    }

protected function resolve($name)
    {
        $config = $this->getConfig($name);

                // Call different driver methods for parsing users according to configuration
        $driverMethod = 'create'.ucfirst($config['driver']).'Driver';

        if (method_exists($this, $driverMethod)) {
            return $this->{$driverMethod}($name, $config);
        }
    }

public function createSessionDriver($name, $config)
    {
                // Create a corresponding provider based on the configuration file
        $provider = $this->createUserProvider($config['provider'] ?? null);
                
                $guard = new SessionGuard($name, $provider, $this->app['session.store']);

        return $guard;
    }
    
    public function createTokenDriver($name, $config)
    {
        $guard = new TokenGuard(
            $this->createUserProvider($config['provider'] ?? null),
            $this->app['request'],
            $config['input_key'] ?? 'api_token',
            $config['storage_key'] ?? 'api_token'
        );
        return $guard;
    }

public function __construct(UserProvider $provider, Request $request, $inputKey = 'api_token', $storageKey = 'api_token')
    {
        $this->request = $request;
        $this->provider = $provider;
        $this->inputKey = $inputKey;
        $this->storageKey = $storageKey;
    }

# Illuminate\Auth\TokenGuard

    public function user()
    {
        if (! is_null($this->user)) {
            return $this->user;
        }

        $user = null;
                // Get token from request
        $token = $this->getTokenForRequest();

        if (! empty($token)) {
                        // Determine whether the user has been authenticated successfully by retrieveByCredentials method in the user provider
            $user = $this->provider->retrieveByCredentials(
                [$this->storageKey => $token]
            );
        }

        return $this->user = $user;
    }

# Illuminate\Auth\DatabaseUserProvider

    public function retrieveByCredentials(array $credentials)
    {
        if (empty($credentials) ||
           (count($credentials) === 1 &&
            array_key_exists('password', $credentials))) {
            return;
        }
        $query = $this->conn->table($this->table);

        foreach ($credentials as $key => $value) {
            if (Str::contains($key, 'password')) {
                continue;
            }

            if (is_array($value) || $value instanceof Arrayable) {
                $query->whereIn($key, $value);
            } else {
                $query->where($key, $value);
            }
        }
        
        $user = $query->first();
        
        // Return auth user data package
        return $this->getGenericUser($user);
    }