<h2>Editing File: /home/xaimptsg/public_html/src/vendor/laravel/sanctum/src/Guard.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php

namespace Laravel\Sanctum;

use Illuminate\Contracts\Auth\Factory as AuthFactory;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;
use Laravel\Sanctum\Events\TokenAuthenticated;

class Guard
{
    /**
     * The authentication factory implementation.
     *
     * @var \Illuminate\Contracts\Auth\Factory
     */
    protected $auth;

    /**
     * The number of minutes tokens should be allowed to remain valid.
     *
     * @var int
     */
    protected $expiration;

    /**
     * The provider name.
     *
     * @var string
     */
    protected $provider;

    /**
     * Create a new guard instance.
     *
     * @param  \Illuminate\Contracts\Auth\Factory  $auth
     * @param  int  $expiration
     * @param  string  $provider
     * @return void
     */
    public function __construct(AuthFactory $auth, $expiration = null, $provider = null)
    {
        $this-&gt;auth = $auth;
        $this-&gt;expiration = $expiration;
        $this-&gt;provider = $provider;
    }

    /**
     * Retrieve the authenticated user for the incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return mixed
     */
    public function __invoke(Request $request)
    {
        foreach (Arr::wrap(config('sanctum.guard', 'web')) as $guard) {
            if ($user = $this-&gt;auth-&gt;guard($guard)-&gt;user()) {
                return $this-&gt;supportsTokens($user)
                    ? $user-&gt;withAccessToken(new TransientToken)
                    : $user;
            }
        }

        if ($token = $this-&gt;getTokenFromRequest($request)) {
            $model = Sanctum::$personalAccessTokenModel;

            $accessToken = $model::findToken($token);

            if (! $this-&gt;isValidAccessToken($accessToken) ||
                ! $this-&gt;supportsTokens($accessToken-&gt;tokenable)) {
                return;
            }

            $tokenable = $accessToken-&gt;tokenable-&gt;withAccessToken(
                $accessToken
            );

            event(new TokenAuthenticated($accessToken));

            if (method_exists($accessToken-&gt;getConnection(), 'hasModifiedRecords') &amp;&amp;
                method_exists($accessToken-&gt;getConnection(), 'setRecordModificationState')) {
                tap($accessToken-&gt;getConnection()-&gt;hasModifiedRecords(), function ($hasModifiedRecords) use ($accessToken) {
                    $accessToken-&gt;forceFill(['last_used_at' =&gt; now()])-&gt;save();

                    $accessToken-&gt;getConnection()-&gt;setRecordModificationState($hasModifiedRecords);
                });
            } else {
                $accessToken-&gt;forceFill(['last_used_at' =&gt; now()])-&gt;save();
            }

            return $tokenable;
        }
    }

    /**
     * Determine if the tokenable model supports API tokens.
     *
     * @param  mixed  $tokenable
     * @return bool
     */
    protected function supportsTokens($tokenable = null)
    {
        return $tokenable &amp;&amp; in_array(HasApiTokens::class, class_uses_recursive(
            get_class($tokenable)
        ));
    }

    /**
     * Get the token from the request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return string|null
     */
    protected function getTokenFromRequest(Request $request)
    {
        if (is_callable(Sanctum::$accessTokenRetrievalCallback)) {
            return (string) (Sanctum::$accessTokenRetrievalCallback)($request);
        }

        $token = $request-&gt;bearerToken();

        return $this-&gt;isValidBearerToken($token) ? $token : null;
    }

    /**
     * Determine if the bearer token is in the correct format.
     *
     * @param  string|null  $token
     * @return bool
     */
    protected function isValidBearerToken(string $token = null)
    {
        if (! is_null($token) &amp;&amp; str_contains($token, '|')) {
            $model = new Sanctum::$personalAccessTokenModel;

            if ($model-&gt;getKeyType() === 'int') {
                [$id, $token] = explode('|', $token, 2);

                return ctype_digit($id) &amp;&amp; ! empty($token);
            }
        }

        return ! empty($token);
    }

    /**
     * Determine if the provided access token is valid.
     *
     * @param  mixed  $accessToken
     * @return bool
     */
    protected function isValidAccessToken($accessToken): bool
    {
        if (! $accessToken) {
            return false;
        }

        $isValid =
            (! $this-&gt;expiration || $accessToken-&gt;created_at-&gt;gt(now()-&gt;subMinutes($this-&gt;expiration)))
            &amp;&amp; (! $accessToken-&gt;expires_at || ! $accessToken-&gt;expires_at-&gt;isPast())
            &amp;&amp; $this-&gt;hasValidProvider($accessToken-&gt;tokenable);

        if (is_callable(Sanctum::$accessTokenAuthenticationCallback)) {
            $isValid = (bool) (Sanctum::$accessTokenAuthenticationCallback)($accessToken, $isValid);
        }

        return $isValid;
    }

    /**
     * Determine if the tokenable model matches the provider's model type.
     *
     * @param  \Illuminate\Database\Eloquent\Model  $tokenable
     * @return bool
     */
    protected function hasValidProvider($tokenable)
    {
        if (is_null($this-&gt;provider)) {
            return true;
        }

        $model = config(&quot;auth.providers.{$this-&gt;provider}.model&quot;);

        return $tokenable instanceof $model;
    }
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fhome%2Fxaimptsg%2Fpublic_html%2Fsrc%2Fvendor%2Flaravel%2Fsanctum%2Fsrc'>Back to Directory</a>