Gecko [ gandhischool.edu.np ]

Name	Size	Permission
Bridge	[ DIR ]	drwxrwxr-x
Console	[ DIR ]	drwxrwxr-x
Events	[ DIR ]	drwxrwxr-x
Exceptions	[ DIR ]	drwxrwxr-x
Guards	[ DIR ]	drwxrwxr-x
Http	[ DIR ]	drwxrwxr-x
ApiTokenCookieFactory.php	2.07 KB	-rwxrwxr-x
AuthCode.php	1.25 KB	-rwxrwxr-x
Client.php	2.97 KB	-rwxrwxr-x
ClientRepository.php	5.35 KB	-rwxrwxr-x
HasApiTokens.php	1.88 KB	-rwxrwxr-x
Passport.php	15.66 KB	-rwxrwxr-x
PassportServiceProvider.php	8.87 KB	-rwxrwxr-x
PersonalAccessClient.php	627 B	-rwxrwxr-x
PersonalAccessTokenFactory.php	3.52 KB	-rwxrwxr-x
PersonalAccessTokenResult.php	1.15 KB	-rwxrwxr-x
RefreshToken.php	1.61 KB	-rwxrwxr-x
RefreshTokenRepository.php	1.6 KB	-rwxrwxr-x
RouteRegistrar.php	4.63 KB	-rwxrwxr-x
Scope.php	1.08 KB	-rwxrwxr-x
Token.php	3.09 KB	-rwxrwxr-x
TokenRepository.php	2.9 KB	-rwxrwxr-x
TransientToken.php	610 B	-rwxrwxr-x

Code Editor : PassportServiceProvider.php

<?php

namespace Laravel\Passport;

use DateInterval;
use Illuminate\Auth\Events\Logout;
use Illuminate\Auth\RequestGuard;
use Illuminate\Config\Repository as Config;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Cookie;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Request;
use Illuminate\Support\ServiceProvider;
use Laravel\Passport\Bridge\PersonalAccessGrant;
use Laravel\Passport\Bridge\RefreshTokenRepository;
use Laravel\Passport\Guards\TokenGuard;
use League\OAuth2\Server\AuthorizationServer;
use League\OAuth2\Server\CryptKey;
use League\OAuth2\Server\Grant\AuthCodeGrant;
use League\OAuth2\Server\Grant\ClientCredentialsGrant;
use League\OAuth2\Server\Grant\ImplicitGrant;
use League\OAuth2\Server\Grant\PasswordGrant;
use League\OAuth2\Server\Grant\RefreshTokenGrant;
use League\OAuth2\Server\ResourceServer;

class PassportServiceProvider extends ServiceProvider
{
    /**
     * Bootstrap the application services.
     *
     * @return void
     */
    public function boot()
    {
        $this->loadViewsFrom(__DIR__.'/../resources/views', 'passport');

$this->deleteCookieOnLogout();

if ($this->app->runningInConsole()) {
            $this->registerMigrations();

$this->publishes([
                __DIR__.'/../database/migrations' => database_path('migrations'),
            ], 'passport-migrations');

$this->publishes([
                __DIR__.'/../resources/views' => base_path('resources/views/vendor/passport'),
            ], 'passport-views');

$this->publishes([
                __DIR__.'/../resources/js/components' => base_path('resources/js/components/passport'),
            ], 'passport-components');

$this->publishes([
                __DIR__.'/../database/factories' => database_path('factories'),
            ], 'passport-factories');

$this->publishes([
                __DIR__.'/../config/passport.php' => config_path('passport.php'),
            ], 'passport-config');

$this->commands([
                Console\InstallCommand::class,
                Console\ClientCommand::class,
                Console\KeysCommand::class,
                Console\PurgeCommand::class,
            ]);
        }
    }

/**
     * Register Passport's migration files.
     *
     * @return void
     */
    protected function registerMigrations()
    {
        if (Passport::$runsMigrations && ! config('passport.client_uuids')) {
            return $this->loadMigrationsFrom(__DIR__.'/../database/migrations');
        }
    }

/**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/../config/passport.php', 'passport');

Passport::setClientUuids($this->app->make(Config::class)->get('passport.client_uuids', false));

$this->registerAuthorizationServer();
        $this->registerResourceServer();
        $this->registerGuard();
    }

/**
     * Register the authorization server.
     *
     * @return void
     */
    protected function registerAuthorizationServer()
    {
        $this->app->singleton(AuthorizationServer::class, function () {
            return tap($this->makeAuthorizationServer(), function ($server) {
                $server->setDefaultScope(Passport::$defaultScope);

$server->enableGrantType(
                    $this->makeAuthCodeGrant(), Passport::tokensExpireIn()
                );

$server->enableGrantType(
                    $this->makeRefreshTokenGrant(), Passport::tokensExpireIn()
                );

$server->enableGrantType(
                    $this->makePasswordGrant(), Passport::tokensExpireIn()
                );

$server->enableGrantType(
                    new PersonalAccessGrant, Passport::personalAccessTokensExpireIn()
                );

$server->enableGrantType(
                    new ClientCredentialsGrant, Passport::tokensExpireIn()
                );

if (Passport::$implicitGrantEnabled) {
                    $server->enableGrantType(
                        $this->makeImplicitGrant(), Passport::tokensExpireIn()
                    );
                }
            });
        });
    }

/**
     * Create and configure an instance of the Auth Code grant.
     *
     * @return \League\OAuth2\Server\Grant\AuthCodeGrant
     */
    protected function makeAuthCodeGrant()
    {
        return tap($this->buildAuthCodeGrant(), function ($grant) {
            $grant->setRefreshTokenTTL(Passport::refreshTokensExpireIn());
        });
    }

/**
     * Build the Auth Code grant instance.
     *
     * @return \League\OAuth2\Server\Grant\AuthCodeGrant
     */
    protected function buildAuthCodeGrant()
    {
        return new AuthCodeGrant(
            $this->app->make(Bridge\AuthCodeRepository::class),
            $this->app->make(Bridge\RefreshTokenRepository::class),
            new DateInterval('PT10M')
        );
    }

/**
     * Create and configure a Refresh Token grant instance.
     *
     * @return \League\OAuth2\Server\Grant\RefreshTokenGrant
     */
    protected function makeRefreshTokenGrant()
    {
        $repository = $this->app->make(RefreshTokenRepository::class);

return tap(new RefreshTokenGrant($repository), function ($grant) {
            $grant->setRefreshTokenTTL(Passport::refreshTokensExpireIn());
        });
    }

/**
     * Create and configure a Password grant instance.
     *
     * @return \League\OAuth2\Server\Grant\PasswordGrant
     */
    protected function makePasswordGrant()
    {
        $grant = new PasswordGrant(
            $this->app->make(Bridge\UserRepository::class),
            $this->app->make(Bridge\RefreshTokenRepository::class)
        );

$grant->setRefreshTokenTTL(Passport::refreshTokensExpireIn());

return $grant;
    }

/**
     * Create and configure an instance of the Implicit grant.
     *
     * @return \League\OAuth2\Server\Grant\ImplicitGrant
     */
    protected function makeImplicitGrant()
    {
        return new ImplicitGrant(Passport::tokensExpireIn());
    }

/**
     * Make the authorization service instance.
     *
     * @return \League\OAuth2\Server\AuthorizationServer
     */
    public function makeAuthorizationServer()
    {
        return new AuthorizationServer(
            $this->app->make(Bridge\ClientRepository::class),
            $this->app->make(Bridge\AccessTokenRepository::class),
            $this->app->make(Bridge\ScopeRepository::class),
            $this->makeCryptKey('private'),
            app('encrypter')->getKey()
        );
    }

/**
     * Register the resource server.
     *
     * @return void
     */
    protected function registerResourceServer()
    {
        $this->app->singleton(ResourceServer::class, function () {
            return new ResourceServer(
                $this->app->make(Bridge\AccessTokenRepository::class),
                $this->makeCryptKey('public')
            );
        });
    }

/**
     * Create a CryptKey instance without permissions check.
     *
     * @param  string  $key
     * @return \League\OAuth2\Server\CryptKey
     */
    protected function makeCryptKey($type)
    {
        $key = str_replace('\\n', "\n", $this->app->make(Config::class)->get('passport.'.$type.'_key'));

if (! $key) {
            $key = 'file://'.Passport::keyPath('oauth-'.$type.'.key');
        }

return new CryptKey($key, null, false);
    }

/**
     * Register the token guard.
     *
     * @return void
     */
    protected function registerGuard()
    {
        Auth::resolved(function ($auth) {
            $auth->extend('passport', function ($app, $name, array $config) {
                return tap($this->makeGuard($config), function ($guard) {
                    $this->app->refresh('request', $guard, 'setRequest');
                });
            });
        });
    }

/**
     * Make an instance of the token guard.
     *
     * @param  array  $config
     * @return \Illuminate\Auth\RequestGuard
     */
    protected function makeGuard(array $config)
    {
        return new RequestGuard(function ($request) use ($config) {
            return (new TokenGuard(
                $this->app->make(ResourceServer::class),
                Auth::createUserProvider($config['provider']),
                $this->app->make(TokenRepository::class),
                $this->app->make(ClientRepository::class),
                $this->app->make('encrypter')
            ))->user($request);
        }, $this->app['request']);
    }

/**
     * Register the cookie deletion event handler.
     *
     * @return void
     */
    protected function deleteCookieOnLogout()
    {
        Event::listen(Logout::class, function () {
            if (Request::hasCookie(Passport::cookie())) {
                Cookie::queue(Cookie::forget(Passport::cookie()));
            }
        });
    }
}

${this.title}

Code Editor : PassportServiceProvider.php