Laravel 系列 (一)

助手函数

php artisan make:provider HelperServiceProvider

# config/app.php
...
App\Providers\HelperServiceProvider::class,
App\Providers\AppServiceProvider::class,
...

<?php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;

class HelperServiceProvider extends ServiceProvider
{
    /**
     * Register services.
     *
     * @return void
     */
    public function register()
    {
        //
    }

    /**
     * Bootstrap services.
     *
     * @return void
     */
    public function boot()
    {
        foreach (glob(app_path('Helpers') . '/*.php') as $helperFile) {
            require_once $helperFile;
        }
    }
}

nwidart/laravel-modules - 模块化管理

composer require "nwidart/laravel-modules:^6.0"

php artisan vendor:publish --provider="Nwidart\Modules\LaravelModulesServiceProvider"

# config/modules.php 配置
# 1.修改命名空间 (Modules => App\Modules)
'namespace' => 'App\Modules'
'modules' => base_path('app/Modules'),
# 2.重命名 resource (Transformers => Http/Resources)
'resource' => ['path' => 'Http/Resources', 'generate' => false]

laravel/passport

<?php

namespace App\Traits;

use Exception;
use Error;
use TypeError;
use DateTimeImmutable;
use Psr\Http\Message\ResponseInterface;
use Laravel\Passport\Passport;
use Laminas\Diactoros\Response as Psr7Response;
use Laravel\Passport\Bridge\{
    Client,
    AccessToken,
    AccessTokenRepository,
    RefreshTokenRepository
};
use League\OAuth2\Server\CryptKey;
use League\OAuth2\Server\Entities\{AccessTokenEntityInterface, RefreshTokenEntityInterface};
use League\OAuth2\Server\ResponseTypes\{ResponseTypeInterface, AbstractResponseType, BearerTokenResponse};
use League\OAuth2\Server\Exception\UniqueTokenIdentifierConstraintViolationException;
use League\OAuth2\Server\Exception\OAuthServerException;

trait PassportToken
{
    /**
     * @var CryptKey
     */
    protected $privateKey;

    /**
     * @param string $userIdentifier
     * @param int    $clientId
     * @param bool   $ouput
     *
     * @return array|null|ResponseInterface
     * @throws OAuthServerException|UniqueTokenIdentifierConstraintViolationException
     */
    protected function getBearerTokenByUser(string $userIdentifier, int $clientId = 0, bool $ouput = false)
    {
        $this->makeCryptKey('private');
        $accessToken = $this->issueAccessToken($userIdentifier, $clientId);
        $refreshToken = $this->issueRefreshToken($accessToken);

        $tokenResponse = $this->getResponse();
        $tokenResponse->setAccessToken($accessToken);
        $tokenResponse->setRefreshToken($refreshToken);
        $response = $tokenResponse->generateHttpResponse(new Psr7Response());

        if (!$ouput) {
            return json_decode($response->getBody()->__toString(), true);
        }

        return $response;
    }

    /**
     * Issue an access token.
     *
     * @param string $userIdentifier
     * @param string $clientId
     *
     * @return AccessTokenEntityInterface
     * @throws OAuthServerException|UniqueTokenIdentifierConstraintViolationException
     */
    private function issueAccessToken(string $userIdentifier, string $clientId)
    {
		// 这里 $clientId 必须是 oauth_clients 表存在的记录, 不然生成的 access_token 无法通过校验
		// 参考源码 vendor\laravel\passport\src\Bridge\ClientRepository.php - validateClient
        $client = new Client($clientId, null, null);
        $accessToken = new AccessToken($userIdentifier, [], $client);
        $accessToken->setExpiryDateTime((new DateTimeImmutable())->add(Passport::tokensExpireIn()));
        $accessToken->setPrivateKey($this->privateKey);

        /** @var AccessTokenRepository $accessTokenRepository */
        $accessTokenRepository = app(AccessTokenRepository::class);

        $maxGenerationAttempts = 10;
        while ($maxGenerationAttempts-- > 0) {
            $accessToken->setIdentifier($this->generateUniqueIdentifier());
            try {
                $accessTokenRepository->persistNewAccessToken($accessToken);

                return $accessToken;
            } catch (UniqueTokenIdentifierConstraintViolationException $e) {
                if ($maxGenerationAttempts === 0) {
                    throw $e;
                }
            }
        }
    }

    /**
     * Issue an refresh token.
     *
     * @param AccessTokenEntityInterface $accessToken
     *
     * @return RefreshTokenEntityInterface
     * @throws OAuthServerException|UniqueTokenIdentifierConstraintViolationException
     */
    private function issueRefreshToken(AccessTokenEntityInterface $accessToken)
    {
        /** @var RefreshTokenRepository $refreshTokenRepository */
        $refreshTokenRepository = app(RefreshTokenRepository::class);
        $refreshToken = $refreshTokenRepository->getNewRefreshToken();
        $refreshToken->setExpiryDateTime((new DateTimeImmutable())->add(Passport::refreshTokensExpireIn()));
        $refreshToken->setAccessToken($accessToken);

        $maxGenerationAttempts = 10;
        while ($maxGenerationAttempts-- > 0) {
            $refreshToken->setIdentifier($this->generateUniqueIdentifier());
            try {
                $refreshTokenRepository->persistNewRefreshToken($refreshToken);

                return $refreshToken;
            } catch (UniqueTokenIdentifierConstraintViolationException $e) {
                if ($maxGenerationAttempts === 0) {
                    throw $e;
                }
            }
        }
    }

    /**
     * Get the token type that grants will return in the HTTP response.
     *
     * @return ResponseTypeInterface
     */
    private function getResponse()
    {
        $responseType = new BearerTokenResponse();
        if ($responseType instanceof AbstractResponseType) {
            $responseType->setPrivateKey($this->privateKey);
        }

        $responseType->setEncryptionKey(app('encrypter')->getKey());

        return $responseType;
    }

    /**
     * Create a CryptKey instance without permissions check.
     *
     * @param string $type
     */
    private function makeCryptKey($type)
    {
        $key = str_replace('\\n', "\n", config('passport.' . $type . '_key'));
        if (!$key) {
            $key = 'file://' . Passport::keyPath('oauth-' . $type . '.key');
        }

        $this->privateKey = new CryptKey($key, null, false);
    }

    /**
     * Generate a new unique identifier.
     *
     * @param int $length
     *
     * @return string
     * @throws OAuthServerException
     */
    private function generateUniqueIdentifier($length = 40)
    {
        try {
            return \bin2hex(\random_bytes($length));
            // @codeCoverageIgnoreStart
        } catch (TypeError $e) {
            throw OAuthServerException::serverError('An unexpected error has occurred', $e);
        } catch (Error $e) {
            throw OAuthServerException::serverError('An unexpected error has occurred', $e);
        } catch (Exception $e) {
            // If you get this message, the CSPRNG failed hard.
            throw OAuthServerException::serverError('Could not generate a random string', $e);
        }
        // @codeCoverageIgnoreEnd
    }
}