├── src
    ├── Controllers
    │   ├── Home.php
    │   └── Auth
    │   │   ├── EmailVerificationPromptController.php
    │   │   ├── EmailVerificationNotificationController.php
    │   │   ├── ConfirmablePasswordController.php
    │   │   ├── PasswordResetLinkController.php
    │   │   ├── VerifyEmailController.php
    │   │   ├── RegisteredUserController.php
    │   │   ├── NewPasswordController.php
    │   │   └── AuthenticatedSessionController.php
    ├── Contracts
    │   ├── ResetPasswordInterface.php
    │   ├── PasswordBrokerFactoryInterface.php
    │   ├── VerifyEmailInterface.php
    │   ├── AuthenticationBasicInterface.php
    │   ├── HasherInterface.php
    │   ├── AuthorizableInterface.php
    │   ├── PasswordResetRepositoryInterface.php
    │   ├── AuthenticatorInterface.php
    │   ├── UserProviderInterface.php
    │   ├── HasAccessTokensInterface.php
    │   ├── AuthFactoryInterface.php
    │   ├── PasswordBrokerInterface.php
    │   ├── AuthenticationInterface.php
    │   └── GateInterface.php
    ├── AuthServiceProvider.php
    ├── Traits
    │   ├── CanResetPasswordTrait.php
    │   ├── MustVerifyEmailTrait.php
    │   ├── AuthorizableTrait.php
    │   ├── InteractsWithTimeTrait.php
    │   ├── AuthenticatableTrait.php
    │   ├── GuardHelperTrait.php
    │   ├── AuthorizesRequestsTrait.php
    │   ├── UserProviderTrait.php
    │   ├── InteractsWithAuthentication.php
    │   └── HasAccessTokensTrait.php
    ├── Language
    │   └── en
    │   │   ├── Auth.php
    │   │   └── Passwords.php
    ├── Authorization
    │   ├── HandlesAuthorization.php
    │   ├── Events
    │   │   └── GateEvaluated.php
    │   └── Response.php
    ├── Views
    │   ├── Auth
    │   │   ├── messages.php
    │   │   ├── forgot_password.php
    │   │   ├── verify_email.php
    │   │   ├── confirm_password.php
    │   │   ├── layout.php
    │   │   ├── reset_password.php
    │   │   ├── login.php
    │   │   └── register.php
    │   └── Email
    │   │   └── layout.php
    ├── Filters
    │   ├── RedirectAuthenticatedFilter.php
    │   ├── AuthenticationBasicFilter.php
    │   ├── EmailVerifiedFilter.php
    │   ├── ConfirmPasswordFilter.php
    │   ├── AuthorizeFilter.php
    │   ├── ThrottleFilter.php
    │   └── AuthenticationFilter.php
    ├── Passwords
    │   ├── Hash
    │   │   ├── AbstractHasher.php
    │   │   ├── Argon2IdHasher.php
    │   │   ├── HashManager.php
    │   │   ├── BcryptHasher.php
    │   │   ├── AbstractManager.php
    │   │   └── ArgonHasher.php
    │   ├── PasswordBrokerManager.php
    │   ├── RateLimiter.php
    │   ├── PasswordResetRepository.php
    │   └── PasswordBroker.php
    ├── AbstractServiceProvider.php
    ├── Facades
    │   ├── RateLimiter.php
    │   ├── Hash.php
    │   ├── Passwords.php
    │   ├── Gate.php
    │   └── Auth.php
    ├── Exceptions
    │   ├── AuthenticationException.php
    │   └── AuthorizationException.php
    ├── Notifications
    │   ├── ResetPasswordNotification.php
    │   └── VerificationNotification.php
    ├── Helpers
    │   ├── auth_helper.php
    │   ├── Arr.php
    │   └── Str.php
    ├── Entities
    │   ├── User.php
    │   └── AccessToken.php
    ├── Commands
    │   └── AuthClearResetCommand.php
    ├── Models
    │   ├── UserModel.php
    │   └── AccessTokenModel.php
    ├── Config
    │   ├── Hashing.php
    │   ├── Services.php
    │   └── Auth.php
    ├── CookieRecaller.php
    ├── Collectors
    │   └── AuthCollector.php
    ├── Database
    │   └── Migrations
    │   │   └── 2020-12-28-223112_create_auth_tables.php
    └── UserDatabase.php
├── LICENSE.md
├── composer.json
└── README.md


/src/Controllers/Home.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Controllers;
 4 | 
 5 | class Home extends BaseController
 6 | {
 7 |     public function index()
 8 |     {
 9 |         return view('welcome_message');
10 |     }
11 | 
12 |     public function dashboard()
13 |     {
14 |         return view('dashboard');
15 |     }
16 | 
17 |     public function confirm()
18 |     {
19 |         return 'granted password';
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Contracts/ResetPasswordInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Contracts;
 4 | 
 5 | interface ResetPasswordInterface
 6 | {
 7 |     /**
 8 |      * Get the e-mail address where password reset links are sent.
 9 |      *
10 |      * @return string
11 |      */
12 |     public function getEmailForPasswordReset();
13 | 
14 |     /**
15 |      * Send the password reset notification.
16 |      *
17 |      * @return void
18 |      */
19 |     public function sendPasswordResetNotification(string $token);
20 | }
21 | 


--------------------------------------------------------------------------------
/src/AuthServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth;
 4 | 
 5 | use Fluent\Auth\Facades\Gate;
 6 | use Fluent\Auth\AbstractServiceProvider;
 7 | 
 8 | class AuthServiceProvider extends AbstractServiceProvider
 9 | {
10 |     /**
11 |      * The policy mappings for the application.
12 |      *
13 |      * @var array<class-string, class-string>
14 |      */
15 |     protected static $policies = [];
16 | 
17 |     /**
18 |      * {@inheritdoc}
19 |      */
20 |     public static function register()
21 |     {
22 |         static::registerPolicies();
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Controllers/Auth/EmailVerificationPromptController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Controllers\Auth;
 4 | 
 5 | use App\Controllers\BaseController;
 6 | 
 7 | use function auth;
 8 | 
 9 | class EmailVerificationPromptController extends BaseController
10 | {
11 |     /**
12 |      * Display the email verification prompt.
13 |      *
14 |      * @return mixed
15 |      */
16 |     public function new()
17 |     {
18 |         return auth()->user()->hasVerifiedEmail()
19 |             ? redirect()->to(session('intended') ?? config('Auth')->home)
20 |             : view('Auth/verify_email');
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Contracts/PasswordBrokerFactoryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Contracts;
 4 | 
 5 | interface PasswordBrokerFactoryInterface
 6 | {
 7 |     /**
 8 |      * Get a password broker instance by name.
 9 |      *
10 |      * @param  string|null  $name
11 |      * @return PasswordBrokerInterface
12 |      */
13 |     public function broker($name = null);
14 | 
15 |     /**
16 |      * Get the default password broker name.
17 |      *
18 |      * @return string
19 |      */
20 |     public function getDefaultDriver();
21 | 
22 |     /**
23 |      * Set the default password broker name.
24 |      *
25 |      * @param  string  $name
26 |      * @return $this
27 |      */
28 |     public function setDefaultDriver($name);
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Traits/CanResetPasswordTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Traits;
 4 | 
 5 | use CodeIgniter\Events\Events;
 6 | use Fluent\Auth\Contracts\ResetPasswordInterface;
 7 | 
 8 | trait CanResetPasswordTrait
 9 | {
10 |     /**
11 |      * Get the e-mail address where password reset links are sent.
12 |      *
13 |      * @return string
14 |      */
15 |     public function getEmailForPasswordReset()
16 |     {
17 |         return $this->email;
18 |     }
19 | 
20 |     /**
21 |      * Send the password reset notification.
22 |      *
23 |      * @return void
24 |      */
25 |     public function sendPasswordResetNotification(string $token)
26 |     {
27 |         Events::trigger(ResetPasswordInterface::class, $this->getEmailForPasswordReset(), $token);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Language/en/Auth.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 | 
 5 |     /*
 6 |     |--------------------------------------------------------------------------
 7 |     | Authentication Language Lines
 8 |     |--------------------------------------------------------------------------
 9 |     |
10 |     | The following language lines are used during authentication for various
11 |     | messages that we need to display to the user. You are free to modify
12 |     | these language lines according to your application's requirements.
13 |     |
14 |     */
15 |     'failed'    => 'These credentials do not match our records.',
16 |     'throttler' => 'You submitted over {0} requests within a minute. Please try again in {1} seconds.',
17 |     'throttle'  => 'Too many login attempts. Please try again in {0} seconds.',
18 | ];
19 | 


--------------------------------------------------------------------------------
/src/Authorization/HandlesAuthorization.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Authorization;
 4 | 
 5 | trait HandlesAuthorization
 6 | {
 7 |     /**
 8 |      * Create a new access response.
 9 |      *
10 |      * @param  string|null  $message
11 |      * @param  mixed  $code
12 |      * @return \Fluent\Auth\Authorization\Response
13 |      */
14 |     protected function allow($message = null, $code = null)
15 |     {
16 |         return Response::allow($message, $code);
17 |     }
18 | 
19 |     /**
20 |      * Throws an unauthorized exception.
21 |      *
22 |      * @param  string|null  $message
23 |      * @param  mixed|null  $code
24 |      * @return \Fluent\Auth\Authorization\Response
25 |      */
26 |     protected function deny($message = null, $code = null)
27 |     {
28 |         return Response::deny($message, $code);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Contracts/VerifyEmailInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Contracts;
 4 | 
 5 | interface VerifyEmailInterface
 6 | {
 7 |     /**
 8 |      * Determine if the user has verified their email address.
 9 |      *
10 |      * @return bool
11 |      */
12 |     public function hasVerifiedEmail();
13 | 
14 |     /**
15 |      * Mark the given user's email as verified.
16 |      *
17 |      * @return bool
18 |      */
19 |     public function markEmailAsVerified();
20 | 
21 |     /**
22 |      * Send the email verification notification.
23 |      *
24 |      * @return void
25 |      */
26 |     public function sendEmailVerificationNotification();
27 | 
28 |     /**
29 |      * Get the email address that should be used for verification.
30 |      *
31 |      * @return string
32 |      */
33 |     public function getEmailForVerification();
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Views/Auth/messages.php:
--------------------------------------------------------------------------------
 1 | <?php if (session()->has('message')) : ?>
 2 |     <div class="alert alert-success" role="alert">
 3 |         <p class="mb-0"><?= session('message') ?></p>
 4 |     </div>
 5 | <?php endif ?>
 6 | 
 7 | <?php if (session()->has('error')) : ?>
 8 |     <div class="alert alert-danger" role="alert">
 9 |         <h5 class="alert-heading">Whoops! Something went wrong.</h5>
10 |         <hr>
11 |         <p class="mb-0"><?= session('error') ?></p>
12 |     </div>
13 | <?php endif ?>
14 | 
15 | <?php if (session()->has('errors')) : ?>
16 |     <div class="alert alert-danger" role="alert">
17 |         <h5 class="alert-heading">Whoops! Something went wrong.</h5>
18 |         <hr>
19 |         <?php foreach (session('errors') as $error) : ?>
20 |             <li class="mb-0"><?= $error ?></li>
21 |         <?php endforeach ?>
22 |     </div>
23 | <?php endif ?>
24 | 


--------------------------------------------------------------------------------
/src/Filters/RedirectAuthenticatedFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Filters;
 4 | 
 5 | use CodeIgniter\Filters\FilterInterface;
 6 | use CodeIgniter\HTTP\RequestInterface;
 7 | use CodeIgniter\HTTP\ResponseInterface;
 8 | use Fluent\Auth\Facades\Auth;
 9 | 
10 | class RedirectAuthenticatedFilter implements FilterInterface
11 | {
12 |     /**
13 |      * {@inheritdoc}
14 |      */
15 |     public function before(RequestInterface $request, $arguments = null)
16 |     {
17 |         if (empty($arguments)) {
18 |             $arguments = [null];
19 |         }
20 | 
21 |         foreach ($arguments as $guard) {
22 |             if (Auth::guard($guard)->check()) {
23 |                 return redirect(config('Auth')->home);
24 |             }
25 |         }
26 |     }
27 | 
28 |     /**
29 |      * {@inheritdoc}
30 |      */
31 |     public function after(RequestInterface $request, ResponseInterface $response, $arguments = null)
32 |     {
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Passwords/Hash/AbstractHasher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Passwords\Hash;
 4 | 
 5 | use function password_get_info;
 6 | use function password_verify;
 7 | use function strlen;
 8 | 
 9 | abstract class AbstractHasher
10 | {
11 |     /**
12 |      * Get information about the given hashed value.
13 |      *
14 |      * @param  string  $hashedValue
15 |      * @return array
16 |      */
17 |     public function info($hashedValue)
18 |     {
19 |         return password_get_info($hashedValue);
20 |     }
21 | 
22 |     /**
23 |      * Check the given plain value against a hash.
24 |      *
25 |      * @param  string  $value
26 |      * @param  string  $hashedValue
27 |      * @param  array  $options
28 |      * @return bool
29 |      */
30 |     public function check($value, $hashedValue, array $options = [])
31 |     {
32 |         if (strlen($hashedValue) === 0) {
33 |             return false;
34 |         }
35 | 
36 |         return password_verify($value, $hashedValue);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Contracts/AuthenticationBasicInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Contracts;
 4 | 
 5 | interface AuthenticationBasicInterface
 6 | {
 7 |     /**
 8 |      * Attempt to authenticate using HTTP Basic Auth.
 9 |      *
10 |      * @param  string  $field
11 |      * @param  array  $extraConditions
12 |      * @throws \Fluent\Auth\Exceptions\AuthenticationException
13 |      */
14 |     public function basic($field = 'email', $extraConditions = []);
15 | 
16 |     /**
17 |      * Perform a stateless HTTP Basic login attempt.
18 |      *
19 |      * @param  string  $field
20 |      * @param  array  $extraConditions
21 |      * @throws \Fluent\Auth\Exceptions\AuthenticationException
22 |      */
23 |     public function onceBasic($field = 'email', $extraConditions = []);
24 | 
25 |     /**
26 |      * Log a user into the application without sessions or cookies.
27 |      *
28 |      * @param  array  $credentials
29 |      * @return bool
30 |      */
31 |     public function once(array $credentials = []);
32 | }


--------------------------------------------------------------------------------
/src/AbstractServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth;
 4 | 
 5 | use Fluent\Auth\Facades\Gate;
 6 | 
 7 | abstract class AbstractServiceProvider
 8 | {
 9 |     /**
10 |      * The policy mappings for the application.
11 |      *
12 |      * @var array<class-string, class-string>
13 |      */
14 |     protected static $policies = [];
15 | 
16 |     /**
17 |      * Register the service provider.
18 |      *
19 |      * @return void
20 |      */
21 |     abstract static function register();
22 | 
23 |     /**
24 |      * Register the application's policies.
25 |      *
26 |      * @return void
27 |      */
28 |     public static function registerPolicies()
29 |     {
30 |         foreach (static::policies() as $key => $value) {
31 |             Gate::policy($key, $value);
32 |         }
33 |     }
34 | 
35 |     /**
36 |      * Get the policies defined on the provider.
37 |      *
38 |      * @return array
39 |      */
40 |     public static function policies()
41 |     {
42 |         return static::$policies;
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Controllers/Auth/EmailVerificationNotificationController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Controllers\Auth;
 4 | 
 5 | use App\Controllers\BaseController;
 6 | use CodeIgniter\HTTP\RedirectResponse;
 7 | use Fluent\Auth\Contracts\PasswordBrokerInterface;
 8 | use Fluent\Auth\Facades\Passwords;
 9 | 
10 | use function auth;
11 | 
12 | class EmailVerificationNotificationController extends BaseController
13 | {
14 |     /**
15 |      * Send a new verification notification.
16 |      *
17 |      * @return RedirectResponse
18 |      */
19 |     public function create()
20 |     {
21 |         $user = auth()->user();
22 | 
23 |         if ($user->hasVerifiedEmail()) {
24 |             return redirect()->to(session('intended') ?? config('Auth')->home);
25 |         }
26 | 
27 |         $status = Passwords::sendVerifyLink([
28 |             'email' => $user->email,
29 |         ]);
30 | 
31 |         return $status === PasswordBrokerInterface::VERIFY_LINK_SENT
32 |             ? redirect()->back()->with('message', lang($status))
33 |             : redirect()->back()->with('error', lang($status));
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Language/en/Passwords.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 | 
 5 |     /*
 6 |     |--------------------------------------------------------------------------
 7 |     | Password Reset Language Lines
 8 |     |--------------------------------------------------------------------------
 9 |     |
10 |     | The following language lines are the default lines which match reasons
11 |     | that are given by the password broker for a password update attempt
12 |     | has failed, such as for an invalid token or invalid new password.
13 |     |
14 |     */
15 |     'verify'    => 'A new verification link has been sent to the email address you provided during registration.',
16 |     'confirm'   => 'The provided password is incorrect.',
17 |     'reset'     => 'Your password has been reset!',
18 |     'sent'      => 'We have emailed your password reset link!',
19 |     'throttled' => 'Please wait before retrying.',
20 |     'token'     => 'This password reset token is invalid.',
21 |     'expired'   => 'This password reset token is expired.',
22 |     'user'      => "We can't find a user with that email address.",
23 | ];
24 | 


--------------------------------------------------------------------------------
/src/Facades/RateLimiter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Facades;
 4 | 
 5 | use Closure;
 6 | use Fluent\Auth\Config\Services;
 7 | 
 8 | /**
 9 |  * @see \Fluent\Auth\Passwords\RateLimiter
10 |  *
11 |  * @method static \Fluent\Auth\Passwords\RateLimiter for(string $name, Closure $callback)
12 |  * @method static Closure limiter(string $name)
13 |  * @method static bool tooManyAttempts($key, $maxAttempts)
14 |  * @method static int hit($key, $decaySeconds = 60)
15 |  * @method static mixed attempts($key)
16 |  * @method static mixed resetAttempts($key)
17 |  * @method static int retriesLeft($key, $maxAttempts)
18 |  * @method static void clear($key)
19 |  * @method static int availableIn($key)
20 |  */
21 | class RateLimiter
22 | {
23 |     /**
24 |      * Facade rate limiter instance service.
25 |      *
26 |      * @param string $method
27 |      * @param array $arguments
28 |      * @return \Fluent\Auth\Passwords\RateLimiter
29 |      */
30 |     public static function __callStatic($method, $arguments)
31 |     {
32 |         return Services::getSharedInstance('limiter')->{$method}(...$arguments);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Contracts/HasherInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Contracts;
 4 | 
 5 | interface HasherInterface
 6 | {
 7 |     /**
 8 |      * Get information about the given hashed value.
 9 |      *
10 |      * @param  string  $hashedValue
11 |      * @return array
12 |      */
13 |     public function info($hashedValue);
14 | 
15 |     /**
16 |      * Hash the given value.
17 |      *
18 |      * @param  string  $value
19 |      * @param  array  $options
20 |      * @return string
21 |      */
22 |     public function make($value, array $options = []);
23 | 
24 |     /**
25 |      * Check the given plain value against a hash.
26 |      *
27 |      * @param  string  $value
28 |      * @param  string  $hashedValue
29 |      * @param  array  $options
30 |      * @return bool
31 |      */
32 |     public function check($value, $hashedValue, array $options = []);
33 | 
34 |     /**
35 |      * Check if the given hash has been hashed using the given options.
36 |      *
37 |      * @param  string  $hashedValue
38 |      * @param  array  $options
39 |      * @return bool
40 |      */
41 |     public function needsRehash($hashedValue, array $options = []);
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Filters/AuthenticationBasicFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Filters;
 4 | 
 5 | use CodeIgniter\Filters\FilterInterface;
 6 | use CodeIgniter\HTTP\RequestInterface;
 7 | use CodeIgniter\HTTP\ResponseInterface;
 8 | use Fluent\Auth\Config\Services;
 9 | use Fluent\Auth\Contracts\AuthenticationBasicInterface;
10 | use Fluent\Auth\Contracts\AuthenticationInterface;
11 | use Fluent\Auth\Contracts\AuthFactoryInterface;
12 | 
13 | class AuthenticationBasicFilter implements FilterInterface
14 | {
15 |     /** @var AuthFactoryInterface|AuthenticationBasicInterface|AuthenticationInterface */
16 |     protected $auth;
17 | 
18 |     public function __construct()
19 |     {
20 |         $this->auth = Services::auth();
21 |     }
22 | 
23 |     /**
24 |      * {@inheritdoc}
25 |      */
26 |     public function before(RequestInterface $request, $arguments = null)
27 |     {
28 |         [$guard, $field, $method] = $arguments;
29 | 
30 |         $this->auth->guard($guard)->{$method}($field);
31 |     }
32 | 
33 |     /**
34 |      * {@inheritdoc}
35 |      */
36 |     public function after(RequestInterface $request, ResponseInterface $response, $arguments = null)
37 |     {
38 |     }
39 | }


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) Taylor Otwell
 4 | 
 5 | Copyright (c) Agung Sugiarto
 6 | 
 7 | Permission is hereby granted, free of charge, to any person obtaining a copy
 8 | of this software and associated documentation files (the "Software"), to deal
 9 | in the Software without restriction, including without limitation the rights
10 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 | copies of the Software, and to permit persons to whom the Software is
12 | furnished to do so, subject to the following conditions:
13 | 
14 | The above copyright notice and this permission notice shall be included in
15 | all copies or substantial portions of the Software.
16 | 
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 | THE SOFTWARE.
24 | 


--------------------------------------------------------------------------------
/src/Controllers/Auth/ConfirmablePasswordController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Controllers\Auth;
 4 | 
 5 | use App\Controllers\BaseController;
 6 | use CodeIgniter\View\RendererInterface;
 7 | use Fluent\Auth\Facades\Auth;
 8 | 
 9 | use function auth;
10 | use function time;
11 | 
12 | class ConfirmablePasswordController extends BaseController
13 | {
14 |     /**
15 |      * Show the confirm password view.
16 |      *
17 |      * @return RendererInterface
18 |      */
19 |     public function show()
20 |     {
21 |         return view('Auth/confirm_password');
22 |     }
23 | 
24 |     /**
25 |      * Confirm the users password.
26 |      *
27 |      * @return mixed
28 |      */
29 |     public function create()
30 |     {
31 |         $request = (object) $this->request->getPost();
32 | 
33 |         if (
34 |             ! Auth::validate([
35 |                 'email'    => auth()->user()->email,
36 |                 'password' => $request->password,
37 |             ])
38 |         ) {
39 |             return redirect()->back()->with('error', lang('Passwords.confirm'));
40 |         }
41 | 
42 |         session()->set('password_confirmed_at', time());
43 | 
44 |         return redirect()->to(session('intended') ?? config('Auth')->home);
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Authorization/Events/GateEvaluated.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Authorization\Events;
 4 | 
 5 | class GateEvaluated
 6 | {
 7 |     /**
 8 |      * The authenticatable model.
 9 |      *
10 |      * @var \Fluent\Auth\Contracts\AuthenticatorInterface|null
11 |      */
12 |     public $user;
13 | 
14 |     /**
15 |      * The ability being evaluated.
16 |      *
17 |      * @var string
18 |      */
19 |     public $ability;
20 | 
21 |     /**
22 |      * The result of the evaluation.
23 |      *
24 |      * @var bool|null
25 |      */
26 |     public $result;
27 | 
28 |     /**
29 |      * The arguments given during evaluation.
30 |      *
31 |      * @var array
32 |      */
33 |     public $arguments;
34 | 
35 |     /**
36 |      * Create a new event instance.
37 |      *
38 |      * @param  \Fluent\Auth\Contracts\AuthenticatorInterface|null  $user
39 |      * @param  string  $ability
40 |      * @param  bool|null  $result
41 |      * @param  array  $arguments
42 |      * @return void
43 |      */
44 |     public function __construct($user, $ability, $result, $arguments)
45 |     {
46 |         $this->user = $user;
47 |         $this->ability = $ability;
48 |         $this->result = $result;
49 |         $this->arguments = $arguments;
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Contracts/AuthorizableInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Contracts;
 4 | 
 5 | interface AuthorizableInterface
 6 | {
 7 |     /**
 8 |      * Determine if the entity has a given ability.
 9 |      *
10 |      * @param  iterable|string  $abilities
11 |      * @param  array|mixed  $arguments
12 |      * @return bool
13 |      */
14 |     public function can($abilities, $arguments = []);
15 | 
16 |     /**
17 |      * Determine if the entity has any of the given abilities.
18 |      *
19 |      * @param  iterable|string  $abilities
20 |      * @param  array|mixed  $arguments
21 |      * @return bool
22 |      */
23 |     public function canAny($abilities, $arguments = []);
24 | 
25 |     /**
26 |      * Determine if the entity does not have the given abilities.
27 |      *
28 |      * @param  iterable|string  $abilities
29 |      * @param  array|mixed  $arguments
30 |      * @return bool
31 |      */
32 |     public function cant($abilities, $arguments = []);
33 | 
34 |     /**
35 |      * Determine if the entity does not have the given abilities.
36 |      *
37 |      * @param  iterable|string  $abilities
38 |      * @param  array|mixed  $arguments
39 |      * @return bool
40 |      */
41 |     public function cannot($abilities, $arguments = []);
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Passwords/Hash/Argon2IdHasher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace FLuent\Auth\Passwords\Hash;
 4 | 
 5 | use Fluent\Auth\Passwords\Hash\ArgonHasher;
 6 | use RuntimeException;
 7 | 
 8 | use function password_verify;
 9 | use function strlen;
10 | 
11 | use const PASSWORD_ARGON2ID;
12 | 
13 | class Argon2IdHasher extends ArgonHasher
14 | {
15 |     /**
16 |      * Check the given plain value against a hash.
17 |      *
18 |      * @param  string  $value
19 |      * @param  string  $hashedValue
20 |      * @param  array  $options
21 |      * @return bool
22 |      * @throws RuntimeException
23 |      */
24 |     public function check($value, $hashedValue, array $options = [])
25 |     {
26 |         if ($this->verifyAlgorithm && $this->info($hashedValue)['algoName'] !== 'argon2id') {
27 |             throw new RuntimeException('This password does not use the Argon2id algorithm.');
28 |         }
29 | 
30 |         if (strlen($hashedValue) === 0) {
31 |             return false;
32 |         }
33 | 
34 |         return password_verify($value, $hashedValue);
35 |     }
36 | 
37 |     /**
38 |      * Get the algorithm that should be used for hashing.
39 |      *
40 |      * @return int
41 |      */
42 |     protected function algorithm()
43 |     {
44 |         return PASSWORD_ARGON2ID;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Contracts/PasswordResetRepositoryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Contracts;
 4 | 
 5 | use Fluent\Auth\Contracts\ResetPasswordInterface;
 6 | 
 7 | interface PasswordResetRepositoryInterface
 8 | {
 9 |     /**
10 |      * Create a new token.
11 |      *
12 |      * @return string
13 |      */
14 |     public function create(ResetPasswordInterface $user);
15 | 
16 |     /**
17 |      * Create a new token for the user.
18 |      *
19 |      * @return string
20 |      */
21 |     public function createNewToken();
22 | 
23 |     /**
24 |      * Determine if a token record exists and is valid.
25 |      *
26 |      * @param string $token
27 |      * @return bool
28 |      */
29 |     public function exists(ResetPasswordInterface $user, $token);
30 | 
31 |     /**
32 |      * Determine if the given user recently created a password reset token.
33 |      *
34 |      * @return bool
35 |      */
36 |     public function recentlyCreatedToken(ResetPasswordInterface $user);
37 | 
38 |     /**
39 |      * Destroy a token record.
40 |      *
41 |      * @return void
42 |      */
43 |     public function destroy(ResetPasswordInterface $user);
44 | 
45 |     /**
46 |      * Delete expired tokens.
47 |      *
48 |      * @return void
49 |      */
50 |     public function destroyExpired();
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Facades/Hash.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Facades;
 4 | 
 5 | use Fluent\Auth\Config\Services;
 6 | use Fluent\Auth\Contracts\HasherInterface;
 7 | use Fluent\Auth\Passwords\Hash\AbstractManager;
 8 | use Fluent\Auth\Passwords\Hash\HashManager;
 9 | 
10 | /**
11 |  * @see \Fluent\Auth\Contracts\HasherInterface
12 |  * @see \Fluent\Auth\Passwords\Hash\AbstractManager
13 |  * @see \Fluent\Auth\Passwords\Hash\HashManager
14 |  *
15 |  * @method static HasherInterface driver($driver = null)
16 |  * @method static $this extend($driver, Closure $callback)
17 |  * @method static array getDrivers()
18 |  * @method static string getDefaultDriver()
19 |  * @method static array info(string $hashedValue)
20 |  * @method static bool check(string $value, string $hashedValue, array $options = [])
21 |  * @method static bool needsRehash(string $hashedValue, array $options = [])
22 |  * @method static string make(string $value, array $options = [])
23 |  */
24 | class Hash
25 | {
26 |     /**
27 |      * Facade hash instance service.
28 |      *
29 |      * @param string $method
30 |      * @param array $arguments
31 |      * @return AbstractManager|HashManager|HasherInterface
32 |      */
33 |     public static function __callStatic($method, $arguments)
34 |     {
35 |         return Services::getSharedInstance('hash')->{$method}(...$arguments);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Exceptions/AuthenticationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Exceptions;
 4 | 
 5 | use Exception;
 6 | 
 7 | class AuthenticationException extends Exception
 8 | {
 9 |     /**
10 |      * All of the guards that were checked.
11 |      *
12 |      * @var array
13 |      */
14 |     protected $guards;
15 | 
16 |     /**
17 |      * The path the user should be redirected to.
18 |      *
19 |      * @var string
20 |      */
21 |     protected $redirectTo;
22 | 
23 |     /**
24 |      * Create a new authentication exception.
25 |      *
26 |      * @param string $message
27 |      * @param array $guards
28 |      * @param string|null $redirectTo
29 |      * @return void
30 |      */
31 |     public function __construct($message = 'Unauthenticated.', array $guards = [], int $code = 401, $redirectTo = null)
32 |     {
33 |         parent::__construct($message, $code);
34 | 
35 |         $this->guards     = $guards;
36 |         $this->redirectTo = $redirectTo;
37 |     }
38 | 
39 |     /**
40 |      * Get the guards that were checked.
41 |      *
42 |      * @return array
43 |      */
44 |     public function guards()
45 |     {
46 |         return $this->guards;
47 |     }
48 | 
49 |     /**
50 |      * Get the path the user should be redirected to.
51 |      *
52 |      * @return string
53 |      */
54 |     public function redirectTo()
55 |     {
56 |         return $this->redirectTo;
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Notifications/ResetPasswordNotification.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Notifications;
 4 | 
 5 | use CodeIgniter\Config\Services;
 6 | use CodeIgniter\Email\Email;
 7 | 
 8 | class ResetPasswordNotification
 9 | {
10 |     /** @var string */
11 |     protected $email;
12 | 
13 |     /** @var string */
14 |     protected $token;
15 | 
16 |     /** @var Email */
17 |     protected $service;
18 | 
19 |     /**
20 |      * Instance verification notification.
21 |      */
22 |     public function __construct(string $email, string $token)
23 |     {
24 |         $this->email   = $email;
25 |         $this->token   = $token;
26 |         $this->service = Services::email();
27 |     }
28 | 
29 |     /**
30 |      * Sending email verification.
31 |      *
32 |      * @return bool
33 |      */
34 |     public function send()
35 |     {
36 |         $this->service
37 |             ->setTo($this->email)
38 |             ->setSubject("Reset Password Notification")
39 |             ->setMessage(view('Fluent\Auth\Views\Email\reset_email', [
40 |                 'token'  => $this->token,
41 |                 'email'  => $this->email,
42 |                 'expire' => config('Auth')->passwords[config('Auth')->defaults['password']]['expire'],
43 |             ]))
44 |             ->setMailType('html');
45 | 
46 |         if (! $this->service->send()) {
47 |             log_message('error', $this->service->printDebugger());
48 | 
49 |             return false;
50 |         }
51 | 
52 |         return true;
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/Notifications/VerificationNotification.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Notifications;
 4 | 
 5 | use CodeIgniter\Config\Services;
 6 | use CodeIgniter\Email\Email;
 7 | use CodeIgniter\I18n\Time;
 8 | 
 9 | class VerificationNotification
10 | {
11 |     /** @var string */
12 |     protected $email;
13 | 
14 |     /** @var Email */
15 |     protected $service;
16 | 
17 |     /**
18 |      * Instance verification notification.
19 |      */
20 |     public function __construct(string $email)
21 |     {
22 |         $this->email   = $email;
23 |         $this->service = Services::email();
24 |     }
25 | 
26 |     /**
27 |      * Sending email verification.
28 |      *
29 |      * @return bool
30 |      */
31 |     public function send()
32 |     {
33 |         $this->service
34 |             ->setTo($this->email)
35 |             ->setSubject('Verify Email Notification')
36 |             ->setMessage(view('Fluent\Auth\Views\Email\verify_email', [
37 |                 'hash'      => sha1($this->email),
38 |                 'expire'    => Time::now()->addMinutes(config('Auth')->passwords[config('Auth')->defaults['password']]['expire'])->getTimestamp(),
39 |                 'signature' => hash_hmac('sha256', $this->email, config('Encryption')->key),
40 |             ]))
41 |             ->setMailType('html');
42 | 
43 |         if (! $this->service->send()) {
44 |             log_message('error', $this->service->printDebugger());
45 | 
46 |             return false;
47 |         }
48 | 
49 |         return true;
50 |     }
51 | }


--------------------------------------------------------------------------------
/src/Contracts/AuthenticatorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Contracts;
 4 | 
 5 | interface AuthenticatorInterface
 6 | {
 7 |     /**
 8 |      * Returns the name of the column used to uniquely
 9 |      * identify this user, typically 'id'.
10 |      */
11 |     public function getAuthIdColumn(): string;
12 | 
13 |     /**
14 |      * Returns the unique identifier of the object for
15 |      * authentication purposes, typically user's id.
16 |      *
17 |      * @return mixed
18 |      */
19 |     public function getAuthId();
20 | 
21 |     /**
22 |      * Returns the name of the column with the email address of this user.
23 |      */
24 |     public function getAuthEmailColumn(): string;
25 | 
26 |     /**
27 |      * Returns the email address for this user.
28 |      *
29 |      * @return string|null
30 |      */
31 |     public function getAuthEmail();
32 | 
33 |     /**
34 |      * Get the password for the user.
35 |      *
36 |      * @return string|null
37 |      */
38 |     public function getAuthPassword();
39 | 
40 |     /**
41 |      * Returns the "remember me" token for this user.
42 |      *
43 |      * @return string|null
44 |      */
45 |     public function getRememberToken();
46 | 
47 |     /**
48 |      * Sets the "remmeber me" token.
49 |      *
50 |      * @return mixed
51 |      */
52 |     public function setRememberToken(string $value);
53 | 
54 |     /**
55 |      * Returns the column name that stores the remember-me value.
56 |      */
57 |     public function getRememberColumn(): string;
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Traits/MustVerifyEmailTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Traits;
 4 | 
 5 | use CodeIgniter\Events\Events;
 6 | use CodeIgniter\I18n\Time;
 7 | use Fluent\Auth\Config\Services;
 8 | use Fluent\Auth\Contracts\VerifyEmailInterface;
 9 | 
10 | use function is_null;
11 | 
12 | trait MustVerifyEmailTrait
13 | {
14 |     /**
15 |      * Determine if the user has verified their email address.
16 |      *
17 |      * @return bool
18 |      */
19 |     public function hasVerifiedEmail()
20 |     {
21 |         return ! is_null($this->email_verified_at);
22 |     }
23 | 
24 |     /**
25 |      * Mark the given user's email as verified.
26 |      *
27 |      * @return bool
28 |      */
29 |     public function markEmailAsVerified()
30 |     {
31 |         return Services::auth()
32 |             ->getProvider()
33 |             ->instance()
34 |             ->where('email', $this->getEmailForVerification())
35 |             ->set('email_verified_at', Time::now())
36 |             ->update();
37 |     }
38 | 
39 |     /**
40 |      * Send the email verification notification.
41 |      *
42 |      * @return void
43 |      */
44 |     public function sendEmailVerificationNotification()
45 |     {
46 |         Events::trigger(VerifyEmailInterface::class, $this->getEmailForVerification());
47 |     }
48 | 
49 |     /**
50 |      * Get the email address that should be used for verification.
51 |      *
52 |      * @return string
53 |      */
54 |     public function getEmailForVerification()
55 |     {
56 |         return $this->email;
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "agungsugiarto/codeigniter4-authentication",
 3 |     "description": "Provides an API for authentication and includes concrete authentication adapters for common use case scenarios",
 4 |     "keywords": [
 5 |         "codeigniter4",
 6 |         "authentication",
 7 |         "auth"
 8 |     ],
 9 |     "license": "MIT",
10 |     "authors": [
11 |         {
12 |             "name": "Agung Sugiarto",
13 |             "email": "me.agungsugiarto@gmail.com",
14 |             "homepage": "https://agungsugiarto.github.io",
15 |             "role": "Developer"
16 |         }
17 |     ],
18 |     "require": {
19 |         "codeigniter4/framework": "^4.1",
20 |         "php": "^7.3 || ^8.0",
21 |         "tightenco/collect": "^8.83"
22 |     },
23 |     "require-dev": {
24 |         "fakerphp/faker": "^1.13",
25 |         "phpunit/phpunit": "^9.1"
26 |     },
27 |     "autoload": {
28 |         "psr-4": {
29 |             "Fluent\\Auth\\": "src/"
30 |         },
31 |         "files": [
32 |             "src/Helpers/auth_helper.php"
33 |         ]
34 |     },
35 |     "autoload-dev": {
36 |         "psr-4": {
37 |             "Fluent\\Auth\\Tests\\": "tests/"
38 |         }
39 |     },
40 |     "extra": {
41 |         "branch-alias": {
42 |             "dev-master": "2.x-dev"
43 |         }
44 |     },
45 |     "provide": {
46 |         "codeigniter4/authentication-implementation": "1.0"
47 |     },
48 |     "minimum-stability": "dev",
49 |     "prefer-stable": true,
50 |     "scripts": {
51 |         "test": "phpunit"
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Helpers/auth_helper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Fluent\Auth\Config\Services;
 4 | use Fluent\Auth\Contracts\AuthenticationBasicInterface;
 5 | use Fluent\Auth\Contracts\AuthenticationInterface;
 6 | use Fluent\Auth\Contracts\AuthFactoryInterface;
 7 | 
 8 | if (! function_exists('auth')) {
 9 |     /**
10 |      * Provides convenient access to the main authentication class.
11 |      *
12 |      * @param string|null $guard
13 |      * @return AuthFactoryInterface|AuthenticationBasicInterface|AuthenticationInterface
14 |      */
15 |     function auth($guard = null)
16 |     {
17 |         if (is_null($guard)) {
18 |             return Services::getSharedInstance('auth');
19 |         }
20 | 
21 |         return Services::getSharedInstance('auth')->guard($guard);
22 |     }
23 | }
24 | 
25 | if (! function_exists('user_id')) {
26 |     /**
27 |      * Provide codeigniter4/authentitication-implementation.
28 |      * Get the unique identifier for a current user.
29 |      *
30 |      * @param string|null $guard
31 |      * @return string|int|null
32 |      */
33 |     function user_id($guard = null)
34 |     {
35 |         return auth($guard)->id();
36 |     }
37 | }
38 | 
39 | if (! function_exists('with')) {
40 |     /**
41 |      * Return the given value, optionally passed through the given callback.
42 |      *
43 |      * @param  mixed  $value
44 |      * @param  callable|null  $callback
45 |      * @return mixed
46 |      */
47 |     function with($value, callable $callback = null)
48 |     {
49 |         return is_null($callback) ? $value : $callback($value);
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Entities/User.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Entities;
 4 | 
 5 | use CodeIgniter\Entity\Entity;
 6 | use Fluent\Auth\Contracts\AuthenticatorInterface;
 7 | use Fluent\Auth\Contracts\AuthorizableInterface;
 8 | use Fluent\Auth\Contracts\HasAccessTokensInterface;
 9 | use Fluent\Auth\Contracts\ResetPasswordInterface;
10 | use Fluent\Auth\Contracts\VerifyEmailInterface;
11 | use Fluent\Auth\Facades\Hash;
12 | use Fluent\Auth\Traits\AuthenticatableTrait;
13 | use Fluent\Auth\Traits\AuthorizableTrait;
14 | use Fluent\Auth\Traits\CanResetPasswordTrait;
15 | use Fluent\Auth\Traits\HasAccessTokensTrait;
16 | use Fluent\Auth\Traits\MustVerifyEmailTrait;
17 | 
18 | class User extends Entity implements
19 |     AuthenticatorInterface,
20 |     AuthorizableInterface,
21 |     HasAccessTokensInterface,
22 |     ResetPasswordInterface,
23 |     VerifyEmailInterface
24 | {
25 |     use AuthenticatableTrait;
26 |     use AuthorizableTrait;
27 |     use CanResetPasswordTrait;
28 |     use HasAccessTokensTrait;
29 |     use MustVerifyEmailTrait;
30 | 
31 |     /**
32 |      * Array of field names and the type of value to cast them as
33 |      * when they are accessed.
34 |      *
35 |      * @var array
36 |      */
37 |     protected $casts = [
38 |         'email_verified_at' => 'datetime',
39 |     ];
40 | 
41 |     /**
42 |      * Fill set password hash.
43 |      *
44 |      * @return $this
45 |      */
46 |     public function setPassword(string $password)
47 |     {
48 |         $this->attributes['password'] = Hash::make($password);
49 | 
50 |         return $this;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Filters/EmailVerifiedFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Filters;
 4 | 
 5 | use CodeIgniter\API\ResponseTrait;
 6 | use CodeIgniter\Config\Services;
 7 | use CodeIgniter\Filters\FilterInterface;
 8 | use CodeIgniter\HTTP\RequestInterface;
 9 | use CodeIgniter\HTTP\ResponseInterface;
10 | use Fluent\Auth\Contracts\VerifyEmailInterface;
11 | 
12 | use function auth;
13 | 
14 | class EmailVerifiedFilter implements FilterInterface
15 | {
16 |     use ResponseTrait;
17 | 
18 |     /** @var ResponseInterface */
19 |     protected $response;
20 | 
21 |     public function __construct()
22 |     {
23 |         $this->response = Services::response();
24 |     }
25 | 
26 |     /**
27 |      * {@inheritdoc}
28 |      */
29 |     public function before(RequestInterface $request, $arguments = null)
30 |     {
31 |         $user = auth()->user();
32 | 
33 |         if (
34 |             ! $user ||
35 |             ($user instanceof VerifyEmailInterface &&
36 |             ! $user->hasVerifiedEmail())
37 |         ) {
38 |             if ($request->isAjax()) {
39 |                 return $this->fail('Your email address is not verified', ResponseInterface::HTTP_FORBIDDEN);
40 |             }
41 | 
42 |             session()->set('intended', current_url());
43 | 
44 |             return redirect()->route('verification.notice')->with('error', 'Your email address is not verified');
45 |         }
46 |     }
47 | 
48 |     /**
49 |      * {@inheritdoc}
50 |      */
51 |     public function after(RequestInterface $request, ResponseInterface $response, $arguments = null)
52 |     {
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/Commands/AuthClearResetCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Commands;
 4 | 
 5 | use CodeIgniter\CLI\BaseCommand;
 6 | use CodeIgniter\CLI\CLI;
 7 | use Exception;
 8 | use Fluent\Auth\Config\Services;
 9 | 
10 | class AuthClearResetCommand extends BaseCommand
11 | {
12 |     /**
13 |      * The group the command is lumped under
14 |      * when listing commands.
15 |      *
16 |      * @var string
17 |      */
18 |     protected $group = 'Auth';
19 | 
20 |     /**
21 |      * The Command's name
22 |      *
23 |      * @var string
24 |      */
25 |     protected $name = 'auth:clear-reset';
26 | 
27 |     /**
28 |      * the Command's usage description
29 |      *
30 |      * @var string
31 |      */
32 |     protected $usage = 'auth:clear-reset';
33 | 
34 |     /**
35 |      * the Command's short description
36 |      *
37 |      * @var string
38 |      */
39 |     protected $description = 'Delete expired password reset tokens.';
40 | 
41 |     /**
42 |      * the Command's options description
43 |      *
44 |      * @var array
45 |      */
46 |     protected $options = [
47 |         '--name' => 'Password broker instance by name.',
48 |     ];
49 | 
50 |     /**
51 |      * {@inheritdoc}
52 |      */
53 |     public function run(array $params)
54 |     {
55 |         try {
56 |             Services::passwords()->broker(CLI::getOption('name'))->getRepository()->destroyExpired();
57 |         } catch (Exception $e) {
58 |             return CLI::error($e->getMessage());
59 |         }
60 | 
61 |         return CLI::write(CLI::color('Expired reset tokens cleared!', 'green'));
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/Traits/AuthorizableTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Traits;
 4 | 
 5 | use Fluent\Auth\Config\Services;
 6 | 
 7 | trait AuthorizableTrait
 8 | {
 9 |     /**
10 |      * Determine if the entity has the given abilities.
11 |      *
12 |      * @param  iterable|string  $abilities
13 |      * @param  array|mixed  $arguments
14 |      * @return bool
15 |      */
16 |     public function can($abilities, $arguments = [])
17 |     {
18 |         return Services::gate()->forUser($this)->check($abilities, $arguments);
19 |     }
20 | 
21 |     /**
22 |      * Determine if the entity has any of the given abilities.
23 |      *
24 |      * @param  iterable|string  $abilities
25 |      * @param  array|mixed  $arguments
26 |      * @return bool
27 |      */
28 |     public function canAny($abilities, $arguments = [])
29 |     {
30 |         return Services::gate()->forUser($this)->any($abilities, $arguments);
31 |     }
32 | 
33 |     /**
34 |      * Determine if the entity does not have the given abilities.
35 |      *
36 |      * @param  iterable|string  $abilities
37 |      * @param  array|mixed  $arguments
38 |      * @return bool
39 |      */
40 |     public function cant($abilities, $arguments = [])
41 |     {
42 |         return ! $this->can($abilities, $arguments);
43 |     }
44 | 
45 |     /**
46 |      * Determine if the entity does not have the given abilities.
47 |      *
48 |      * @param  iterable|string  $abilities
49 |      * @param  array|mixed  $arguments
50 |      * @return bool
51 |      */
52 |     public function cannot($abilities, $arguments = [])
53 |     {
54 |         return $this->cant($abilities, $arguments);
55 |     }
56 | }


--------------------------------------------------------------------------------
/src/Models/UserModel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Models;
 4 | 
 5 | use CodeIgniter\Model;
 6 | use Faker\Generator;
 7 | use Fluent\Auth\Contracts\UserProviderInterface;
 8 | use Fluent\Auth\Entities\User;
 9 | use Fluent\Auth\Traits\UserProviderTrait;
10 | 
11 | class UserModel extends Model implements UserProviderInterface
12 | {
13 |     use UserProviderTrait;
14 | 
15 |     /**
16 |      * Name of database table
17 |      *
18 |      * @var string
19 |      */
20 |     protected $table = 'users';
21 | 
22 |     /**
23 |      * The format that the results should be returned as.
24 |      * Will be overridden if the as* methods are used.
25 |      *
26 |      * @var User
27 |      */
28 |     protected $returnType = User::class;
29 | 
30 |     /**
31 |      * An array of field names that are allowed
32 |      * to be set by the user in inserts/updates.
33 |      *
34 |      * @var array
35 |      */
36 |     protected $allowedFields = [
37 |         'email',
38 |         'username',
39 |         'password',
40 |         'email_verified_at',
41 |         'remember_token',
42 |     ];
43 | 
44 |     /**
45 |      * If true, will set created_at, and updated_at
46 |      * values during insert and update routines.
47 |      *
48 |      * @var boolean
49 |      */
50 |     protected $useTimestamps = true;
51 | 
52 |     /**
53 |      * Generate fake data.
54 |      *
55 |      * @return array
56 |      */
57 |     public function fake(Generator &$faker)
58 |     {
59 |         return [
60 |             'email'    => $faker->email,
61 |             'username' => $faker->userName,
62 |             'password' => 'secret',
63 |         ];
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/Controllers/Auth/PasswordResetLinkController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Controllers\Auth;
 4 | 
 5 | use App\Controllers\BaseController;
 6 | use CodeIgniter\HTTP\RedirectResponse;
 7 | use CodeIgniter\View\RendererInterface;
 8 | use Fluent\Auth\Contracts\PasswordBrokerInterface;
 9 | use Fluent\Auth\Facades\Passwords;
10 | 
11 | class PasswordResetLinkController extends BaseController
12 | {
13 |     /**
14 |      * Display the password reset link request view.
15 |      *
16 |      * @return RendererInterface
17 |      */
18 |     public function new()
19 |     {
20 |         return view('Auth/forgot_password');
21 |     }
22 | 
23 |     /**
24 |      * Handle an incomming password reset link request.
25 |      *
26 |      * @return RedirectResponse
27 |      */
28 |     public function create()
29 |     {
30 |         $request = (object) $this->request->getPost();
31 | 
32 |         if (! $this->validate(['email' => 'required|valid_email'])) {
33 |             return redirect()->back()->withInput()->with('errors', $this->validator->getErrors());
34 |         }
35 | 
36 |         // We will send the password reset link to this user. Once we have attempted
37 |         // to send the link, we will examine the response then see the message we
38 |         // need to show to the user. Finally, we'll send out a proper response.
39 |         $status = Passwords::sendResetLink([
40 |             'email' => $request->email,
41 |         ]);
42 | 
43 |         return $status === PasswordBrokerInterface::RESET_LINK_SENT
44 |             ? redirect()->back()->with('message', lang($status))
45 |             : redirect()->back()->withInput()->with('error', lang($status));
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Contracts/UserProviderInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Contracts;
 4 | 
 5 | use CodeIgniter\Database\BaseBuilder;
 6 | use CodeIgniter\Model;
 7 | 
 8 | interface UserProviderInterface
 9 | {
10 |     /**
11 |      * Locates an identity object by ID.
12 |      *
13 |      * @param int|string $userId
14 |      * @return AuthenticatorInterface|HasAccessTokensInterface|null
15 |      */
16 |     public function findById($userId);
17 | 
18 |     /**
19 |      * Locate a user by the given credentials.
20 |      *
21 |      * @param array $credentials
22 |      * @return AuthenticatorInterface|HasAccessTokensInterface|null
23 |      */
24 |     public function findByCredentials(array $credentials);
25 | 
26 |     /**
27 |      * Find a user by their ID and "remember-me" token.
28 |      *
29 |      * @param int|string $userId
30 |      * @param string $token
31 |      * @return AuthenticatorInterface|HasAccessTokensInterface|null
32 |      */
33 |     public function findByRememberToken($userId, $token);
34 | 
35 |     /**
36 |      * Update the "remember me" token for the given user in storage.
37 |      *
38 |      * @param string $token
39 |      * @return mixed
40 |      */
41 |     public function updateRememberToken(AuthenticatorInterface $user, $token);
42 | 
43 |     /**
44 |      * Validate a user against the given credentials.
45 |      *
46 |      * @param array $credentials
47 |      * @return bool
48 |      */
49 |     public function validateCredentials(AuthenticatorInterface $user, array $credentials);
50 | 
51 |     /**
52 |      * Get instance class user provider.
53 |      *
54 |      * @return BaseBuilder|Model
55 |      */
56 |     public function instance();
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Filters/ConfirmPasswordFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Filters;
 4 | 
 5 | use CodeIgniter\API\ResponseTrait;
 6 | use CodeIgniter\Config\Services;
 7 | use CodeIgniter\Filters\FilterInterface;
 8 | use CodeIgniter\HTTP\RequestInterface;
 9 | use CodeIgniter\HTTP\ResponseInterface;
10 | 
11 | use function time;
12 | class ConfirmPasswordFilter implements FilterInterface
13 | {
14 |     use ResponseTrait;
15 | 
16 |     /** @var ResponseInterface */
17 |     protected $response;
18 | 
19 |     public function __construct()
20 |     {
21 |         $this->response = Services::response();
22 |     }
23 | 
24 |     /**
25 |      * {@inheritdoc}
26 |      */
27 |     public function before(RequestInterface $request, $arguments = null)
28 |     {
29 |         if ($this->shouldConfirmPassword()) {
30 |             if ($request->isAjax()) {
31 |                 return $this->fail('Password confirmation required.', ResponseInterface::HTTP_LOCKED);
32 |             }
33 | 
34 |             session()->set('intended', current_url());
35 | 
36 |             return redirect()->route('password.confirm')->with('error', 'Password confirmation required.');
37 |         }
38 |     }
39 | 
40 |     /**
41 |      * {@inheritdoc}
42 |      */
43 |     public function after(RequestInterface $request, ResponseInterface $response, $arguments = null)
44 |     {
45 |     }
46 | 
47 |     /**
48 |      * Determine if the confirmation timeout has expired.
49 |      *
50 |      * @return bool
51 |      */
52 |     protected function shouldConfirmPassword()
53 |     {
54 |         $confirmedAt = time() - session('password_confirmed_at');
55 | 
56 |         return $confirmedAt > config('Auth')->passwordTimeout;
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Exceptions/AuthorizationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Exceptions;
 4 | 
 5 | use Exception;
 6 | use Throwable;
 7 | use Fluent\Auth\Authorization\Response;
 8 | 
 9 | class AuthorizationException extends Exception
10 | {
11 |     /**
12 |      * The response from the gate.
13 |      *
14 |      * @var \Fluent\Auth\Authorization\Response
15 |      */
16 |     protected $response;
17 | 
18 |     /**
19 |      * Create a new authorization exception instance.
20 |      *
21 |      * @param  string|null  $message
22 |      * @param  mixed  $code
23 |      * @param  \Throwable|null  $previous
24 |      * @return void
25 |      */
26 |     public function __construct($message = null, $code = null, Throwable $previous = null)
27 |     {
28 |         parent::__construct($message ?? 'This action is unauthorized.', 0, $previous);
29 | 
30 |         $this->code = $code ?: 403;
31 |     }
32 | 
33 |     /**
34 |      * Get the response from the gate.
35 |      *
36 |      * @return \Fluent\Auth\Authorization\Response
37 |      */
38 |     public function response()
39 |     {
40 |         return $this->response;
41 |     }
42 | 
43 |     /**
44 |      * Set the response from the gate.
45 |      *
46 |      * @param  \Fluent\Auth\Authorization\Response  $response
47 |      * @return $this
48 |      */
49 |     public function setResponse($response)
50 |     {
51 |         $this->response = $response;
52 | 
53 |         return $this;
54 |     }
55 | 
56 |     /**
57 |      * Create a deny response object from this exception.
58 |      *
59 |      * @return \Fluent\Auth\Authorization\Response
60 |      */
61 |     public function toResponse()
62 |     {
63 |         return Response::deny($this->message, $this->code);
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/Models/AccessTokenModel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Models;
 4 | 
 5 | use CodeIgniter\Model;
 6 | use Faker\Generator;
 7 | use Fluent\Auth\Entities\AccessToken;
 8 | 
 9 | use function hash;
10 | 
11 | class AccessTokenModel extends Model
12 | {
13 |     /**
14 |      * Name of database table
15 |      *
16 |      * @var string
17 |      */
18 |     protected $table = 'auth_access_tokens';
19 | 
20 |     /**
21 |      * The format that the results should be returned as.
22 |      * Will be overridden if the as* methods are used.
23 |      *
24 |      * @var AccessToken
25 |      */
26 |     protected $returnType = AccessToken::class;
27 | 
28 |     /**
29 |      * An array of field names that are allowed
30 |      * to be set by the user in inserts/updates.
31 |      *
32 |      * @var array
33 |      */
34 |     protected $allowedFields = [
35 |         'user_id',
36 |         'name',
37 |         'token',
38 |         'last_used_at',
39 |         'scopes',
40 |     ];
41 | 
42 |     /**
43 |      * If true, will set created_at, and updated_at
44 |      * values during insert and update routines.
45 |      *
46 |      * @var boolean
47 |      */
48 |     protected $useTimestamps = true;
49 | 
50 |     /**
51 |      * Generate fake data.
52 |      *
53 |      * @return array
54 |      */
55 |     public function fake(Generator &$faker)
56 |     {
57 |         helper('text');
58 |         $rawToken = random_string('crypt', 64);
59 | 
60 |         return [
61 |             'user_id'   => fake(UserModel::class)->id,
62 |             'name'      => $faker->streetName,
63 |             'token'     => hash('sha256', $rawToken),
64 |             'raw_token' => $rawToken, // Only normally available on newly created record.
65 |         ];
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/Facades/Passwords.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Facades;
 4 | 
 5 | use Fluent\Auth\Config\Services;
 6 | use Fluent\Auth\Contracts\PasswordBrokerFactoryInterface;
 7 | use Fluent\Auth\Contracts\PasswordBrokerInterface;
 8 | use Fluent\Auth\Contracts\PasswordResetRepositoryInterface;
 9 | use Fluent\Auth\Contracts\ResetPasswordInterface;
10 | use Fluent\Auth\Contracts\VerifyEmailInterface;
11 | 
12 | /**
13 |  * @see \Fluent\Auth\Contracts\PasswordBrokerFactoryInterface
14 |  * @see \Fluent\Auth\Contracts\PasswordBrokerInterface
15 |  *
16 |  * @method static PasswordBrokerInterface broker($name = null)
17 |  * @method static string getDefaultDriver()
18 |  * @method static $this setDefaultDriver($name)
19 |  * @method static string sendResetLink(array $credentials, ?Closure $callback = null)
20 |  * @method static string sendVerifyLink(array $credentials, ?Closure $callback = null)
21 |  * @method static mixed reset(array $credentials, Closure $callback)
22 |  * @method static ResetPasswordInterface|VerifyEmailInterface|null getUser(array $credentials)
23 |  * @method static string createToken(ResetPasswordInterface $user)
24 |  * @method static void deleteToken(ResetPasswordInterface $user)
25 |  * @method static bool tokenExists(ResetPasswordInterface $user, $token)
26 |  * @method static PasswordResetRepositoryInterface getRepository()
27 |  */
28 | class Passwords
29 | {
30 |     /**
31 |      * Facade passwords instance service.
32 |      *
33 |      * @param string $method
34 |      * @param array $arguments
35 |      * @return PasswordBrokerFactoryInterface|PasswordBrokerInterface
36 |      */
37 |     public static function __callStatic($method, $arguments)
38 |     {
39 |         return Services::getSharedInstance('passwords')->{$method}(...$arguments);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Traits/InteractsWithTimeTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Traits;
 4 | 
 5 | use CodeIgniter\I18n\Time;
 6 | use DateInterval;
 7 | use DateTimeInterface;
 8 | 
 9 | use function max;
10 | 
11 | trait InteractsWithTimeTrait
12 | {
13 |     /**
14 |      * Get the number of seconds until the given DateTime.
15 |      *
16 |      * @param DateTimeInterface|DateInterval|int $delay
17 |      * @return int
18 |      */
19 |     protected function secondsUntil($delay)
20 |     {
21 |         $delay = $this->parseDateInterval($delay);
22 | 
23 |         return $delay instanceof DateTimeInterface
24 |             ? max(0, $delay->getTimestamp() - $this->currentTime())
25 |             : (int) $delay;
26 |     }
27 | 
28 |     /**
29 |      * Get the "available at" UNIX timestamp.
30 |      *
31 |      * @param DateTimeInterface|DateInterval|int $delay
32 |      * @return int
33 |      */
34 |     protected function availableAt($delay = 0)
35 |     {
36 |         $delay = $this->parseDateInterval($delay);
37 | 
38 |         return $delay instanceof DateTimeInterface
39 |             ? $delay->getTimestamp()
40 |             : Time::now()->addSeconds($delay)->getTimestamp();
41 |     }
42 | 
43 |     /**
44 |      * If the given value is an interval, convert it to a DateTime instance.
45 |      *
46 |      * @param DateTimeInterface|DateInterval|int $delay
47 |      * @return DateTimeInterface|int
48 |      */
49 |     protected function parseDateInterval($delay)
50 |     {
51 |         if ($delay instanceof DateInterval) {
52 |             $delay = Time::now()->add($delay);
53 |         }
54 | 
55 |         return $delay;
56 |     }
57 | 
58 |     /**
59 |      * Get the current system time as a UNIX timestamp.
60 |      *
61 |      * @return int
62 |      */
63 |     protected function currentTime()
64 |     {
65 |         return Time::now()->getTimestamp();
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/Controllers/Auth/VerifyEmailController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Controllers\Auth;
 4 | 
 5 | use App\Controllers\BaseController;
 6 | use CodeIgniter\Events\Events;
 7 | use CodeIgniter\HTTP\RedirectResponse;
 8 | use CodeIgniter\I18n\Time;
 9 | 
10 | use function auth;
11 | use function hash_equals;
12 | use function hash_hmac;
13 | use function sha1;
14 | 
15 | class VerifyEmailController extends BaseController
16 | {
17 |     /**
18 |      * Mark the authenticated users email addres as verified.
19 |      *
20 |      * @return RedirectResponse
21 |      */
22 |     public function index(string $hash)
23 |     {
24 |         // Check first if user email already verified
25 |         if (auth()->user()->hasVerifiedEmail()) {
26 |             return redirect()->to(session('intended') ?? config('Auth')->home);
27 |         }
28 | 
29 |         // Check if hash equal with current user email.
30 |         if (! hash_equals($hash, sha1(auth()->user()->email))) {
31 |             return redirect()->route('verification.notice')->with('error', lang('Passwords.token'));
32 |         }
33 | 
34 |         $signature = hash_hmac('sha256', auth()->user()->email, config('Encryption')->key);
35 | 
36 |         // Check signature key
37 |         if (! hash_equals($signature, $this->request->getVar('signature'))) {
38 |             return redirect()->route('verification.notice')->with('error', lang('Passwords.token'));
39 |         }
40 | 
41 |         // Check for token if expired
42 |         if ($this->request->getVar('expires') < Time::now()->getTimestamp()) {
43 |             return redirect()->route('verification.notice')->with('error', lang('Passwords.expired'));
44 |         }
45 | 
46 |         auth()->user()->markEmailAsVerified();
47 | 
48 |         Events::trigger('fireVerifiedUser', auth()->user());
49 | 
50 |         return redirect()->to(session('intended') ?? config('Auth')->home);
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Config/Hashing.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Config;
 4 | 
 5 | use CodeIgniter\Config\BaseConfig;
 6 | 
 7 | class Hashing extends BaseConfig
 8 | {
 9 |     /**
10 |      * --------------------------------------------------------------------------
11 |      * Default Hash Driver
12 |      * --------------------------------------------------------------------------
13 |      *
14 |      * This option controls the default hash driver that will be used to hash
15 |      * passwords for your application. By default, the bcrypt algorithm is
16 |      * used; however, you remain free to modify this option if you wish.
17 |      *
18 |      * Supported: "bcrypt", "argon", "argon2id"
19 |      *
20 |      * @var string
21 |      */
22 |     public $driver = 'bcrypt';
23 | 
24 |     /**
25 |      * --------------------------------------------------------------------------
26 |      * Bcrypt Options
27 |      * --------------------------------------------------------------------------
28 |      *
29 |      * Here you may specify the configuration options that should be used when
30 |      * passwords are hashed using the Bcrypt algorithm. This will allow you
31 |      * to control the amount of time it takes to hash the given password.
32 |      *
33 |      * @var array
34 |      */
35 |     public $bcrypt = [
36 |         'rounds' => 10,
37 |     ];
38 | 
39 |     /**
40 |      * --------------------------------------------------------------------------
41 |      * Argon Options
42 |      * --------------------------------------------------------------------------
43 |      *
44 |      * Here you may specify the configuration options that should be used when
45 |      * passwords are hashed using the Argon algorithm. These will allow you
46 |      * to control the amount of time it takes to hash the given password.
47 |      *
48 |      * @var array
49 |      */
50 |     public $argon = [
51 |         'memory'  => 1024,
52 |         'threads' => 2,
53 |         'time'    => 2,
54 |     ];
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Entities/AccessToken.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Entities;
 4 | 
 5 | use CodeIgniter\Entity;
 6 | 
 7 | use function auth;
 8 | use function in_array;
 9 | 
10 | class AccessToken extends Entity
11 | {
12 |     /**
13 |      * Array of field names and the type of value to cast them as
14 |      * when they are accessed.
15 |      *
16 |      * @var array
17 |      */
18 |     protected $casts = [
19 |         'last_used_at' => 'datetime',
20 |         'scopes'       => 'array',
21 |         'expires'      => 'datetime',
22 |     ];
23 | 
24 |     /**
25 |      * Returns the user associated with this token.
26 |      *
27 |      * @return mixed
28 |      */
29 |     public function user()
30 |     {
31 |         if (empty($this->attributes['user'])) {
32 |             $users                    = auth('token')->getProvider();
33 |             $this->attributes['user'] = $users->findById($this->user_id);
34 |         }
35 | 
36 |         return $this->attributes['user'];
37 |     }
38 | 
39 |     /**
40 |      * Determines whether this token grants
41 |      * permission to the $scope
42 |      */
43 |     public function can(string $scope): bool
44 |     {
45 |         if (empty($this->scopes)) {
46 |             return false;
47 |         }
48 | 
49 |         // Wildcard present
50 |         if (in_array('*', $this->scopes)) {
51 |             return true;
52 |         }
53 | 
54 |         // Check stored scopes
55 |         return in_array($scope, $this->scopes);
56 |     }
57 | 
58 |     /**
59 |      * Determines whether this token does NOT
60 |      * grant permission to $scope.
61 |      */
62 |     public function cant(string $scope): bool
63 |     {
64 |         if (empty($this->scopes)) {
65 |             return true;
66 |         }
67 | 
68 |         // Wildcard present
69 |         if (in_array('*', $this->scopes)) {
70 |             return false;
71 |         }
72 | 
73 |         // Check stored scopes
74 |         return ! in_array($scope, $this->scopes);
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/Traits/AuthenticatableTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Traits;
 4 | 
 5 | trait AuthenticatableTrait
 6 | {
 7 |     /**
 8 |      * Returns the name of the column used to uniquely
 9 |      * identify this user, typically 'id'.
10 |      */
11 |     public function getAuthIdColumn(): string
12 |     {
13 |         return 'id';
14 |     }
15 | 
16 |     /**
17 |      * Returns the unique identifier of the object for
18 |      * authentication purposes. Typically user's id.
19 |      *
20 |      * @return mixed
21 |      */
22 |     public function getAuthId()
23 |     {
24 |         return $this->attributes[$this->getAuthIdColumn()] ?? null;
25 |     }
26 | 
27 |     /**
28 |      * Returns the name of the column with the
29 |      * email address of this user.
30 |      */
31 |     public function getAuthEmailColumn(): string
32 |     {
33 |         return 'email';
34 |     }
35 | 
36 |     /**
37 |      * Returns the email address for this user.
38 |      *
39 |      * @return string|null
40 |      */
41 |     public function getAuthEmail()
42 |     {
43 |         return $this->attributes[$this->getAuthEmailColumn()] ?? null;
44 |     }
45 | 
46 |     /**
47 |      * Get the password for the user.
48 |      *
49 |      * @return string|null
50 |      */
51 |     public function getAuthPassword()
52 |     {
53 |         return $this->password;
54 |     }
55 | 
56 |     /**
57 |      * Returns the "remember me" token for this user.
58 |      *
59 |      * @return string|null
60 |      */
61 |     public function getRememberToken()
62 |     {
63 |         $column = $this->getRememberColumn();
64 | 
65 |         // fix me sometime getter is not retrived.
66 |         return $this->attributes[$column] ?? $this->{$column} ?? null;
67 |     }
68 | 
69 |     /**
70 |      * Sets the "remmeber me" token.
71 |      *
72 |      * @return self
73 |      */
74 |     public function setRememberToken(string $value)
75 |     {
76 |         $this->attributes[$this->getRememberColumn()] = $value;
77 | 
78 |         return $this;
79 |     }
80 | 
81 |     /**
82 |      * Returns the column name that stores the remember-me value.
83 |      */
84 |     public function getRememberColumn(): string
85 |     {
86 |         return 'remember_token';
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/src/CookieRecaller.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth;
 4 | 
 5 | use Fluent\Auth\Helpers\Str;
 6 | 
 7 | use function count;
 8 | use function explode;
 9 | use function is_string;
10 | use function trim;
11 | use function unserialize;
12 | 
13 | class CookieRecaller
14 | {
15 |     /**
16 |      * The "recaller" / "remember me" cookie string.
17 |      *
18 |      * @var string
19 |      */
20 |     protected $recaller;
21 | 
22 |     /**
23 |      * Create a new recaller instance.
24 |      *
25 |      * @param  string  $recaller
26 |      * @return void
27 |      */
28 |     public function __construct($recaller)
29 |     {
30 |         $this->recaller = @unserialize($recaller, ['allowed_classes' => false]) ?: $recaller;
31 |     }
32 | 
33 |     /**
34 |      * Get the user ID from the recaller.
35 |      *
36 |      * @return string
37 |      */
38 |     public function id()
39 |     {
40 |         return explode('|', $this->recaller, 3)[0];
41 |     }
42 | 
43 |     /**
44 |      * Get the "remember token" token from the recaller.
45 |      *
46 |      * @return string
47 |      */
48 |     public function token()
49 |     {
50 |         return explode('|', $this->recaller, 3)[1];
51 |     }
52 | 
53 |     /**
54 |      * Get the password from the recaller.
55 |      *
56 |      * @return string
57 |      */
58 |     public function hash()
59 |     {
60 |         return explode('|', $this->recaller, 3)[2];
61 |     }
62 | 
63 |     /**
64 |      * Determine if the recaller is valid.
65 |      *
66 |      * @return bool
67 |      */
68 |     public function valid()
69 |     {
70 |         return $this->properString() && $this->hasAllSegments();
71 |     }
72 | 
73 |     /**
74 |      * Determine if the recaller is an invalid string.
75 |      *
76 |      * @return bool
77 |      */
78 |     protected function properString()
79 |     {
80 |         return is_string($this->recaller) && Str::contains($this->recaller, '|');
81 |     }
82 | 
83 |     /**
84 |      * Determine if the recaller has all segments.
85 |      *
86 |      * @return bool
87 |      */
88 |     protected function hasAllSegments()
89 |     {
90 |         $segments = explode('|', $this->recaller);
91 | 
92 |         return count($segments) === 3 && trim($segments[0]) !== '' && trim($segments[1]) !== '';
93 |     }
94 | }
95 | 


--------------------------------------------------------------------------------
/src/Traits/GuardHelperTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Traits;
 4 | 
 5 | use CodeIgniter\Events\Events;
 6 | use Fluent\Auth\Contracts\AuthenticatorInterface;
 7 | use Fluent\Auth\Contracts\AuthorizableInterface;
 8 | use Fluent\Auth\Contracts\HasAccessTokensInterface;
 9 | use Fluent\Auth\Contracts\ResetPasswordInterface;
10 | use Fluent\Auth\Contracts\UserProviderInterface;
11 | use Fluent\Auth\Contracts\VerifyEmailInterface;
12 | use Fluent\Auth\Exceptions\AuthenticationException;
13 | 
14 | use function is_null;
15 | 
16 | trait GuardHelperTrait
17 | {
18 |     /** @var UserProviderInterface */
19 |     protected $provider;
20 | 
21 |     /** @var AuthenticatorInterface|AuthorizableInterface|ResetPasswordInterface|VerifyEmailInterface|HasAccessTokensInterface */
22 |     protected $user;
23 | 
24 |     /**
25 |      * {@inheritdoc}
26 |      */
27 |     public function authenticate()
28 |     {
29 |         if (! is_null($user = $this->user())) {
30 |             return $user;
31 |         }
32 | 
33 |         throw new AuthenticationException();
34 |     }
35 | 
36 |     /**
37 |      * {@inheritdoc}
38 |      */
39 |     public function hasUser(): bool
40 |     {
41 |         return ! is_null($this->user);
42 |     }
43 | 
44 |     /**
45 |      * {@inheritdoc}
46 |      */
47 |     public function check(): bool
48 |     {
49 |         return ! is_null($this->user());
50 |     }
51 | 
52 |     /**
53 |      * {@inheritdoc}
54 |      */
55 |     public function id()
56 |     {
57 |         if ($this->user()) {
58 |             return $this->user()->getAuthId();
59 |         }
60 | 
61 |         return null;
62 |     }
63 | 
64 |     /**
65 |      * {@inheritdoc}
66 |      */
67 |     public function setUser(AuthenticatorInterface $user)
68 |     {
69 |         $this->user = $user;
70 | 
71 |         $this->loggedOut = false;
72 | 
73 |         Events::trigger('fireAuthenticatedEvent', $user);
74 | 
75 |         return $this;
76 |     }
77 | 
78 |     /**
79 |      * {@inheritdoc}
80 |      */
81 |     public function getProvider()
82 |     {
83 |         return $this->provider;
84 |     }
85 | 
86 |     /**
87 |      * {@inheritdoc}
88 |      */
89 |     public function setProvider(UserProviderInterface $provider)
90 |     {
91 |         $this->provider = $provider;
92 | 
93 |         return $this;
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/src/Helpers/Arr.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Helpers;
 4 | 
 5 | use ArrayAccess;
 6 | 
 7 | use function array_key_exists;
 8 | use function array_shift;
 9 | use function count;
10 | use function explode;
11 | use function is_array;
12 | 
13 | class Arr
14 | {
15 |     /**
16 |      * Determine if the given key exists in the provided array.
17 |      *
18 |      * @param ArrayAccess|array $array
19 |      * @param  string|int  $key
20 |      * @return bool
21 |      */
22 |     public static function exists($array, $key)
23 |     {
24 |         if ($array instanceof ArrayAccess) {
25 |             return $array->offsetExists($key);
26 |         }
27 | 
28 |         return array_key_exists($key, $array);
29 |     }
30 | 
31 |     /**
32 |      * Remove one or many array items from a given array using "dot" notation.
33 |      *
34 |      * @param  array  $array
35 |      * @param  array|string  $keys
36 |      * @return void
37 |      */
38 |     public static function forget(&$array, $keys)
39 |     {
40 |         $original = &$array;
41 | 
42 |         $keys = (array) $keys;
43 | 
44 |         if (count($keys) === 0) {
45 |             return;
46 |         }
47 | 
48 |         foreach ($keys as $key) {
49 |             // if the exact key exists in the top-level, remove it
50 |             if (static::exists($array, $key)) {
51 |                 unset($array[$key]);
52 | 
53 |                 continue;
54 |             }
55 | 
56 |             $parts = explode('.', $key);
57 | 
58 |             // clean up before each pass
59 |             $array = &$original;
60 | 
61 |             while (count($parts) > 1) {
62 |                 $part = array_shift($parts);
63 | 
64 |                 if (isset($array[$part]) && is_array($array[$part])) {
65 |                     $array = &$array[$part];
66 |                 } else {
67 |                     continue 2;
68 |                 }
69 |             }
70 | 
71 |             unset($array[array_shift($parts)]);
72 |         }
73 |     }
74 | 
75 |     /**
76 |      * Get all of the given array except for a specified array of keys.
77 |      *
78 |      * @param  array  $array
79 |      * @param  array|string  $keys
80 |      * @return array
81 |      */
82 |     public static function except($array, $keys)
83 |     {
84 |         static::forget($array, $keys);
85 | 
86 |         return $array;
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/src/Contracts/HasAccessTokensInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Contracts;
 4 | 
 5 | use Fluent\Auth\Entities\AccessToken;
 6 | 
 7 | interface HasAccessTokensInterface
 8 | {
 9 |     /**
10 |      * Generates a new personal access token for this user.
11 |      *
12 |      * @param array $scopes
13 |      * @return object
14 |      */
15 |     public function generateAccessToken(string $name, array $scopes = ['*']);
16 | 
17 |     /**
18 |      * Given the token, will retrieve the token to
19 |      * verify it exists, then delete it.
20 |      *
21 |      * @return mixed
22 |      */
23 |     public function revokeAccessToken(string $token);
24 | 
25 |     /**
26 |      * Revokes all access tokens for this user.
27 |      *
28 |      * @return mixed
29 |      */
30 |     public function revokeAllAccessTokens();
31 | 
32 |     /**
33 |      * Retrieves all personal access tokens for this user.
34 |      *
35 |      * @return array
36 |      */
37 |     public function accessTokens(): array;
38 | 
39 |     /**
40 |      * Given a raw token, will hash it and attemp to
41 |      * locate it within the system.
42 |      *
43 |      * @return AccessToken|null
44 |      */
45 |     public function getAccessToken(?string $token);
46 | 
47 |     /**
48 |      * Given the ID, returns the given access token.
49 |      *
50 |      * @return AccessToken|null
51 |      */
52 |     public function getAccessTokenById(int $id);
53 | 
54 |     /**
55 |      * Determines whether the user's token grants permissions to $scope.
56 |      * First checks against $this->activeToken, which is set during
57 |      * authentication. If it hasn't been set, returns false.
58 |      */
59 |     public function tokenCan(string $scope): bool;
60 | 
61 |     /**
62 |      * Determines whether the user's token does NOT grant permissions to $scope.
63 |      * First checks against $this->activeToken, which is set during
64 |      * authentication. If it hasn't been set, returns true.
65 |      */
66 |     public function tokenCant(string $scope): bool;
67 | 
68 |     /**
69 |      * Returns the current access token for the user.
70 |      *
71 |      * @return AccessToken
72 |      */
73 |     public function currentAccessToken();
74 | 
75 |     /**
76 |      * Sets the current active token for this user.
77 |      *
78 |      * @return $this
79 |      */
80 |     public function withAccessToken(?AccessToken $accessToken);
81 | }
82 | 


--------------------------------------------------------------------------------
/src/Facades/Gate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Facades;
 4 | 
 5 | use Fluent\Auth\Config\Services;
 6 | 
 7 | /**
 8 |  * @method static \Fluent\Auth\Authorization\Gate guessPolicyNamesUsing(callable $callback)
 9 |  * @method static mixed resolvePolicy(string $class)
10 |  * @method static \Fluent\Auth\Authorization\Response authorize(string $ability, array|mixed $arguments = [])
11 |  * @method static \Fluent\Auth\Authorization\Response inspect(string $ability, array|mixed $arguments = [])
12 |  * @method static \Fluent\Auth\Authorization\Response allowIf(\Closure|bool $condition, string|null $message = null, mixed $code = null)
13 |  * @method static \Fluent\Auth\Authorization\Response denyIf(\Closure|bool $condition, string|null $message = null, mixed $code = null)
14 |  * @method static \Fluent\Auth\Contracts\GateInterface after(callable $callback)
15 |  * @method static \Fluent\Auth\Contracts\GateInterface before(callable $callback)
16 |  * @method static \Fluent\Auth\Contracts\GateInterface define(string $ability, callable|string $callback)
17 |  * @method static \Fluent\Auth\Contracts\GateInterface resource(string $name, string $class, array $abilities = null)
18 |  * @method static \Fluent\Auth\Contracts\GateInterface forUser(\Illuminate\Contracts\Auth\Authenticatable|mixed $user)
19 |  * @method static \Fluent\Auth\Contracts\GateInterface policy(string $class, string $policy)
20 |  * @method static array abilities()
21 |  * @method static array policies()
22 |  * @method static bool allows(string $ability, array|mixed $arguments = [])
23 |  * @method static bool any(iterable|string $abilities, array|mixed $arguments = [])
24 |  * @method static bool check(iterable|string $abilities, array|mixed $arguments = [])
25 |  * @method static bool denies(string $ability, array|mixed $arguments = [])
26 |  * @method static bool has(string $ability)
27 |  * @method static mixed getPolicyFor(object|string $class)
28 |  * @method static mixed raw(string $ability, array|mixed $arguments = [])
29 |  *
30 |  * @see \Fluent\Auth\Contracts\GateInterface
31 |  */
32 | class Gate
33 | {
34 |     /**
35 |      * Get the registered name of the component.
36 |      *
37 |      * @param string $method
38 |      * @param array $arguments
39 |      * @return GateInterface
40 |      */
41 |     public static function __callStatic($method, $arguments)
42 |     {
43 |         return Services::getSharedInstance('gate')->{$method}(...$arguments);
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Views/Auth/forgot_password.php:
--------------------------------------------------------------------------------
 1 | <?= $this->extend('Auth/layout') ?>
 2 | 
 3 | <?= $this->section('content') ?>
 4 | <section class="vh-lg-100 mt-5 mt-lg-0 bg-soft d-flex align-items-center">
 5 |     <div class="container">
 6 |         <div class="row justify-content-center form-bg-image">
 7 |             <p class="text-center"><a href="<?= route_to('login') ?>" class="d-flex align-items-center justify-content-center">
 8 |                     <svg class="icon icon-xs me-2" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
 9 |                         <path fill-rule="evenodd" d="M7.707 14.707a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414l4-4a1 1 0 011.414 1.414L5.414 9H17a1 1 0 110 2H5.414l2.293 2.293a1 1 0 010 1.414z" clip-rule="evenodd"></path>
10 |                     </svg>
11 |                     Back to log in
12 |                 </a>
13 |             </p>
14 |             <div class="col-12 d-flex align-items-center justify-content-center">
15 |                 <div class="signin-inner my-3 my-lg-0 bg-white shadow border-0 rounded p-4 p-lg-5 w-100 fmxw-500">
16 |                     <div class="text-center text-md-center mb-4 mt-md-0">
17 |                         <h1 class="mb-0 h3">Forgot your password?</h1>
18 |                     </div>
19 |                     <!-- Validation Errors and Message -->
20 |                     <?= $this->include('Auth/messages') ?>
21 |                     <p class="mb-4">Don't fret! Just type in your email and we will send you a code to reset your password!</p>
22 |                     <form method="post" action="<?= route_to('password.email') ?>">
23 |                         <?= csrf_field() ?>
24 |                         <!-- Form -->
25 |                         <div class="mb-4">
26 |                             <label for="email">Your Email</label>
27 |                             <div class="input-group">
28 |                                 <input type="email" value="<?= old('email') ?>" name="email" class="form-control" id="email" placeholder="john@company.com" required autofocus>
29 |                             </div>
30 |                         </div>
31 |                         <!-- End of Form -->
32 |                         <div class="d-grid">
33 |                             <button type="submit" class="btn btn-gray-800">Recover password</button>
34 |                         </div>
35 |                     </form>
36 |                 </div>
37 |             </div>
38 |         </div>
39 |     </div>
40 | </section>
41 | <?= $this->endSection() ?>


--------------------------------------------------------------------------------
/src/Views/Auth/verify_email.php:
--------------------------------------------------------------------------------
 1 | <?= $this->extend('Auth/layout') ?>
 2 | 
 3 | <?= $this->section('content') ?>
 4 | <section class="vh-lg-100 mt-5 mt-lg-0 bg-soft d-flex align-items-center">
 5 |     <div class="container">
 6 |         <div class="row justify-content-center form-bg-image">
 7 |             <p class="text-center"><a href="/" class="d-flex align-items-center justify-content-center">
 8 |                     <svg class="icon icon-xs me-2" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
 9 |                         <path fill-rule="evenodd" d="M7.707 14.707a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414l4-4a1 1 0 011.414 1.414L5.414 9H17a1 1 0 110 2H5.414l2.293 2.293a1 1 0 010 1.414z" clip-rule="evenodd"></path>
10 |                     </svg>
11 |                     Back to homepage
12 |                 </a>
13 |             </p>
14 |             <div class="col-12 d-flex align-items-center justify-content-center">
15 |                 <div class="signin-inner my-3 my-lg-0 bg-white shadow border-0 rounded p-4 p-lg-5 w-100 fmxw-500">
16 |                     <div class="text-center text-md-center mb-4 mt-md-0">
17 |                         <h1 class="mb-0 h3">Verification Account</h1>
18 |                     </div>
19 |                     <!-- Validation Errors and Message -->
20 |                     <?= $this->include('Auth/messages') ?>
21 |                         <p class="mb-4">
22 |                             Thanks for signing up! Before getting started, could you verify your email address by clicking on
23 |                             the link we just emailed to you? If you didn&#039;t receive the email, we will gladly send you
24 |                             another.
25 |                         </p>
26 |                     <form method="post" action="<?= route_to('verification.send') ?>">
27 |                         <?= csrf_field() ?>
28 |                         <div class="d-grid">
29 |                             <button type="submit" class="btn btn-gray-800">Resend Verification Email</button>
30 |                         </div>
31 |                     </form>
32 |                     <form method="post" action="<?= route_to('logout') ?>" class="mt-4">
33 |                         <?= csrf_field() ?>
34 |                         <div class="d-grid">
35 |                             <button type="submit" class="btn btn-gray-800">Logout</button>
36 |                         </div>
37 |                     </form>
38 |                 </div>
39 |             </div>
40 |         </div>
41 |     </div>
42 | </section>
43 | <?= $this->endSection() ?>


--------------------------------------------------------------------------------
/src/Filters/AuthorizeFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Filters;
 4 | 
 5 | use CodeIgniter\Model;
 6 | use Fluent\Auth\Config\Services;
 7 | use CodeIgniter\HTTP\RequestInterface;
 8 | use CodeIgniter\HTTP\ResponseInterface;
 9 | use CodeIgniter\Filters\FilterInterface;
10 | 
11 | class AuthorizeFilter implements FilterInterface
12 | {
13 |     /**
14 |      * The gate instance.
15 |      *
16 |      * @var \Fluent\Auth\Contracts\GateInterface
17 |      */
18 |     protected $gate;
19 | 
20 |     /**
21 |      * Create a new filter instance.
22 |      *
23 |      * @return void
24 |      */
25 |     public function __construct()
26 |     {
27 |         $this->gate = Services::gate();
28 |     }
29 | 
30 |     /**
31 |      * {@inheritdoc}
32 |      * 
33 |      * @throws \Fluent\Auth\Exceptions\AuthenticationException
34 |      * @throws \Fluent\Auth\Exceptions\AuthorizationException
35 |      */
36 |     public function before(RequestInterface $request, $arguments = null)
37 |     {
38 |         [$ability] = $arguments;
39 | 
40 |         $this->gate->authorize($ability, $this->getGateArguments(isset($arguments[1]) ? $arguments[1] : null));
41 | 
42 |         return $request;
43 |     }
44 | 
45 |     /**
46 |      * {@inheritdoc}
47 |      */
48 |     public function after(RequestInterface $request, ResponseInterface $response, $arguments = null)
49 |     { 
50 |     }
51 | 
52 |     /**
53 |      * Get the arguments parameter for the gate.
54 |      *
55 |      * @param  array|null  $models
56 |      * @return \CodeIgniter\Model|array|string
57 |      */
58 |     protected function getGateArguments($models)
59 |     {
60 |         if (is_null($models)) {
61 |             return [];
62 |         }
63 | 
64 |         return collect($models)->map(function ($model) {
65 |             return $model instanceof Model ? $model : $this->getModel($model);
66 |         })->all();
67 |     }
68 | 
69 |     /**
70 |      * Get the model to authorize.
71 |      *
72 |      * @param  string  $model
73 |      * @return \CodeIgniter\Model|string
74 |      */
75 |     protected function getModel($model)
76 |     {
77 |         if ($this->isClassName($model)) {
78 |             return trim($model);
79 |         } else {
80 |             return ((preg_match("/^['\"](.*)['\"]$/", trim($model), $matches)) ? $matches[1] : null);
81 |         }
82 |     }
83 | 
84 |     /**
85 |      * Checks if the given string looks like a fully qualified class name.
86 |      *
87 |      * @param  string  $value
88 |      * @return bool
89 |      */
90 |     protected function isClassName($value)
91 |     {
92 |         return strpos($value, '\\') !== false;
93 |     }
94 | }
95 | 


--------------------------------------------------------------------------------
/src/Controllers/Auth/RegisteredUserController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Controllers\Auth;
 4 | 
 5 | use App\Controllers\BaseController;
 6 | use CodeIgniter\Events\Events;
 7 | use CodeIgniter\HTTP\RedirectResponse;
 8 | use CodeIgniter\View\RendererInterface;
 9 | use Fluent\Auth\Contracts\AuthenticatorInterface;
10 | use Fluent\Auth\Contracts\VerifyEmailInterface;
11 | use Fluent\Auth\Entities\User;
12 | use Fluent\Auth\Facades\Auth;
13 | use Fluent\Auth\Models\UserModel;
14 | 
15 | class RegisteredUserController extends BaseController
16 | {
17 |     /**
18 |      * Display the registration view.
19 |      *
20 |      * @return RendererInterface
21 |      */
22 |     public function new()
23 |     {
24 |         return view('Auth/register');
25 |     }
26 | 
27 |     /**
28 |      * Handle an incoming registration request.
29 |      *
30 |      * @return RedirectResponse
31 |      */
32 |     public function create()
33 |     {
34 |         $request = (object) $this->request->getPost();
35 | 
36 |         if (! $this->validate(static::rules())) {
37 |             return redirect()->back()->withInput()->with('errors', $this->validator->getErrors());
38 |         }
39 | 
40 |         $user = static::createUser($request);
41 | 
42 |         Auth::login($user);
43 | 
44 |         // Automatic trigger send verify email if user
45 |         // instanceof VerifyEmailInterface.
46 |         if ($user instanceof VerifyEmailInterface) {
47 |             Events::trigger(VerifyEmailInterface::class, $user->email);
48 |         }
49 | 
50 |         return redirect(config('Auth')->home);
51 |     }
52 | 
53 |     /**
54 |      * Rules for validation.
55 |      *
56 |      * @return array
57 |      */
58 |     protected static function rules()
59 |     {
60 |         return [
61 |             'username'              => 'required|alpha_numeric_space|min_length[3]|is_unique[users.username]',
62 |             'email'                 => 'required|valid_email|is_unique[users.email]',
63 |             'password'              => 'required|min_length[8]',
64 |             'password_confirmation' => 'matches[password]',
65 |         ];
66 |     }
67 | 
68 |     /**
69 |      * Generate user registration.
70 |      *
71 |      * @param object $request
72 |      * @return AuthenticatorInterface
73 |      */
74 |     protected static function createUser($request)
75 |     {
76 |         $user = new UserModel();
77 |         $id   = $user->insert(new User([
78 |             'username' => $request->username,
79 |             'email'    => $request->email,
80 |             'password' => $request->password,
81 |         ]));
82 | 
83 |         return $user->find($id);
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/src/Filters/ThrottleFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Filters;
 4 | 
 5 | use CodeIgniter\API\ResponseTrait;
 6 | use CodeIgniter\Config\Services;
 7 | use CodeIgniter\Filters\FilterInterface;
 8 | use CodeIgniter\HTTP\RequestInterface;
 9 | use CodeIgniter\HTTP\Response;
10 | use CodeIgniter\HTTP\ResponseInterface;
11 | use Fluent\Auth\Facades\RateLimiter;
12 | 
13 | use function array_values;
14 | 
15 | class ThrottleFilter implements FilterInterface
16 | {
17 |     use ResponseTrait;
18 | 
19 |     /** @var Response */
20 |     protected $response;
21 | 
22 |     public function __construct()
23 |     {
24 |         $this->response = Services::response();
25 |     }
26 | 
27 |     /**
28 |      * {@inheritdoc}
29 |      */
30 |     public function before(RequestInterface $request, $arguments = null)
31 |     {
32 |         if ($this->tooManyAttempts($request, $arguments)) {
33 |             $seconds = RateLimiter::availableIn($this->throttleKey($request));
34 | 
35 |             if ($request->isAJAX()) {
36 |                 return $this->fail(lang('Auth.throttle', [$seconds]));
37 |             }
38 | 
39 |             return redirect()->back()->with('error', lang('Auth.throttler', [$this->maxAttempt($arguments), $seconds]));
40 |         }
41 | 
42 |         RateLimiter::hit($this->throttleKey($request), $this->decaySecond($arguments));
43 |     }
44 | 
45 |     /**
46 |      * {@inheritdoc}
47 |      */
48 |     public function after(RequestInterface $request, ResponseInterface $response, $arguments = null)
49 |     {
50 |     }
51 | 
52 |     /**
53 |      * Determine if the given key has been "accessed" too many times.
54 |      *
55 |      * @return bool
56 |      */
57 |     protected function tooManyAttempts(RequestInterface $request, array $arguments)
58 |     {
59 |         return RateLimiter::tooManyAttempts($this->throttleKey($request), $this->maxAttempt($arguments));
60 |     }
61 | 
62 |     /**
63 |      * Get the number of attempts for the given key.
64 |      *
65 |      * @return int
66 |      */
67 |     protected function maxAttempt(array $arguments)
68 |     {
69 |         return (int) array_values($arguments)[1];
70 |     }
71 | 
72 |     /**
73 |      * Get the decay second for the given key.
74 |      *
75 |      * @return int
76 |      */
77 |     protected function decaySecond(array $arguments)
78 |     {
79 |         return (int) array_values($arguments)[0];
80 |     }
81 | 
82 |     /**
83 |      * Get the rate limiting throttle key for the request.
84 |      *
85 |      * @return string
86 |      */
87 |     public function throttleKey(RequestInterface $request)
88 |     {
89 |         return 'throttle_' . md5(auth()->user()->email . "|{$request->getIPAddress()}");
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/src/Contracts/AuthFactoryInterface.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Contracts;
  4 | 
  5 | use Closure;
  6 | use CodeIgniter\Router\RouteCollection;
  7 | 
  8 | interface AuthFactoryInterface
  9 | {
 10 |     /**
 11 |      * Create the user provider implementation for the driver.
 12 |      *
 13 |      * @param  string|null  $provider
 14 |      * @return UserProviderInterface
 15 |      * @throws InvalidArgumentException
 16 |      */
 17 |     public function createUserProvider($provider = null);
 18 | 
 19 |     /**
 20 |      * Get the default user provider name.
 21 |      *
 22 |      * @return string
 23 |      */
 24 |     public function getDefaultUserProvider();
 25 | 
 26 |     /**
 27 |      * Attempt to get the guard from the local cache.
 28 |      *
 29 |      * @param  string|null  $name
 30 |      * @return AuthenticationBasicInterface|AuthenticationInterface
 31 |      */
 32 |     public function guard($name = null);
 33 | 
 34 |     /**
 35 |      * Set the default guard the factory should serve.
 36 |      *
 37 |      * @param  string  $name
 38 |      * @return void
 39 |      */
 40 |     public function shouldUse($name);
 41 | 
 42 |     /**
 43 |      * Get the default authentication driver name.
 44 |      *
 45 |      * @return string
 46 |      */
 47 |     public function getDefaultDriver();
 48 | 
 49 |     /**
 50 |      * Set the default authentication driver name.
 51 |      *
 52 |      * @param  string  $name
 53 |      * @return $this
 54 |      */
 55 |     public function setDefaultDriver($name);
 56 | 
 57 |     /**
 58 |      * Get the user resolver callback.
 59 |      *
 60 |      * @return Closure
 61 |      */
 62 |     public function userResolver();
 63 | 
 64 |     /**
 65 |      * Set the callback to be used to resolve users.
 66 |      *
 67 |      * @return $this
 68 |      */
 69 |     public function resolveUsersUsing(Closure $callback);
 70 | 
 71 |     /**
 72 |      * Register a custom driver creator Closure.
 73 |      *
 74 |      * @param  string  $driver
 75 |      * @return $this
 76 |      */
 77 |     public function extend($driver, Closure $callback);
 78 | 
 79 |     /**
 80 |      * Register a custom provider creator Closure.
 81 |      *
 82 |      * @param  string  $name
 83 |      * @return $this
 84 |      */
 85 |     public function provider($name, Closure $callback);
 86 | 
 87 |     /**
 88 |      * Determines if any guards have already been resolved.
 89 |      *
 90 |      * @return bool
 91 |      */
 92 |     public function hasResolvedGuards();
 93 | 
 94 |     /**
 95 |      * Auth routes for authentication users.
 96 |      *
 97 |      * @return RouteCollection
 98 |      */
 99 |     public function routes(array $options = []);
100 | }
101 | 


--------------------------------------------------------------------------------
/src/Config/Services.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Config;
 4 | 
 5 | use CodeIgniter\Config\BaseService;
 6 | use CodeIgniter\Config\Factories;
 7 | use Fluent\Auth\AuthManager;
 8 | use Fluent\Auth\Authorization\Gate;
 9 | use Fluent\Auth\Contracts\AuthenticationInterface;
10 | use Fluent\Auth\Contracts\AuthFactoryInterface;
11 | use Fluent\Auth\Contracts\HasherInterface;
12 | use Fluent\Auth\Contracts\PasswordBrokerFactoryInterface;
13 | use Fluent\Auth\Contracts\PasswordBrokerInterface;
14 | use Fluent\Auth\Passwords\Hash\AbstractManager;
15 | use Fluent\Auth\Passwords\Hash\HashManager;
16 | use Fluent\Auth\Passwords\PasswordBrokerManager;
17 | use Fluent\Auth\Passwords\RateLimiter;
18 | 
19 | class Services extends BaseService
20 | {
21 |     /**
22 |      * The base auth class.
23 |      *
24 |      * @return AuthFactoryInterface|AuthenticationInterface
25 |      */
26 |     public static function auth(bool $getShared = true)
27 |     {
28 |         if ($getShared) {
29 |             return self::getSharedInstance('auth');
30 |         }
31 | 
32 |         return new AuthManager(new Factories(), $getShared);
33 |     }
34 | 
35 |     /**
36 |      * Register the access gate service.
37 |      *
38 |      * @return Gate
39 |      */
40 |     public static function gate(bool $getShared = true)
41 |     {
42 |         if ($getShared) {
43 |             return self::getSharedInstance('gate');
44 |         }
45 | 
46 |         return new Gate(function () {
47 |             return call_user_func(auth()->userResolver());
48 |         });
49 |     }
50 | 
51 |     /**
52 |      * Passwords broker services.
53 |      *
54 |      * @return PasswordBrokerFactoryInterface|PasswordBrokerInterface
55 |      */
56 |     public static function passwords(bool $getShared = true)
57 |     {
58 |         if ($getShared) {
59 |             return self::getSharedInstance('passwords');
60 |         }
61 | 
62 |         return new PasswordBrokerManager(new Factories(), $getShared);
63 |     }
64 | 
65 |     /**
66 |      * Create HashManager instance.
67 |      *
68 |      * @return AbstractManager|HashManager|HasherInterface
69 |      */
70 |     public static function hash(bool $getShared = true)
71 |     {
72 |         if ($getShared) {
73 |             return self::getSharedInstance('hash');
74 |         }
75 | 
76 |         return new HashManager(new Factories(), $getShared);
77 |     }
78 | 
79 |     /**
80 |      * Create a new rate limiter instance.
81 |      *
82 |      * @return RateLimiter
83 |      */
84 |     public static function limiter(bool $getShared = true)
85 |     {
86 |         if ($getShared) {
87 |             return self::getSharedInstance('limiter');
88 |         }
89 | 
90 |         return new RateLimiter();
91 |     }
92 | }
93 | 


--------------------------------------------------------------------------------
/src/Collectors/AuthCollector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Collectors;
 4 | 
 5 | use CodeIgniter\Debug\Toolbar\Collectors\BaseCollector;
 6 | 
 7 | use function auth;
 8 | use function get_class;
 9 | 
10 | class AuthCollector extends BaseCollector
11 | {
12 |     /**
13 |      * Whether this collector needs to display
14 |      * content in a tab or not.
15 |      *
16 |      * @var boolean
17 |      */
18 |     protected $hasTabContent = true;
19 | 
20 |     /**
21 |      * The 'title' of this Collector.
22 |      * Used to name things in the toolbar HTML.
23 |      *
24 |      * @var string
25 |      */
26 |     protected $title = 'Auth';
27 | 
28 |     /**
29 |      * Returns any information that should be shown next to the title.
30 |      */
31 |     public function getTitleDetails(): string
32 |     {
33 |         return get_class(auth()->getProvider());
34 |     }
35 | 
36 |     /**
37 |      * Returns the data of this collector to be formatted in the toolbar
38 |      */
39 |     public function display(): string
40 |     {
41 |         if (auth('web')->check()) {
42 |             $user  = auth('web')->user();
43 |             $html  = '<h3>Current User</h3>';
44 |             $html .= '<table><tbody>';
45 |             $html .= "<tr><td style='width:150px;'>User ID</td><td>#{$user->id}</td></tr>";
46 |             $html .= "<tr><td>Username</td><td>{$user->username}</td></tr>";
47 |             $html .= "<tr><td>Email</td><td>{$user->email}</td></tr>";
48 |             $html .= "<tr><td>User since</td><td>{$user->created_at->humanize()}</td></tr>";
49 |             $html .= "<tr><td>Verified at</td><td>{$user->email_verified_at}</td></tr>";
50 |             $html .= '</tbody></table>';
51 |         } else {
52 |             $html = '<p>Not logged in.</p>';
53 |         }
54 | 
55 |         return $html;
56 |     }
57 | 
58 |     /**
59 |      * Gets the "badge" value for the button.
60 |      *
61 |      * @return int|null ID of the current User, or null when not logged in
62 |      */
63 |     public function getBadgeValue(): ?int
64 |     {
65 |         return auth('web')->check() ? auth('web')->id() : null;
66 |     }
67 | 
68 |     /**
69 |      * Display the icon.
70 |      *
71 |      * Icon from https://icons8.com - 1em package
72 |      */
73 |     public function icon(): string
74 |     {
75 |         return 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAADLSURBVEhL5ZRLCsIwGAa7UkE9gd5HUfEoekxxJx7AhXoCca/fhESkJiQxBHwMDG3S/9EmJc0n0JMruZVXK/fMdWQRY7mXt4A7OZJvwZu74hRayIEc2nv3jGtXZrOWrnifiRY0OkhiWK5sWGeS52bkZymJ2ZhRJmwmySxLCL6CmIsZZUIixkiNezCRR+kSUyWH3Cgn6SuQIk2iuOBckvN+t8FMnq1TJloUN3jefN9mhvJeCAVWb8CyUDj0vxc3iPFHDaofFdUPu2+iae7nYJMCY/1bpAAAAABJRU5ErkJggg==';
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/Facades/Auth.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Facades;
 4 | 
 5 | use Closure;
 6 | use Fluent\Auth\Config\Services;
 7 | use CodeIgniter\Router\RouteCollection;
 8 | use Fluent\Auth\Contracts\AuthenticationBasicInterface;
 9 | use Fluent\Auth\Contracts\AuthenticationInterface;
10 | use Fluent\Auth\Contracts\AuthenticatorInterface;
11 | use Fluent\Auth\Contracts\HasAccessTokensInterface;
12 | use Fluent\Auth\Contracts\ResetPasswordInterface;
13 | use Fluent\Auth\Contracts\UserProviderInterface;
14 | use Fluent\Auth\Contracts\VerifyEmailInterface;
15 | 
16 | /**
17 |  * @see \Fluent\Auth\Contracts\AuthenticationInterface
18 |  * @see \Fluent\Auth\Contracts\AuthFactoryInterface
19 |  *
20 |  * @method static UserProviderInterface createUserProvider($provider = null)
21 |  * @method static string getDefaultUserProvider()
22 |  * @method static AuthenticationBasicInterface|AuthenticationInterface guard($name = null)
23 |  * @method static string getDefaultDriver()
24 |  * @method static $this setDefaultDriver($name)
25 |  * @method static Closure userResolver()
26 |  * @method static $this resolveUsersUsing(Closure $userResolver)
27 |  * @method static $this extend($driver, Closure $callback)
28 |  * @method static $this provider($name, Closure $callback)
29 |  * @method static bool hasResolvedGuards()
30 |  * @method static RouteCollection routes(array $options = [])
31 |  * @method static AuthenticatorInterface|ResetPasswordInterface|VerifyEmailInterface|HasAccessTokensInterface authenticate()
32 |  * @method static bool attempt(array $credentials, bool $remember = false)
33 |  * @method static bool viaRemember()
34 |  * @method static bool validate(array $credentials)
35 |  * @method static bool check()
36 |  * @method static mixed login(AuthenticatorInterface $user, bool $remember = false)
37 |  * @method static AuthenticatorInterface|bool loginById(int $userId, bool $remember = false)
38 |  * @method static void logout()
39 |  * @method static AuthenticatorInterface|ResetPasswordInterface|VerifyEmailInterface|HasAccessTokensInterface|null user()
40 |  * @method static int|null id()
41 |  * @method static bool hasUser
42 |  * @method static $this setUser(AuthenticatorInterface $user)
43 |  * @method static string getSessionName()
44 |  * @method static string getCookieName()
45 |  * @method static UserProviderInterface getProvider()
46 |  * @method static $this setProvider(UserProviderInterface $provider)
47 |  */
48 | class Auth
49 | {
50 |     /**
51 |      * Facade auth instance service.
52 |      *
53 |      * @param string $method
54 |      * @param array $arguments
55 |      * @return AuthFactoryInterface|AuthenticationInterface
56 |      */
57 |     public static function __callStatic($method, $arguments)
58 |     {
59 |         return Services::getSharedInstance('auth')->{$method}(...$arguments);
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/Traits/AuthorizesRequestsTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Traits;
 4 | 
 5 | use Fluent\Auth\Config\Services;
 6 | 
 7 | trait AuthorizesRequestsTrait
 8 | {
 9 |     /**
10 |      * Authorize a given action for the current user.
11 |      *
12 |      * @param  mixed  $ability
13 |      * @param  mixed|array  $arguments
14 |      * @return \Fluent\Auth\Authorization\Response
15 |      *
16 |      * @throws \Fluent\Auth\Exceptions\AuthorizationException
17 |      */
18 |     public function authorize($ability, $arguments = [])
19 |     {
20 |         [$ability, $arguments] = $this->parseAbilityAndArguments($ability, $arguments);
21 | 
22 |         return Services::gate()->authorize($ability, $arguments);
23 |     }
24 | 
25 |     /**
26 |      * Authorize a given action for a user.
27 |      *
28 |      * @param  \Fluent\Auth\Contracts\AuthenticatorInterface $user
29 |      * @param  mixed  $ability
30 |      * @param  mixed|array  $arguments
31 |      * @return \Fluent\Auth\Authorization\Response
32 |      *
33 |      * @throws \Fluent\Auth\Exceptions\AuthorizationException
34 |      */
35 |     public function authorizeForUser($user, $ability, $arguments = [])
36 |     {
37 |         [$ability, $arguments] = $this->parseAbilityAndArguments($ability, $arguments);
38 | 
39 |         return Services::gate()->forUser($user)->authorize($ability, $arguments);
40 |     }
41 | 
42 |     /**
43 |      * Guesses the ability's name if it wasn't provided.
44 |      *
45 |      * @param  mixed  $ability
46 |      * @param  mixed|array  $arguments
47 |      * @return array
48 |      */
49 |     protected function parseAbilityAndArguments($ability, $arguments)
50 |     {
51 |         if (is_string($ability) && strpos($ability, '\\') === false) {
52 |             return [$ability, $arguments];
53 |         }
54 | 
55 |         $method = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3)[2]['function'];
56 | 
57 |         return [$this->normalizeGuessedAbilityName($method), $ability];
58 |     }
59 | 
60 |     /**
61 |      * Normalize the ability name that has been guessed from the method name.
62 |      *
63 |      * @param  string  $ability
64 |      * @return string
65 |      */
66 |     protected function normalizeGuessedAbilityName($ability)
67 |     {
68 |         $map = $this->resourceAbilityMap();
69 | 
70 |         return $map[$ability] ?? $ability;
71 |     }
72 | 
73 |     /**
74 |      * Get the map of resource methods to ability names.
75 |      *
76 |      * @return array
77 |      */
78 |     protected function resourceAbilityMap()
79 |     {
80 |         return [
81 |             'index' => 'viewAny',
82 |             'show' => 'view',
83 |             'new' => 'create',
84 |             'create' => 'create',
85 |             'edit' => 'update',
86 |             'update' => 'update',
87 |             'delete' => 'delete',
88 |         ];
89 |     }
90 | }


--------------------------------------------------------------------------------
/src/Passwords/Hash/HashManager.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Passwords\Hash;
  4 | 
  5 | use Fluent\Auth\Contracts\HasherInterface;
  6 | use Fluent\Auth\Passwords\Hash\Argon2IdHasher;
  7 | use Fluent\Auth\Passwords\Hash\ArgonHasher;
  8 | use Fluent\Auth\Passwords\Hash\BcryptHasher;
  9 | 
 10 | class HashManager extends AbstractManager implements HasherInterface
 11 | {
 12 |     /**
 13 |      * Create an instance of the Bcrypt hash Driver.
 14 |      *
 15 |      * @return BcryptHasher
 16 |      */
 17 |     public function createBcryptDriver()
 18 |     {
 19 |         return new BcryptHasher($this->config->bcrypt ?? []);
 20 |     }
 21 | 
 22 |     /**
 23 |      * Create an instance of the Argon2i hash Driver.
 24 |      *
 25 |      * @return ArgonHasher
 26 |      */
 27 |     public function createArgonDriver()
 28 |     {
 29 |         return new ArgonHasher($this->config->argon ?? []);
 30 |     }
 31 | 
 32 |     /**
 33 |      * Create an instance of the Argon2id hash Driver.
 34 |      *
 35 |      * @return Argon2IdHasher
 36 |      */
 37 |     public function createArgon2idDriver()
 38 |     {
 39 |         return new Argon2IdHasher($this->config->argon ?? []);
 40 |     }
 41 | 
 42 |     /**
 43 |      * Get information about the given hashed value.
 44 |      *
 45 |      * @param  string  $hashedValue
 46 |      * @return array
 47 |      */
 48 |     public function info($hashedValue)
 49 |     {
 50 |         return $this->driver()->info($hashedValue);
 51 |     }
 52 | 
 53 |     /**
 54 |      * Hash the given value.
 55 |      *
 56 |      * @param  string  $value
 57 |      * @param  array  $options
 58 |      * @return string
 59 |      */
 60 |     public function make($value, array $options = [])
 61 |     {
 62 |         return $this->driver()->make($value, $options);
 63 |     }
 64 | 
 65 |     /**
 66 |      * Check the given plain value against a hash.
 67 |      *
 68 |      * @param  string  $value
 69 |      * @param  string  $hashedValue
 70 |      * @param  array  $options
 71 |      * @return bool
 72 |      */
 73 |     public function check($value, $hashedValue, array $options = [])
 74 |     {
 75 |         return $this->driver()->check($value, $hashedValue, $options);
 76 |     }
 77 | 
 78 |     /**
 79 |      * Check if the given hash has been hashed using the given options.
 80 |      *
 81 |      * @param  string  $hashedValue
 82 |      * @param  array  $options
 83 |      * @return bool
 84 |      */
 85 |     public function needsRehash($hashedValue, array $options = [])
 86 |     {
 87 |         return $this->driver()->needsRehash($hashedValue, $options);
 88 |     }
 89 | 
 90 |     /**
 91 |      * Get the default driver name.
 92 |      *
 93 |      * @return string
 94 |      */
 95 |     public function getDefaultDriver()
 96 |     {
 97 |         return $this->config->driver;
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/Filters/AuthenticationFilter.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Filters;
  4 | 
  5 | use CodeIgniter\API\ResponseTrait;
  6 | use CodeIgniter\Filters\FilterInterface;
  7 | use CodeIgniter\HTTP\RequestInterface;
  8 | use CodeIgniter\HTTP\ResponseInterface;
  9 | use Fluent\Auth\Config\Services;
 10 | use Fluent\Auth\Contracts\AuthenticationInterface;
 11 | use Fluent\Auth\Contracts\AuthFactoryInterface;
 12 | use Fluent\Auth\Exceptions\AuthenticationException;
 13 | 
 14 | class AuthenticationFilter implements FilterInterface
 15 | {
 16 |     use ResponseTrait;
 17 | 
 18 |     /** @var AuthFactoryInterface|AuthenticationInterface */
 19 |     protected $auth;
 20 | 
 21 |     /** @var ResponseInterface */
 22 |     protected $response;
 23 | 
 24 |     public function __construct()
 25 |     {
 26 |         $this->auth = Services::auth();
 27 |         $this->response = Services::response();
 28 |     }
 29 | 
 30 |     /**
 31 |      * {@inheritdoc}
 32 |      */
 33 |     public function before(RequestInterface $request, $arguments = null)
 34 |     {
 35 |         return $this->authenticate($request, $arguments);
 36 |     }
 37 | 
 38 |     /**
 39 |      * {@inheritdoc}
 40 |      */
 41 |     public function after(RequestInterface $request, ResponseInterface $response, $arguments = null)
 42 |     {
 43 |     }
 44 | 
 45 |     /**
 46 |      * Determine if the user is logged in to any of the given guards.
 47 |      *
 48 |      * @param RequestInterface $request
 49 |      * @param array $guards
 50 |      * @return void
 51 |      * @throws AuthenticationException
 52 |      */
 53 |     protected function authenticate($request, $guards)
 54 |     {
 55 |         if (empty($guards)) {
 56 |             $guards = [null];
 57 |         }
 58 | 
 59 |         foreach ($guards as $guard) {
 60 |             if ($this->auth->guard($guard)->check()) {
 61 |                 return $this->auth->shouldUse($guard);
 62 |             }
 63 |         }
 64 | 
 65 |         return $this->unauthenticated($request, $guards);
 66 |     }
 67 | 
 68 |      /**
 69 |       * Handle an unauthenticated user.
 70 |       *
 71 |       * @param RequestInterface $request
 72 |       * @param array $guards
 73 |       * @return void
 74 |       * @throws AuthenticationException
 75 |       */
 76 |     protected function unauthenticated($request, $guards)
 77 |     {
 78 |         if ($request->isAJAX()) {
 79 |             return $this->fail('Unauthenticated.', ResponseInterface::HTTP_UNAUTHORIZED);
 80 |         }
 81 | 
 82 |         throw new AuthenticationException(
 83 |             'Unauthenticated.',
 84 |             $guards,
 85 |             ResponseInterface::HTTP_UNAUTHORIZED,
 86 |             $this->redirectTo($request)
 87 |         );
 88 |     }
 89 | 
 90 |     /**
 91 |      * Get the path the user should be redirected to when they are not authenticated.
 92 |      *
 93 |      * @param RequestInterface $request
 94 |      * @return string|null
 95 |      */
 96 |     protected function redirectTo($request)
 97 |     {
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/Views/Auth/confirm_password.php:
--------------------------------------------------------------------------------
 1 | <?= $this->extend('Auth/layout') ?>
 2 | 
 3 | <?= $this->section('content') ?>
 4 | <section class="vh-lg-100 mt-5 mt-lg-0 bg-soft d-flex align-items-center">
 5 |     <div class="container">
 6 |         <div class="row justify-content-center form-bg-image">
 7 |             <p class="text-center"><a href="/" class="d-flex align-items-center justify-content-center">
 8 |                     <svg class="icon icon-xs me-2" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
 9 |                         <path fill-rule="evenodd" d="M7.707 14.707a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414l4-4a1 1 0 011.414 1.414L5.414 9H17a1 1 0 110 2H5.414l2.293 2.293a1 1 0 010 1.414z" clip-rule="evenodd"></path>
10 |                     </svg>
11 |                     Back to homepage
12 |                 </a>
13 |             </p>
14 |             <div class="col-12 d-flex align-items-center justify-content-center">
15 |                 <div class="signin-inner my-3 my-lg-0 bg-white shadow border-0 rounded p-4 p-lg-5 w-100 fmxw-500">
16 |                     <div class="text-center text-md-center mb-4 mt-md-0">
17 |                         <h1 class="mb-0 h3">Confirm your password</h1>
18 |                     </div>
19 |                     <!-- Validation Errors and Message -->
20 |                     <?= $this->include('Auth/messages') ?>
21 |                     <p class="mb-4">This is a secure area of the application. Please confirm your password before continuing.</p>
22 |                     <form method="post" action="<?= route_to('password-confirm') ?>">
23 |                         <?= csrf_field() ?>
24 |                         <div class="form-group">
25 |                             <div class="form-group mb-4">
26 |                                 <label for="password">Your Password</label>
27 |                                 <div class="input-group">
28 |                                     <span class="input-group-text" id="basic-addon2">
29 |                                         <svg class="icon icon-xs text-gray-600" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
30 |                                             <path fill-rule="evenodd" d="M5 9V7a5 5 0 0110 0v2a2 2 0 012 2v5a2 2 0 01-2 2H5a2 2 0 01-2-2v-5a2 2 0 012-2zm8-2v2H7V7a3 3 0 016 0z" clip-rule="evenodd"></path>
31 |                                         </svg>
32 |                                     </span>
33 |                                     <input type="password" name="password" placeholder="Password" class="form-control" id="password" required="">
34 |                                 </div>
35 |                             </div>
36 |                         </div>
37 |                         <div class="d-grid">
38 |                             <button type="submit" class="btn btn-gray-800">Confirm</button>
39 |                         </div>
40 |                     </form>
41 |                 </div>
42 |             </div>
43 |         </div>
44 |     </div>
45 | </section>
46 | <?= $this->endSection() ?>


--------------------------------------------------------------------------------
/src/Helpers/Str.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Helpers;
  4 | 
  5 | use function mb_strpos;
  6 | use function strlen;
  7 | use function strncmp;
  8 | 
  9 | class Str
 10 | {
 11 |     /**
 12 |      * Determine if a given string contains a given substring.
 13 |      *
 14 |      * @param  string  $haystack
 15 |      * @param  string|string[]  $needles
 16 |      * @return bool
 17 |      */
 18 |     public static function contains($haystack, $needles)
 19 |     {
 20 |         foreach ((array) $needles as $needle) {
 21 |             if ($needle !== '' && mb_strpos($haystack, $needle) !== false) {
 22 |                 return true;
 23 |             }
 24 |         }
 25 | 
 26 |         return false;
 27 |     }
 28 | 
 29 |     /**
 30 |      * Convert a value to camel case.
 31 |      *
 32 |      * @param  string  $value
 33 |      * @return string
 34 |      */
 35 |     public static function camel($value)
 36 |     {
 37 |         return lcfirst(static::studly($value));
 38 |     }
 39 | 
 40 |     /**
 41 |      * Convert a value to studly caps case.
 42 |      *
 43 |      * @param  string  $value
 44 |      * @return string
 45 |      */
 46 |     public static function studly($value)
 47 |     {
 48 |         $words = explode(' ', str_replace(['-', '_'], ' ', $value));
 49 | 
 50 |         $studlyWords = array_map(function ($word) {
 51 |             return static::ucfirst($word);
 52 |         }, $words);
 53 | 
 54 |         return implode($studlyWords);
 55 |     }
 56 | 
 57 |     /**
 58 |      * Make a string's first character uppercase.
 59 |      *
 60 |      * @param  string  $string
 61 |      * @return string
 62 |      */
 63 |     public static function ucfirst($string)
 64 |     {
 65 |         return mb_strtoupper(mb_substr($string, 0, 1)).mb_substr($string, 1);
 66 |     }
 67 | 
 68 |     /**
 69 |      * Parse a Class[@]method style callback into class and method.
 70 |      *
 71 |      * @param  string  $callback
 72 |      * @param  string|null  $default
 73 |      * @return array<int, string|null>
 74 |      */
 75 |     public static function parseCallback($callback, $default = null)
 76 |     {
 77 |         return static::contains($callback, '@') ? explode('@', $callback, 2) : [$callback, $default];
 78 |     }
 79 | 
 80 |     /**
 81 |      * Determine if a given string starts with a given substring.
 82 |      *
 83 |      * @param  string  $haystack
 84 |      * @param  string|string[]  $needles
 85 |      * @return bool
 86 |      */
 87 |     public static function startsWith($haystack, $needles)
 88 |     {
 89 |         foreach ((array) $needles as $needle) {
 90 |             if ((string) $needle !== '' && strncmp($haystack, $needle, strlen($needle)) === 0) {
 91 |                 return true;
 92 |             }
 93 |         }
 94 | 
 95 |         return false;
 96 |     }
 97 | 
 98 |     /**
 99 |      * Extract username from given email.
100 |      * 
101 |      * @param string $email
102 |      * @return string|empty
103 |      */
104 |     public static function extractName(string $email)
105 |     {
106 |         return strstr($email, '@', true);
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/src/Contracts/PasswordBrokerInterface.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Contracts;
  4 | 
  5 | use Closure;
  6 | use Fluent\Auth\Contracts\PasswordResetRepositoryInterface;
  7 | use Fluent\Auth\Contracts\ResetPasswordInterface;
  8 | use Fluent\Auth\Contracts\VerifyEmailInterface;
  9 | 
 10 | interface PasswordBrokerInterface
 11 | {
 12 |     /**
 13 |      * Constant representing a successfully sent reminder.
 14 |      *
 15 |      * @var string
 16 |      */
 17 |     const RESET_LINK_SENT = 'Passwords.sent';
 18 | 
 19 |     /**
 20 |      * Constant representing a successfully sent verify.
 21 |      *
 22 |      * @var string
 23 |      */
 24 |     const VERIFY_LINK_SENT = 'Passwords.verify';
 25 | 
 26 |     /**
 27 |      * Constant representing a successfully reset password.
 28 |      *
 29 |      * @var string
 30 |      */
 31 |     const PASSWORD_RESET = 'Passwords.reset';
 32 | 
 33 |     /**
 34 |      * Constant representing the user not found response.
 35 |      *
 36 |      * @var string
 37 |      */
 38 |     const INVALID_USER = 'Passwords.user';
 39 | 
 40 |     /**
 41 |      * Constant representing an invalid token.
 42 |      *
 43 |      * @var string
 44 |      */
 45 |     const INVALID_TOKEN = 'Passwords.token';
 46 | 
 47 |     /**
 48 |      * Constant representing a throttled reset attempt.
 49 |      *
 50 |      * @var string
 51 |      */
 52 |     const RESET_THROTTLED = 'Passwords.throttled';
 53 | 
 54 |     /**
 55 |      * Send a password reset link to a user.
 56 |      *
 57 |      * @param  array  $credentials
 58 |      * @return string
 59 |      */
 60 |     public function sendResetLink(array $credentials, ?Closure $callback = null);
 61 | 
 62 |     /**
 63 |      * Send a password reset link to a user.
 64 |      *
 65 |      * @param  array  $credentials
 66 |      * @return string
 67 |      */
 68 |     public function sendVerifyLink(array $credentials, ?Closure $callback = null);
 69 | 
 70 |     /**
 71 |      * Reset the password for the given token.
 72 |      *
 73 |      * @param  array  $credentials
 74 |      * @return mixed
 75 |      */
 76 |     public function reset(array $credentials, Closure $callback);
 77 | 
 78 |     /**
 79 |      * Get the user for the given credentials.
 80 |      *
 81 |      * @param  array  $credentials
 82 |      * @return ResetPasswordInterface|VerifyEmailInterface|null
 83 |      * @throws UnexpectedValueException
 84 |      */
 85 |     public function getUser(array $credentials);
 86 | 
 87 |     /**
 88 |      * Create a new password reset token for the given user.
 89 |      *
 90 |      * @return string
 91 |      */
 92 |     public function createToken(ResetPasswordInterface $user);
 93 | 
 94 |     /**
 95 |      * Delete password reset tokens of the given user.
 96 |      *
 97 |      * @return void
 98 |      */
 99 |     public function deleteToken(ResetPasswordInterface $user);
100 | 
101 |     /**
102 |      * Validate the given password reset token.
103 |      *
104 |      * @param  string  $token
105 |      * @return bool
106 |      */
107 |     public function tokenExists(ResetPasswordInterface $user, $token);
108 | 
109 |     /**
110 |      * Get the password reset token repository implementation.
111 |      *
112 |      * @return PasswordResetRepositoryInterface
113 |      */
114 |     public function getRepository();
115 | }
116 | 


--------------------------------------------------------------------------------
/src/Contracts/AuthenticationInterface.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Contracts;
  4 | 
  5 | use Fluent\Auth\Exceptions\AuthenticationException;
  6 | 
  7 | interface AuthenticationInterface
  8 | {
  9 |     /**
 10 |      * Determine if current user is authenticated. If not, throw an exception.
 11 |      *
 12 |      * @return AuthenticatorInterface|AuthorizableInterface|ResetPasswordInterface|HasAccessTokensInterface|VerifyEmailInterface
 13 |      * @throws AuthenticationException
 14 |      */
 15 |     public function authenticate();
 16 | 
 17 |     /**
 18 |      * Attempts to authenticate a user with the given $credentials.
 19 |      *
 20 |      * @param array $credentials
 21 |      * @return bool
 22 |      */
 23 |     public function attempt(array $credentials, bool $remember = false);
 24 | 
 25 |     /**
 26 |      * Determine if the user was authenticated via "remember me" cookie.
 27 |      *
 28 |      * @return bool
 29 |      */
 30 |     public function viaRemember();
 31 | 
 32 |     /**
 33 |      * Validate a user's credentials.
 34 |      *
 35 |      * @param  array  $credentials
 36 |      */
 37 |     public function validate(array $credentials): bool;
 38 | 
 39 |     /**
 40 |      * Checks if the user is currently logged in.
 41 |      */
 42 |     public function check(): bool;
 43 | 
 44 |     /**
 45 |      * Logs the given user in.
 46 |      * 
 47 |      * @return mixed
 48 |      */
 49 |     public function login(AuthenticatorInterface $user, bool $remember = false);
 50 | 
 51 |     /**
 52 |      * Logs a user in based on their ID.
 53 |      *
 54 |      * @param int|string $userId
 55 |      * @return AuthenticatorInterface|AuthorizableInterface|bool
 56 |      */
 57 |     public function loginById($userId, bool $remember = false);
 58 | 
 59 |     /**
 60 |      * Logs the current user out.
 61 |      *
 62 |      * @return void
 63 |      */
 64 |     public function logout();
 65 | 
 66 |     /**
 67 |      * Returns the currently logged in user.
 68 |      *
 69 |      * @return AuthenticatorInterface|AuthorizableInterface|ResetPasswordInterface|HasAccessTokensInterface|VerifyEmailInterface|null
 70 |      */
 71 |     public function user();
 72 | 
 73 |     /**
 74 |      * Get the ID for the currently authenticated user.
 75 |      *
 76 |      * @return int|null
 77 |      */
 78 |     public function id();
 79 | 
 80 |     /**
 81 |      * Determine if the adapter has a user instance.
 82 |      */
 83 |     public function hasUser(): bool;
 84 | 
 85 |     /**
 86 |      * Set the current user.
 87 |      *
 88 |      * @return $this
 89 |      */
 90 |     public function setUser(AuthenticatorInterface $user);
 91 | 
 92 |     /**
 93 |      * Get a unique identifier for the auth session value.
 94 |      *
 95 |      * @return string
 96 |      */
 97 |     public function getSessionName();
 98 | 
 99 |     /**
100 |      * Get the name of the cookie used to store the "recaller".
101 |      *
102 |      * @return string
103 |      */
104 |     public function getCookieName();
105 | 
106 |     /**
107 |      * Get the user provider used by the adapter.
108 |      *
109 |      * @return UserProviderInterface
110 |      */
111 |     public function getProvider();
112 | 
113 |     /**
114 |      * Set the user provider used by the adapter.
115 |      *
116 |      * @return $this
117 |      */
118 |     public function setProvider(UserProviderInterface $provider);
119 | }
120 | 


--------------------------------------------------------------------------------
/src/Traits/UserProviderTrait.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Traits;
  4 | 
  5 | use CodeIgniter\Database\BaseBuilder;
  6 | use CodeIgniter\Model;
  7 | use Fluent\Auth\Contracts\AuthenticatorInterface;
  8 | use Fluent\Auth\Facades\Hash;
  9 | use Fluent\Auth\Helpers\Str;
 10 | 
 11 | use function array_key_exists;
 12 | use function count;
 13 | use function hash_equals;
 14 | use function is_array;
 15 | 
 16 | trait UserProviderTrait
 17 | {
 18 |     /**
 19 |      * Locates an identity object by ID.
 20 |      *
 21 |      * @param int|string $userId
 22 |      * @return AuthenticatorInterface|null
 23 |      */
 24 |     public function findById($userId)
 25 |     {
 26 |         return $this->find($userId);
 27 |     }
 28 | 
 29 |     /**
 30 |      * Locate a user by the given credentials.
 31 |      *
 32 |      * @param array $credentials
 33 |      * @return AuthenticatorInterface|null
 34 |      */
 35 |     public function findByCredentials(array $credentials)
 36 |     {
 37 |         if (
 38 |             empty($credentials) ||
 39 |             (count($credentials) === 1 &&
 40 |             array_key_exists('password', $credentials))
 41 |         ) {
 42 |             return;
 43 |         }
 44 | 
 45 |         /** @var Model $query */
 46 |         $query = clone $this;
 47 | 
 48 |         foreach ($credentials as $key => $value) {
 49 |             if (Str::contains($key, 'password')) {
 50 |                 continue;
 51 |             }
 52 | 
 53 |             if (is_array($value)) {
 54 |                 $query->whereIn($key, $value);
 55 |             } else {
 56 |                 $query->where($key, $value);
 57 |             }
 58 |         }
 59 | 
 60 |         return $query->first();
 61 |     }
 62 | 
 63 |     /**
 64 |      * Find a user by their ID and "remember-me" token.
 65 |      *
 66 |      * @param int|string $userId
 67 |      * @param string $token
 68 |      * @return AuthenticatorInterface|null
 69 |      */
 70 |     public function findByRememberToken($userId, $token)
 71 |     {
 72 |         $retrievedModel = $this->where('id', $userId)->first();
 73 | 
 74 |         if (! $retrievedModel) {
 75 |             return;
 76 |         }
 77 | 
 78 |         $rememberToken = $retrievedModel->getRememberToken();
 79 | 
 80 |         return $rememberToken && hash_equals($rememberToken, $token)
 81 |             ? $retrievedModel
 82 |             : null;
 83 |     }
 84 | 
 85 |     /**
 86 |      * Update the "remember me" token for the given user in storage.
 87 |      *
 88 |      * @param string $token
 89 |      * @return mixed
 90 |      */
 91 |     public function updateRememberToken(AuthenticatorInterface $user, $token = null)
 92 |     {
 93 |         return $this->where($user->getAuthIdColumn(), $user->getAuthId())
 94 |             ->set($user->getRememberColumn(), $token)->update();
 95 |     }
 96 | 
 97 |     /**
 98 |      * Validate a user against the given credentials.
 99 |      *
100 |      * @param array $credentials
101 |      * @return bool
102 |      */
103 |     public function validateCredentials(AuthenticatorInterface $user, array $credentials)
104 |     {
105 |         return Hash::check($credentials['password'], $user->getAuthPassword());
106 |     }
107 | 
108 |     /**
109 |      * Get instance class user provider.
110 |      *
111 |      * @return BaseBuilder|Model
112 |      */
113 |     public function instance()
114 |     {
115 |         return $this;
116 |     }
117 | }
118 | 


--------------------------------------------------------------------------------
/src/Database/Migrations/2020-12-28-223112_create_auth_tables.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fluent\Auth\Database\Migrations;
 4 | 
 5 | use CodeIgniter\Database\Migration;
 6 | 
 7 | class CreateAuthTables extends Migration
 8 | {
 9 |     /**
10 |      * {@inheritdoc}
11 |      */
12 |     public function up()
13 |     {
14 |         /**
15 |          * Users table.
16 |          */
17 |         $this->forge->addField([
18 |             'id'                => ['type' => 'int', 'constraint' => 11, 'unsigned' => true, 'auto_increment' => true],
19 |             'email'             => ['type' => 'varchar', 'constraint' => 255],
20 |             'username'          => ['type' => 'varchar', 'constraint' => 30, 'null' => true],
21 |             'password'          => ['type' => 'varchar', 'constraint' => 255],
22 |             'email_verified_at' => ['type' => 'datetime', 'null' => true],
23 |             'remember_token'    => ['type' => 'varchar', 'constraint' => 255, 'null' => true],
24 |             'created_at'        => ['type' => 'datetime', 'null' => true],
25 |             'updated_at'        => ['type' => 'datetime', 'null' => true],
26 |             'deleted_at'        => ['type' => 'datetime', 'null' => true],
27 |         ]);
28 | 
29 |         $this->forge->addPrimaryKey('id');
30 |         $this->forge->addUniqueKey('email');
31 |         $this->forge->addUniqueKey('username');
32 | 
33 |         $this->forge->createTable('users', true);
34 | 
35 |         /**
36 |          * Password reset table.
37 |          */
38 |         $this->forge->addField([
39 |             'id'         => ['type' => 'int', 'constraint' => 11, 'unsigned' => true, 'auto_increment' => true],
40 |             'email'      => ['type' => 'varchar', 'constraint' => 255],
41 |             'token'      => ['type' => 'varchar', 'constraint' => 255, 'null' => true],
42 |             'created_at' => ['type' => 'datetime', 'null' => false],
43 |             'updated_at' => ['type' => 'datetime', 'null' => true],
44 |         ]);
45 | 
46 |         $this->forge->addPrimaryKey('id');
47 |         $this->forge->createTable('auth_password_resets', true);
48 | 
49 |         /**
50 |          * Access tokens table.
51 |          */
52 |         $this->forge->addField([
53 |             'id'           => ['type' => 'int', 'constraint' => 11, 'unsigned' => true, 'auto_increment' => true],
54 |             'user_id'      => ['type' => 'int', 'constraint' => 11, 'unsigned' => true],
55 |             'name'         => ['type' => 'varchar', 'constraint' => 255],
56 |             'token'        => ['type' => 'varchar', 'constraint' => 64],
57 |             'last_used_at' => ['type' => 'datetime', 'null' => true],
58 |             'scopes'       => ['type' => 'text', 'null' => true],
59 |             'created_at'   => ['type' => 'datetime', 'null' => true],
60 |             'updated_at'   => ['type' => 'datetime', 'null' => true],
61 |         ]);
62 | 
63 |         $this->forge->addPrimaryKey('id');
64 |         $this->forge->addUniqueKey('token');
65 |         $this->forge->createTable('auth_access_tokens', true);
66 |     }
67 | 
68 |     //--------------------------------------------------------------------
69 | 
70 |     /**
71 |      * {@inheritdoc}
72 |      */
73 |     public function down()
74 |     {
75 |         $this->forge->dropTable('users', true);
76 |         $this->forge->dropTable('auth_password_resets', true);
77 |         $this->forge->dropTable('auth_access_tokens', true);
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/src/Passwords/Hash/BcryptHasher.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace FLuent\Auth\Passwords\Hash;
  4 | 
  5 | use Fluent\Auth\Contracts\HasherInterface;
  6 | use Fluent\Auth\Passwords\Hash\AbstractHasher;
  7 | use RuntimeException;
  8 | 
  9 | use function password_hash;
 10 | use function password_needs_rehash;
 11 | 
 12 | use const PASSWORD_BCRYPT;
 13 | 
 14 | class BcryptHasher extends AbstractHasher implements HasherInterface
 15 | {
 16 |     /**
 17 |      * The default cost factor.
 18 |      *
 19 |      * @var int
 20 |      */
 21 |     protected $rounds = 10;
 22 | 
 23 |     /**
 24 |      * Indicates whether to perform an algorithm check.
 25 |      *
 26 |      * @var bool
 27 |      */
 28 |     protected $verifyAlgorithm = false;
 29 | 
 30 |     /**
 31 |      * Create a new hasher instance.
 32 |      *
 33 |      * @param  array  $options
 34 |      * @return void
 35 |      */
 36 |     public function __construct(array $options = [])
 37 |     {
 38 |         $this->rounds          = $options['rounds'] ?? $this->rounds;
 39 |         $this->verifyAlgorithm = $options['verify'] ?? $this->verifyAlgorithm;
 40 |     }
 41 | 
 42 |     /**
 43 |      * Hash the given value.
 44 |      *
 45 |      * @param  string  $value
 46 |      * @param  array  $options
 47 |      * @return string
 48 |      * @throws RuntimeException
 49 |      */
 50 |     public function make($value, array $options = [])
 51 |     {
 52 |         $hash = password_hash($value, PASSWORD_BCRYPT, [
 53 |             'cost' => $this->cost($options),
 54 |         ]);
 55 | 
 56 |         if ($hash === false) {
 57 |             throw new RuntimeException('Bcrypt hashing not supported.');
 58 |         }
 59 | 
 60 |         return $hash;
 61 |     }
 62 | 
 63 |     /**
 64 |      * Check the given plain value against a hash.
 65 |      *
 66 |      * @param  string  $value
 67 |      * @param  string  $hashedValue
 68 |      * @param  array  $options
 69 |      * @return bool
 70 |      * @throws RuntimeException
 71 |      */
 72 |     public function check($value, $hashedValue, array $options = [])
 73 |     {
 74 |         if ($this->verifyAlgorithm && $this->info($hashedValue)['algoName'] !== 'bcrypt') {
 75 |             throw new RuntimeException('This password does not use the Bcrypt algorithm.');
 76 |         }
 77 | 
 78 |         return parent::check($value, $hashedValue, $options);
 79 |     }
 80 | 
 81 |     /**
 82 |      * Check if the given hash has been hashed using the given options.
 83 |      *
 84 |      * @param  string  $hashedValue
 85 |      * @param  array  $options
 86 |      * @return bool
 87 |      */
 88 |     public function needsRehash($hashedValue, array $options = [])
 89 |     {
 90 |         return password_needs_rehash($hashedValue, PASSWORD_BCRYPT, [
 91 |             'cost' => $this->cost($options),
 92 |         ]);
 93 |     }
 94 | 
 95 |     /**
 96 |      * Set the default password work factor.
 97 |      *
 98 |      * @param  int  $rounds
 99 |      * @return $this
100 |      */
101 |     public function setRounds($rounds)
102 |     {
103 |         $this->rounds = (int) $rounds;
104 | 
105 |         return $this;
106 |     }
107 | 
108 |     /**
109 |      * Extract the cost value from the options array.
110 |      *
111 |      * @param  array  $options
112 |      * @return int
113 |      */
114 |     protected function cost(array $options = [])
115 |     {
116 |         return $options['rounds'] ?? $this->rounds;
117 |     }
118 | }
119 | 


--------------------------------------------------------------------------------
/src/Controllers/Auth/NewPasswordController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Controllers\Auth;
 4 | 
 5 | use App\Controllers\BaseController;
 6 | use CodeIgniter\Events\Events;
 7 | use CodeIgniter\HTTP\RedirectResponse;
 8 | use CodeIgniter\View\RendererInterface;
 9 | use Fluent\Auth\Contracts\PasswordBrokerInterface;
10 | use Fluent\Auth\Entities\User;
11 | use Fluent\Auth\Facades\Passwords;
12 | use Fluent\Auth\Models\UserModel;
13 | 
14 | use function bin2hex;
15 | use function random_bytes;
16 | 
17 | class NewPasswordController extends BaseController
18 | {
19 |     /**
20 |      * Display the password reset view.
21 |      *
22 |      * @return RendererInterface
23 |      */
24 |     public function new(string $token)
25 |     {
26 |         return view('Auth/reset_password', [
27 |             'email' => $this->request->getVar('email'),
28 |             'token' => $token,
29 |         ]);
30 |     }
31 | 
32 |     /**
33 |      * Handle an incoming new password request.
34 |      *
35 |      * @return RedirectResponse
36 |      */
37 |     public function create()
38 |     {
39 |         $request = (object) $this->request->getPost();
40 | 
41 |         if (! $this->validate(static::rules())) {
42 |             return redirect()->back()->withInput()->with('errors', $this->validator->getErrors());
43 |         }
44 | 
45 |         // Here we will attempt to reset the user's password. If it is successful we
46 |         // will update the password on an actual user model and persist it to the
47 |         // database. Otherwise we will parse the error and return the response.
48 |         $status = Passwords::reset(
49 |             static::credentials($request),
50 |             function ($user) use ($request) {
51 |                 (new UserModel())->update($user->id, new User([
52 |                     'password'       => $request->password,
53 |                     'remember_token' => bin2hex(random_bytes(20)),
54 |                 ]));
55 | 
56 |                 Events::trigger('firePasswordReset', $user);
57 |             }
58 |         );
59 | 
60 |         // If the password was successfully reset, we will redirect the user back to
61 |         // the application's home authenticated view. If there is an error we can
62 |         // redirect them back to where they came from with their error message.
63 |         return $status === PasswordBrokerInterface::PASSWORD_RESET
64 |             ? redirect()->route('login')->with('message', lang($status))
65 |             : redirect()->back()->withInput()->with('error', lang($status));
66 |     }
67 | 
68 |     /**
69 |      * Rules for validation.
70 |      *
71 |      * @return array
72 |      */
73 |     protected static function rules()
74 |     {
75 |         return [
76 |             'email'                 => 'required|valid_email',
77 |             'password'              => 'required|min_length[8]',
78 |             'password_confirmation' => 'matches[password]',
79 |         ];
80 |     }
81 | 
82 |     /**
83 |      * Get the request credentials.
84 |      *
85 |      * @param object $request
86 |      * @return array
87 |      */
88 |     protected static function credentials($request)
89 |     {
90 |         return [
91 |             'token'                 => $request->token,
92 |             'email'                 => $request->email,
93 |             'password'              => $request->password,
94 |             'password_confirmation' => $request->password_confirmation,
95 |         ];
96 |     }
97 | }
98 | 


--------------------------------------------------------------------------------
/src/Views/Auth/layout.php:
--------------------------------------------------------------------------------
 1 | <!--
 2 | 
 3 | =========================================================
 4 | * Volt Free - Bootstrap 5 Dashboard
 5 | =========================================================
 6 | 
 7 | * Product Page: https://themesberg.com/product/admin-dashboard/volt-premium-bootstrap-5-dashboard
 8 | * Copyright 2020 Themesberg (https://www.themesberg.com)
 9 | * License (https://themes.getbootstrap.com/licenses/)
10 | 
11 | * Designed and coded by https://themesberg.com
12 | 
13 | =========================================================
14 | 
15 | * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. Please contact us to request a removal.
16 | 
17 | -->
18 | <!DOCTYPE html>
19 | <html lang="<?= config('App')->defaultLocale ?>">
20 | <head>
21 |     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
22 |     <!-- Primary Meta Tags -->
23 |     <title>CodeIgniter4 Authentication</title>
24 |     <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
25 |     <?= csrf_meta() ?>
26 | 
27 |     <!-- Favicon -->
28 |     <link rel="icon" type="image/png" sizes="32x32" href="/favicon.ico">
29 |     <meta name="msapplication-TileColor" content="#ffffff">
30 |     <meta name="theme-color" content="#ffffff">
31 | 
32 |     <!-- Fontawesome -->
33 |     <link type="text/css" href="https://cdn.jsdelivr.net/npm/@fortawesome/fontawesome-free@5.15.2/css/all.min.css" rel="stylesheet">
34 | 
35 |     <!-- Volt CSS -->
36 |     <link type="text/css" href="https://demo.themesberg.com/volt/css/volt.css" rel="stylesheet">
37 | </head>
38 | <body>
39 |     <main>
40 |         <!-- Section -->
41 |         <?= $this->renderSection('content') ?>
42 |     </main>
43 | 
44 |     <!-- Core -->
45 |     <script src="https://cdn.jsdelivr.net/npm/@popperjs/core@2.6.0/dist/umd/popper.min.js"></script>
46 |     <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.1/dist/js/bootstrap.min.js"></script>
47 | 
48 |     <!-- Volt JS -->
49 |     <script>"use strict";const d=document;d.addEventListener("DOMContentLoaded",function(e){var t=document.getElementById("theme-settings"),o=document.getElementById("theme-settings-expand");if(t){var n=new bootstrap.Collapse(t,{show:!0,toggle:!1});"true"===window.localStorage.getItem("settings_expanded")?(n.show(),o.classList.remove("show")):(n.hide(),o.classList.add("show")),t.addEventListener("hidden.bs.collapse",function(){o.classList.add("show"),window.localStorage.setItem("settings_expanded",!1)}),o.addEventListener("click",function(){o.classList.remove("show"),window.localStorage.setItem("settings_expanded",!0),setTimeout(function(){n.show()},300)})}const l=960;var a=document.getElementById("sidebarMenu");a&&d.body.clientWidth<l&&(a.addEventListener("shown.bs.collapse",function(){document.querySelector("body").style.position="fixed"}),a.addEventListener("hidden.bs.collapse",function(){document.querySelector("body").style.position="relative"})),[].slice.call(d.querySelectorAll("[data-background]")).map(function(e){e.style.background="url("+e.getAttribute("data-background")+")"}),[].slice.call(d.querySelectorAll("[data-background-lg]")).map(function(e){document.body.clientWidth>l&&(e.style.background="url("+e.getAttribute("data-background-lg")+")")}),[].slice.call(d.querySelectorAll("[data-background-color]")).map(function(e){e.style.background="url("+e.getAttribute("data-background-color")+")"}),[].slice.call(d.querySelectorAll("[data-color]")).map(function(e){e.style.color="url("+e.getAttribute("data-color")+")"})});</script>
50 | </body>
51 | </html>


--------------------------------------------------------------------------------
/src/Passwords/PasswordBrokerManager.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Passwords;
  4 | 
  5 | use CodeIgniter\Config\Factories;
  6 | use Fluent\Auth\Config\Auth;
  7 | use Fluent\Auth\Config\Services;
  8 | use Fluent\Auth\Contracts\PasswordBrokerFactoryInterface;
  9 | use Fluent\Auth\Contracts\PasswordBrokerInterface;
 10 | use Fluent\Auth\Contracts\PasswordResetRepositoryInterface;
 11 | use Fluent\Auth\Passwords\PasswordBroker;
 12 | use InvalidArgumentException;
 13 | 
 14 | class PasswordBrokerManager implements PasswordBrokerFactoryInterface
 15 | {
 16 |     /** @var Auth */
 17 |     protected $config;
 18 | 
 19 |     /** @var array */
 20 |     protected $brokers = [];
 21 | 
 22 |     /**
 23 |      * Create a new PasswordBroker manager instance.
 24 |      *
 25 |      * @param bool getShared
 26 |      * @return void
 27 |      */
 28 |     public function __construct(Factories $factory, bool $getShared = true)
 29 |     {
 30 |         $this->config = $factory::config('Auth', ['getShared' => $getShared]);
 31 |     }
 32 | 
 33 |     /**
 34 |      * {@inheritdoc}
 35 |      */
 36 |     public function broker($name = null)
 37 |     {
 38 |         $name = $name ?: $this->getDefaultDriver();
 39 | 
 40 |         return $this->brokers[$name] ?? ($this->brokers[$name] = $this->resolve($name));
 41 |     }
 42 | 
 43 |     /**
 44 |      * Resolve the given broker.
 45 |      *
 46 |      * @param  string  $name
 47 |      * @return PasswordBrokerInterface
 48 |      * @throws InvalidArgumentException
 49 |      */
 50 |     protected function resolve($name)
 51 |     {
 52 |         $config = $this->getConfig($name);
 53 | 
 54 |         // The password broker uses a token repository to validate tokens and send user
 55 |         // password e-mails, as well as validating that password reset process as an
 56 |         // aggregate service of sorts providing a convenient interface for resets.
 57 |         return new PasswordBroker(
 58 |             $this->createTokenRepository($config),
 59 |             Services::auth()->createUserProvider($config['provider'])
 60 |         );
 61 |     }
 62 | 
 63 |     /**
 64 |      * Create a token repository instance based on the given configuration.
 65 |      *
 66 |      * @param  array  $config
 67 |      * @return PasswordResetRepositoryInterface
 68 |      */
 69 |     protected function createTokenRepository(array $config)
 70 |     {
 71 |         return new PasswordResetRepository($config['table'], $config['connection'], $config['expire'], $config['throttle']);
 72 |     }
 73 | 
 74 |     /**
 75 |      * Get the password broker configuration.
 76 |      *
 77 |      * @param  string  $name
 78 |      * @return array
 79 |      */
 80 |     protected function getConfig($name)
 81 |     {
 82 |         if (isset($this->config->passwords[$name])) {
 83 |             return $this->config->passwords[$name];
 84 |         }
 85 | 
 86 |         throw new InvalidArgumentException("Password resetter [{$name}] is not defined.");
 87 |     }
 88 | 
 89 |     /**
 90 |      * {@inheritdoc}
 91 |      */
 92 |     public function getDefaultDriver()
 93 |     {
 94 |         return $this->config->defaults['password'];
 95 |     }
 96 | 
 97 |     /**
 98 |      * {@inheritdoc}
 99 |      */
100 |     public function setDefaultDriver($name)
101 |     {
102 |         $this->config->defaults['password'] = $name;
103 | 
104 |         return $this;
105 |     }
106 | 
107 |     /**
108 |      * Dynamically call the default driver instance.
109 |      *
110 |      * @param  string  $method
111 |      * @param  array  $parameters
112 |      * @return mixed
113 |      */
114 |     public function __call($method, $parameters)
115 |     {
116 |         return $this->broker()->{$method}(...$parameters);
117 |     }
118 | }
119 | 


--------------------------------------------------------------------------------
/src/Authorization/Response.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Authorization;
  4 | 
  5 | use Fluent\Auth\Exceptions\AuthorizationException;
  6 | use Tightenco\Collect\Contracts\Support\Arrayable;
  7 | 
  8 | class Response implements Arrayable
  9 | {
 10 |     /**
 11 |      * Indicates whether the response was allowed.
 12 |      *
 13 |      * @var bool
 14 |      */
 15 |     protected $allowed;
 16 | 
 17 |     /**
 18 |      * The response message.
 19 |      *
 20 |      * @var string|null
 21 |      */
 22 |     protected $message;
 23 | 
 24 |     /**
 25 |      * The response code.
 26 |      *
 27 |      * @var mixed
 28 |      */
 29 |     protected $code;
 30 | 
 31 |     /**
 32 |      * Create a new response.
 33 |      *
 34 |      * @param  bool  $allowed
 35 |      * @param  string  $message
 36 |      * @param  mixed  $code
 37 |      * @return void
 38 |      */
 39 |     public function __construct($allowed, $message = '', $code = null)
 40 |     {
 41 |         $this->code = $code;
 42 |         $this->allowed = $allowed;
 43 |         $this->message = $message;
 44 |     }
 45 | 
 46 |     /**
 47 |      * Create a new "allow" Response.
 48 |      *
 49 |      * @param  string|null  $message
 50 |      * @param  mixed  $code
 51 |      * @return \Fluent\Auth\Authorization\Response
 52 |      */
 53 |     public static function allow($message = null, $code = null)
 54 |     {
 55 |         return new static(true, $message, $code);
 56 |     }
 57 | 
 58 |     /**
 59 |      * Create a new "deny" Response.
 60 |      *
 61 |      * @param  string|null  $message
 62 |      * @param  mixed  $code
 63 |      * @return \Fluent\Auth\Authorization\Response
 64 |      */
 65 |     public static function deny($message = null, $code = null)
 66 |     {
 67 |         return new static(false, $message, $code);
 68 |     }
 69 | 
 70 |     /**
 71 |      * Determine if the response was allowed.
 72 |      *
 73 |      * @return bool
 74 |      */
 75 |     public function allowed()
 76 |     {
 77 |         return $this->allowed;
 78 |     }
 79 | 
 80 |     /**
 81 |      * Determine if the response was denied.
 82 |      *
 83 |      * @return bool
 84 |      */
 85 |     public function denied()
 86 |     {
 87 |         return ! $this->allowed();
 88 |     }
 89 | 
 90 |     /**
 91 |      * Get the response message.
 92 |      *
 93 |      * @return string|null
 94 |      */
 95 |     public function message()
 96 |     {
 97 |         return $this->message;
 98 |     }
 99 | 
100 |     /**
101 |      * Get the response code / reason.
102 |      *
103 |      * @return mixed
104 |      */
105 |     public function code()
106 |     {
107 |         return $this->code;
108 |     }
109 | 
110 |     /**
111 |      * Throw authorization exception if response was denied.
112 |      *
113 |      * @return \Fluent\Auth\Authorization\Response
114 |      *
115 |      * @throws \Fluent\Auth\Authorization\AuthorizationException
116 |      */
117 |     public function authorize()
118 |     {
119 |         if ($this->denied()) {
120 |             throw (new AuthorizationException($this->message(), $this->code()))
121 |                         ->setResponse($this);
122 |         }
123 | 
124 |         return $this;
125 |     }
126 | 
127 |     /**
128 |      * Convert the response to an array.
129 |      *
130 |      * @return array
131 |      */
132 |     public function toArray()
133 |     {
134 |         return [
135 |             'allowed' => $this->allowed(),
136 |             'message' => $this->message(),
137 |             'code' => $this->code(),
138 |         ];
139 |     }
140 | 
141 |     /**
142 |      * Get the string representation of the message.
143 |      *
144 |      * @return string
145 |      */
146 |     public function __toString()
147 |     {
148 |         return (string) $this->message();
149 |     }
150 | }
151 | 


--------------------------------------------------------------------------------
/src/UserDatabase.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth;
  4 | 
  5 | use CodeIgniter\Database\BaseBuilder;
  6 | use CodeIgniter\Database\Config;
  7 | use Fluent\Auth\Contracts\AuthenticatorInterface;
  8 | use Fluent\Auth\Contracts\UserProviderInterface;
  9 | use Fluent\Auth\Entities\User;
 10 | use Fluent\Auth\Facades\Hash;
 11 | use Fluent\Auth\Helpers\Str;
 12 | 
 13 | use function array_key_exists;
 14 | use function count;
 15 | use function hash_equals;
 16 | use function is_array;
 17 | 
 18 | class UserDatabase implements UserProviderInterface
 19 | {
 20 |     /**
 21 |      * The active database connection.
 22 |      *
 23 |      * @var BaseBuilder
 24 |      */
 25 |     protected $connection;
 26 | 
 27 |     /**
 28 |      * Create a new database user provider.
 29 |      *
 30 |      * @param string|null $connection
 31 |      * @return void
 32 |      */
 33 |     public function __construct(string $table, $connection = null)
 34 |     {
 35 |         $this->connection = Config::connect($connection)->table($table);
 36 |     }
 37 | 
 38 |     /**
 39 |      * {@inheritdoc}
 40 |      */
 41 |     public function findById($userId)
 42 |     {
 43 |         return $this->connection->where('id', $userId)->get()->getFirstRow(User::class);
 44 |     }
 45 | 
 46 |     /**
 47 |      * {@inheritdoc}
 48 |      */
 49 |     public function findByRememberToken($userId, $token)
 50 |     {
 51 |         $retriveDatabase = $this->connection->where('id', $userId)->get()->getFirstRow(User::class);
 52 | 
 53 |         $rememberToken = $retriveDatabase->getRememberToken();
 54 | 
 55 |         return $rememberToken && hash_equals($rememberToken, $token)
 56 |             ? $retriveDatabase
 57 |             : null;
 58 |     }
 59 | 
 60 |     /**
 61 |      * {@inheritdoc}
 62 |      */
 63 |     public function updateRememberToken(AuthenticatorInterface $user, $token)
 64 |     {
 65 |         return $this->connection
 66 |             ->where($user->getAuthIdColumn(), $user->getAuthId())
 67 |             ->set($user->getRememberColumn(), $token)
 68 |             ->update();
 69 |     }
 70 | 
 71 |     /**
 72 |      * {@inheritdoc}
 73 |      */
 74 |     public function findByCredentials(array $credentials)
 75 |     {
 76 |         if (
 77 |             empty($credentials) ||
 78 |             (count($credentials) === 1 &&
 79 |             array_key_exists('password', $credentials))
 80 |         ) {
 81 |             return;
 82 |         }
 83 | 
 84 |         // First we will add each credential element to the query as a where clause.
 85 |         // Then we can execute the query and, if we found a user, return it in a
 86 |         // generic "user" object that will be utilized by the Guard instances.
 87 |         $query = $this->connection;
 88 | 
 89 |         foreach ($credentials as $key => $value) {
 90 |             if (Str::contains($key, 'password')) {
 91 |                 continue;
 92 |             }
 93 | 
 94 |             if (is_array($value)) {
 95 |                 $query->whereIn($key, $value);
 96 |             } else {
 97 |                 $query->where($key, $value);
 98 |             }
 99 |         }
100 | 
101 |         // Now we are ready to execute the query to see if we have an user matching
102 |         // the given credentials. If not, we will just return nulls and indicate
103 |         // that there are no matching users for these given credential arrays.
104 |         return $query->get()->getFirstRow(User::class);
105 |     }
106 | 
107 |     /**
108 |      * {@inheritdoc}
109 |      */
110 |     public function validateCredentials(AuthenticatorInterface $user, array $credentials)
111 |     {
112 |         return Hash::check($credentials['password'], $user->getAuthPassword());
113 |     }
114 | 
115 |     /**
116 |      * {@inheritdoc}
117 |      */
118 |     public function instance()
119 |     {
120 |         return $this->connection;
121 |     }
122 | }
123 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # CodeIgniter4 Authentication
  2 | 
  3 | [![tests](https://github.com/agungsugiarto/codeigniter4-authentication/actions/workflows/php.yml/badge.svg)](https://github.com/agungsugiarto/codeigniter4-authentication/actions/workflows/php.yml)
  4 | [![Latest Stable Version](https://poser.pugx.org/agungsugiarto/codeigniter4-authentication/v)](https://github.com/agungsugiarto/codeigniter4-authentication/releases)
  5 | [![Total Downloads](https://poser.pugx.org/agungsugiarto/codeigniter4-authentication/downloads)](https://packagist.org/packages/agungsugiarto/codeigniter4-authentication/stats)
  6 | [![Latest Unstable Version](https://poser.pugx.org/agungsugiarto/codeigniter4-authentication/v/unstable)](https://packagist.org/packages/agungsugiarto/codeigniter4-authentication)
  7 | [![License](https://poser.pugx.org/agungsugiarto/codeigniter4-authentication/license)](https://github.com/agungsugiarto/codeigniter4-authentication/blob/master/LICENSE.md)
  8 | 
  9 | ## About
 10 | The `codeigniter4\authentication` component provides an API for authentication and
 11 | includes concrete authentication adapters for common use case scenarios.
 12 | 
 13 | - Inspired from https://github.com/lonnieezell/codigniter-shield
 14 | - Most inspired from auth by laravel https://github.com/illuminate/auth
 15 | 
 16 | ## Upgrade from v1.x to 2.x
 17 | ### Composer Dependencies
 18 | You should update the following dependencies in your application's composer.json file:
 19 | 
 20 | `agungsugiarto/codeigniter4-authentication` to `^2.0`
 21 | 
 22 | ### User Entity
 23 | 
 24 | Open class `App\Entities\User` add interface and trait to implement.
 25 | ```diff
 26 | namespace Fluent\Auth\Entities;
 27 | 
 28 | - use CodeIgniter\Entity;
 29 | + use CodeIgniter\Entity\Entity;
 30 | use Fluent\Auth\Contracts\AuthenticatorInterface;
 31 | + use Fluent\Auth\Contracts\AuthorizableInterface;
 32 | use Fluent\Auth\Contracts\HasAccessTokensInterface;
 33 | use Fluent\Auth\Contracts\ResetPasswordInterface;
 34 | use Fluent\Auth\Contracts\VerifyEmailInterface;
 35 | use Fluent\Auth\Facades\Hash;
 36 | use Fluent\Auth\Traits\AuthenticatableTrait;
 37 | use Fluent\Auth\Traits\AuthorizableTrait;
 38 | use Fluent\Auth\Traits\CanResetPasswordTrait;
 39 | use Fluent\Auth\Traits\HasAccessTokensTrait;
 40 | use Fluent\Auth\Traits\MustVerifyEmailTrait;
 41 | 
 42 | class User extends Entity implements
 43 |     AuthenticatorInterface,
 44 | +   AuthorizableInterface,
 45 |     HasAccessTokensInterface,
 46 |     ResetPasswordInterface,
 47 |     VerifyEmailInterface
 48 | {
 49 |     use AuthenticatableTrait;
 50 | +   use AuthorizableTrait;
 51 |     use CanResetPasswordTrait;
 52 |     use HasAccessTokensTrait;
 53 |     use MustVerifyEmailTrait;
 54 | }
 55 | ```
 56 | 
 57 | ### AuthServiceProvider
 58 | 
 59 | Open `App\Providers\AuthServiceProvider`
 60 | ```diff
 61 | namespace Fluent\Auth;
 62 | 
 63 | + use Fluent\Auth\Facades\Gate;
 64 | use Fluent\Auth\AbstractServiceProvider;
 65 | 
 66 | class AuthServiceProvider extends AbstractServiceProvider
 67 | {
 68 | +   /**
 69 | +    * The policy mappings for the application.
 70 | +    *
 71 | +    * @var array<class-string, class-string>
 72 | +    */
 73 | +   protected static $policies = [];
 74 | 
 75 |     /**
 76 |      * {@inheritdoc}
 77 |      */
 78 |     public static function register()
 79 |     {
 80 | +        static::registerPolicies();
 81 |     }
 82 | }
 83 | ```
 84 | 
 85 | ## Documentation
 86 | - [Authentication](docs/en/authentication.md)
 87 | - [Authorization](docs/en/authorization.md)
 88 | 
 89 | ## Community Authentication Guards
 90 | - JWT (JSON Web Token) - [agungsugiarto/codeigniter4-authentication-jwt](https://github.com/agungsugiarto/codeigniter4-authentication-jwt)
 91 | 
 92 | ## Authentication Demo
 93 | - [codeigniter4-authentication-demo](https://github.com/agungsugiarto/codeigniter4-authentication-demo)
 94 | 
 95 | Changelog
 96 | --------
 97 | Please see [CHANGELOG](CHANGELOG.md) for more information what has changed recently.
 98 | 
 99 | ## Contributing
100 | Contributions are very welcome.
101 | 
102 | ## License
103 | 
104 | Released under the MIT License, see [LICENSE](LICENSE.md).
105 | 


--------------------------------------------------------------------------------
/src/Passwords/RateLimiter.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Passwords;
  4 | 
  5 | use Closure;
  6 | use CodeIgniter\Cache\CacheInterface;
  7 | use CodeIgniter\Config\Services;
  8 | use Fluent\Auth\Traits\InteractsWithTimeTrait;
  9 | 
 10 | class RateLimiter
 11 | {
 12 |     use InteractsWithTimeTrait;
 13 | 
 14 |     /**
 15 |      * The cache store implementation.
 16 |      *
 17 |      * @var CacheInterface
 18 |      */
 19 |     protected $cache;
 20 | 
 21 |     /**
 22 |      * The configured limit object resolvers.
 23 |      *
 24 |      * @var array
 25 |      */
 26 |     protected $limiters = [];
 27 | 
 28 |     /**
 29 |      * Create a new rate limiter instance.
 30 |      *
 31 |      * @return void
 32 |      */
 33 |     public function __construct()
 34 |     {
 35 |         $this->cache = Services::cache();
 36 |     }
 37 | 
 38 |     /**
 39 |      * Register a named limiter configuration.
 40 |      *
 41 |      * @return $this
 42 |      */
 43 |     public function for(string $name, Closure $callback)
 44 |     {
 45 |         $this->limiters[$name] = $callback;
 46 | 
 47 |         return $this;
 48 |     }
 49 | 
 50 |     /**
 51 |      * Get the given named rate limiter.
 52 |      *
 53 |      * @return Closure
 54 |      */
 55 |     public function limiter(string $name)
 56 |     {
 57 |         return $this->limiters[$name] ?? null;
 58 |     }
 59 | 
 60 |     /**
 61 |      * Determine if the given key has been "accessed" too many times.
 62 |      *
 63 |      * @param  string  $key
 64 |      * @param  int  $maxAttempts
 65 |      * @return bool
 66 |      */
 67 |     public function tooManyAttempts($key, $maxAttempts)
 68 |     {
 69 |         if ($this->attempts($key) >= $maxAttempts) {
 70 |             if ($this->cache->get($key . '_timer')) {
 71 |                 return true;
 72 |             }
 73 | 
 74 |             $this->resetAttempts($key);
 75 |         }
 76 | 
 77 |         return false;
 78 |     }
 79 | 
 80 |     /**
 81 |      * Increment the counter for a given key for a given decay time.
 82 |      *
 83 |      * @param  string  $key
 84 |      * @param  int  $decaySeconds
 85 |      * @return int
 86 |      */
 87 |     public function hit($key, $decaySeconds = 60)
 88 |     {
 89 |         $this->cache->save(
 90 |             $key . '_timer',
 91 |             $this->availableAt($decaySeconds),
 92 |             $decaySeconds
 93 |         );
 94 | 
 95 |         $this->cache->remember($key, $decaySeconds, function () {
 96 |             return 0;
 97 |         });
 98 | 
 99 |         return $this->cache->increment($key);
100 |     }
101 | 
102 |     /**
103 |      * Get the number of attempts for the given key.
104 |      *
105 |      * @param  string  $key
106 |      * @return mixed
107 |      */
108 |     public function attempts($key)
109 |     {
110 |         return $this->cache->get($key) ?? 0;
111 |     }
112 | 
113 |     /**
114 |      * Reset the number of attempts for the given key.
115 |      *
116 |      * @param  string  $key
117 |      * @return mixed
118 |      */
119 |     public function resetAttempts($key)
120 |     {
121 |         return $this->cache->delete($key);
122 |     }
123 | 
124 |     /**
125 |      * Get the number of retries left for the given key.
126 |      *
127 |      * @param  string  $key
128 |      * @param  int  $maxAttempts
129 |      * @return int
130 |      */
131 |     public function retriesLeft($key, $maxAttempts)
132 |     {
133 |         $attempts = $this->attempts($key);
134 | 
135 |         return $maxAttempts - $attempts;
136 |     }
137 | 
138 |     /**
139 |      * Clear the hits and lockout timer for the given key.
140 |      *
141 |      * @param  string  $key
142 |      * @return void
143 |      */
144 |     public function clear($key)
145 |     {
146 |         $this->resetAttempts($key);
147 | 
148 |         $this->cache->delete($key . '_timer');
149 |     }
150 | 
151 |     /**
152 |      * Get the number of seconds until the "key" is accessible again.
153 |      *
154 |      * @param  string  $key
155 |      * @return int
156 |      */
157 |     public function availableIn($key)
158 |     {
159 |         return $this->cache->get($key . '_timer') - $this->currentTime();
160 |     }
161 | }
162 | 


--------------------------------------------------------------------------------
/src/Controllers/Auth/AuthenticatedSessionController.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace App\Controllers\Auth;
  4 | 
  5 | use App\Controllers\BaseController;
  6 | use CodeIgniter\Http\RedirectResponse;
  7 | use CodeIgniter\View\RendererInterface;
  8 | use Fluent\Auth\Facades\Auth;
  9 | use Fluent\Auth\Facades\RateLimiter;
 10 | 
 11 | use function func_get_args;
 12 | use function is_array;
 13 | use function is_bool;
 14 | use function trim;
 15 | 
 16 | class AuthenticatedSessionController extends BaseController
 17 | {
 18 |     /**
 19 |      * Max attempt login throttle.
 20 |      *
 21 |      * @var int
 22 |      */
 23 |     const MAX_ATTEMPT = 5;
 24 | 
 25 |     /**
 26 |      * Decay in second if failed attempt.
 27 |      *
 28 |      * @var int
 29 |      */
 30 |     const DECAY_SECOND = 60;
 31 | 
 32 |     /**
 33 |      * Display the login view.
 34 |      *
 35 |      * @return RendererInterface
 36 |      */
 37 |     public function new()
 38 |     {
 39 |         return view('Auth/login');
 40 |     }
 41 | 
 42 |     /**
 43 |      * Handle an incoming authentication request.
 44 |      *
 45 |      * @return RedirectResponse
 46 |      */
 47 |     public function create()
 48 |     {
 49 |         // Populate request to object.
 50 |         $request = (object) $this->request->getPost();
 51 | 
 52 |         // Credentials for attempt login.
 53 |         $credentials = ['email' => $request->email, 'password' => $request->password];
 54 | 
 55 |         // Credential if remember.
 56 |         $remember = $this->filled('remember');
 57 | 
 58 |         // Rate limiter how many can be attempt.
 59 |         if (RateLimiter::tooManyAttempts($this->throttleKey(), static::MAX_ATTEMPT)) {
 60 |             $seconds = RateLimiter::availableIn($this->throttleKey());
 61 | 
 62 |             return redirect()->back()->withInput()->with('error', lang('Auth.throttle', [$seconds]));
 63 |         }
 64 | 
 65 |         // Validate this credentials request.
 66 |         if (! $this->validate(['email' => 'required|valid_email', 'password' => 'required'])) {
 67 |             return redirect()->back()->withInput()->with('errors', $this->validator->getErrors());
 68 |         }
 69 | 
 70 |         // Try to login this credentials.
 71 |         if (! Auth::attempt($credentials, $remember)) {
 72 |             // Save throttle state.
 73 |             RateLimiter::hit($this->throttleKey(), static::DECAY_SECOND);
 74 | 
 75 |             return redirect()->back()->withInput()->with('error', lang('Auth.failed'));
 76 |         }
 77 | 
 78 |         // Clear the throttle key
 79 |         RateLimiter::clear($this->throttleKey());
 80 | 
 81 |         // Finnaly we're success login.
 82 |         return redirect(config('Auth')->home)->withCookies();
 83 |     }
 84 | 
 85 |     /**
 86 |      * Destroy an authenticated session.
 87 |      *
 88 |      * @return RedirectResponse
 89 |      */
 90 |     public function delete()
 91 |     {
 92 |         Auth::logout();
 93 | 
 94 |         return redirect('/')->withCookies();
 95 |     }
 96 | 
 97 |     /**
 98 |      * Determine if the request contains a non-empty value for an input item.
 99 |      *
100 |      * @param  string|array  $key
101 |      * @return bool
102 |      */
103 |     protected function filled($key)
104 |     {
105 |         $keys = is_array($key) ? $key : func_get_args();
106 | 
107 |         foreach ($keys as $value) {
108 |             if ($this->isEmptyString($value)) {
109 |                 return false;
110 |             }
111 |         }
112 | 
113 |         return true;
114 |     }
115 | 
116 |     /**
117 |      * Determine if the given input key is an empty string for "has".
118 |      *
119 |      * @param  string  $key
120 |      * @return bool
121 |      */
122 |     protected function isEmptyString($key)
123 |     {
124 |         $value = $this->request->getVar($key);
125 | 
126 |         return ! is_bool($value) && ! is_array($value) && trim((string) $value) === '';
127 |     }
128 | 
129 |     /**
130 |      * Get the rate limiting throttle key for the request.
131 |      *
132 |      * @param object $request
133 |      * @return string
134 |      */
135 |     public function throttleKey()
136 |     {
137 |         return md5("{$this->request->getPost('email')}|{$this->request->getIPAddress()}");
138 |     }
139 | }
140 | 


--------------------------------------------------------------------------------
/src/Passwords/PasswordResetRepository.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Passwords;
  4 | 
  5 | use CodeIgniter\Database\BaseBuilder;
  6 | use CodeIgniter\Database\Config;
  7 | use CodeIgniter\I18n\Time;
  8 | use Fluent\Auth\Contracts\PasswordResetRepositoryInterface;
  9 | use Fluent\Auth\Contracts\ResetPasswordInterface;
 10 | use Fluent\Auth\Facades\Hash;
 11 | 
 12 | use function bin2hex;
 13 | use function hash_hmac;
 14 | use function random_bytes;
 15 | 
 16 | class PasswordResetRepository implements PasswordResetRepositoryInterface
 17 | {
 18 |     /**
 19 |      * The active database connection.
 20 |      *
 21 |      * @var BaseBuilder
 22 |      */
 23 |     protected $connection;
 24 | 
 25 |     /**
 26 |      * The number of seconds a token should last.
 27 |      *
 28 |      * @var int
 29 |      */
 30 |     protected $expires;
 31 | 
 32 |     /**
 33 |      * Minimum number of seconds before re-redefining the token.
 34 |      *
 35 |      * @var int
 36 |      */
 37 |     protected $throttle;
 38 | 
 39 |     /**
 40 |      * Create new token repository instance.
 41 |      * 
 42 |      * @param string|null $connection
 43 |      * @return void
 44 |      */
 45 |     public function __construct(string $table, $connection = null, int $expires = 60, int $throttle = 60)
 46 |     {
 47 |         $this->connection = Config::connect($connection)->table($table);
 48 |         $this->expires    = $expires * 60;
 49 |         $this->throttle   = $throttle;
 50 |     }
 51 | 
 52 |     /**
 53 |      * {@inheritdoc}
 54 |      */
 55 |     public function create(ResetPasswordInterface $user)
 56 |     {
 57 |         $email = $user->getEmailForPasswordReset();
 58 | 
 59 |         $this->destroy($user);
 60 | 
 61 |         // We will create a new, random token for the user so that we can e-mail them
 62 |         // a safe link to the password reset form. Then we will insert a record in
 63 |         // the database so that we can verify the token within the actual reset.
 64 |         $token = $this->createNewToken();
 65 | 
 66 |         $this->connection->insert($this->getPayload($email, $token));
 67 | 
 68 |         return $token;
 69 |     }
 70 | 
 71 |     /**
 72 |      * {@inheritdoc}
 73 |      */
 74 |     public function createNewToken()
 75 |     {
 76 |         return hash_hmac('sha256', bin2hex(random_bytes(20)), config('Encryption')->key);
 77 |     }
 78 | 
 79 |     /**
 80 |      * {@inheritdoc}
 81 |      */
 82 |     public function exists(ResetPasswordInterface $user, $token)
 83 |     {
 84 |         $record = $this->connection->where('email', $user->getEmailForPasswordReset())->get()->getFirstRow();
 85 | 
 86 |         $expiredAt = Time::now()->subSeconds($this->expires);
 87 | 
 88 |         return $record && ! $record->created_at < $expiredAt && Hash::check($token, $record->token);
 89 |     }
 90 | 
 91 |     /**
 92 |      * {@inheritdoc}
 93 |      */
 94 |     public function recentlyCreatedToken(ResetPasswordInterface $user)
 95 |     {
 96 |         if ($this->throttle <= 0) {
 97 |             return false;
 98 |         }
 99 | 
100 |         $record = $this->connection->where('email', $user->getEmailForPasswordReset())->get()->getFirstRow();
101 | 
102 |         $expiredAt = Time::now()->subSeconds($this->throttle);
103 | 
104 |         return $record && $record->created_at > $expiredAt;
105 |     }
106 | 
107 |     /**
108 |      * {@inheritdoc}
109 |      */
110 |     public function destroy(ResetPasswordInterface $user)
111 |     {
112 |         return $this->connection->where('email', $user->getEmailForPasswordReset())->delete();
113 |     }
114 | 
115 |     /**
116 |      * {@inheritdoc}
117 |      */
118 |     public function destroyExpired()
119 |     {
120 |         $expiredAt = Time::now()->subSeconds($this->expires);
121 | 
122 |         return $this->connection->where('created_at <', $expiredAt)->delete();
123 |     }
124 | 
125 |     /**
126 |      * Build the record payload for the table.
127 |      *
128 |      * @param  string  $email
129 |      * @param  string  $token
130 |      * @return array
131 |      */
132 |     protected function getPayload($email, $token)
133 |     {
134 |         return [
135 |             'email'      => $email,
136 |             'token'      => Hash::make($token),
137 |             'created_at' => Time::now(),
138 |             'updated_at' => Time::now(),
139 |         ];
140 |     }
141 | }
142 | 


--------------------------------------------------------------------------------
/src/Contracts/GateInterface.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Contracts;
  4 | 
  5 | interface GateInterface
  6 | {
  7 |     /**
  8 |      * Determine if a given ability has been defined.
  9 |      *
 10 |      * @param  string  $ability
 11 |      * @return bool
 12 |      */
 13 |     public function has($ability);
 14 | 
 15 |     /**
 16 |      * Define a new ability.
 17 |      *
 18 |      * @param  string  $ability
 19 |      * @param  callable|string  $callback
 20 |      * @return $this
 21 |      */
 22 |     public function define($ability, $callback);
 23 | 
 24 |     /**
 25 |      * Define abilities for a resource.
 26 |      *
 27 |      * @param  string  $name
 28 |      * @param  string  $class
 29 |      * @param  array|null  $abilities
 30 |      * @return $this
 31 |      */
 32 |     public function resource($name, $class, array $abilities = null);
 33 | 
 34 |     /**
 35 |      * Define a policy class for a given class type.
 36 |      *
 37 |      * @param  string  $class
 38 |      * @param  string  $policy
 39 |      * @return $this
 40 |      */
 41 |     public function policy($class, $policy);
 42 | 
 43 |     /**
 44 |      * Register a callback to run before all Gate checks.
 45 |      *
 46 |      * @param  callable  $callback
 47 |      * @return $this
 48 |      */
 49 |     public function before(callable $callback);
 50 | 
 51 |     /**
 52 |      * Register a callback to run after all Gate checks.
 53 |      *
 54 |      * @param  callable  $callback
 55 |      * @return $this
 56 |      */
 57 |     public function after(callable $callback);
 58 | 
 59 |     /**
 60 |      * Determine if the given ability should be granted for the current user.
 61 |      *
 62 |      * @param  string  $ability
 63 |      * @param  array|mixed  $arguments
 64 |      * @return bool
 65 |      */
 66 |     public function allows($ability, $arguments = []);
 67 | 
 68 |     /**
 69 |      * Determine if the given ability should be denied for the current user.
 70 |      *
 71 |      * @param  string  $ability
 72 |      * @param  array|mixed  $arguments
 73 |      * @return bool
 74 |      */
 75 |     public function denies($ability, $arguments = []);
 76 | 
 77 |     /**
 78 |      * Determine if all of the given abilities should be granted for the current user.
 79 |      *
 80 |      * @param  iterable|string  $abilities
 81 |      * @param  array|mixed  $arguments
 82 |      * @return bool
 83 |      */
 84 |     public function check($abilities, $arguments = []);
 85 | 
 86 |     /**
 87 |      * Determine if any one of the given abilities should be granted for the current user.
 88 |      *
 89 |      * @param  iterable|string  $abilities
 90 |      * @param  array|mixed  $arguments
 91 |      * @return bool
 92 |      */
 93 |     public function any($abilities, $arguments = []);
 94 | 
 95 |     /**
 96 |      * Determine if the given ability should be granted for the current user.
 97 |      *
 98 |      * @param  string  $ability
 99 |      * @param  array|mixed  $arguments
100 |      * @return \Fluent\Auth\Authorization\Response
101 |      *
102 |      * @throws \FLuent\Auth\Exceptions\AuthorizationException
103 |      */
104 |     public function authorize($ability, $arguments = []);
105 | 
106 |     /**
107 |      * Inspect the user for the given ability.
108 |      *
109 |      * @param  string  $ability
110 |      * @param  array|mixed  $arguments
111 |      * @return \Fluent\Auth\Authorization\Response
112 |      */
113 |     public function inspect($ability, $arguments = []);
114 | 
115 |     /**
116 |      * Get the raw result from the authorization callback.
117 |      *
118 |      * @param  string  $ability
119 |      * @param  array|mixed  $arguments
120 |      * @return mixed
121 |      *
122 |      * @throws \FLuent\Auth\Exceptions\AuthorizationException
123 |      */
124 |     public function raw($ability, $arguments = []);
125 | 
126 |     /**
127 |      * Get a policy instance for a given class.
128 |      *
129 |      * @param  object|string  $class
130 |      * @return mixed
131 |      *
132 |      * @throws \InvalidArgumentException
133 |      */
134 |     public function getPolicyFor($class);
135 | 
136 |     /**
137 |      * Get a guard instance for the given user.
138 |      *
139 |      * @param  \Fluent\Auth\Contracts\AuthenticatorInterface $user
140 |      * @return static
141 |      */
142 |     public function forUser($user);
143 | 
144 |     /**
145 |      * Get all of the defined abilities.
146 |      *
147 |      * @return array
148 |      */
149 |     public function abilities();
150 | }
151 | 


--------------------------------------------------------------------------------
/src/Traits/InteractsWithAuthentication.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Traits;
  4 | 
  5 | use Fluent\Auth\Contracts\AuthenticatorInterface;
  6 | 
  7 | trait InteractsWithAuthentication
  8 | {
  9 |     /**
 10 |      * Set the currently logged in user for the application.
 11 |      *
 12 |      * @param  \Fluent\Auth\Contracts\AuthenticatorInterface  $user
 13 |      * @param  string|null  $guard
 14 |      * @return $this
 15 |      */
 16 |     public function actingAs(AuthenticatorInterface $user, $guard = null)
 17 |     {
 18 |         return $this->be($user, $guard);
 19 |     }
 20 | 
 21 |     /**
 22 |      * Set the currently logged in user for the application.
 23 |      *
 24 |      * @param  \Fluent\Auth\Contracts\AuthenticatorInterface  $user
 25 |      * @param  string|null  $guard
 26 |      * @return $this
 27 |      */
 28 |     public function be(AuthenticatorInterface $user, $guard = null)
 29 |     {
 30 |         auth()->guard($guard)->setUser($user);
 31 | 
 32 |         auth()->shouldUse($guard);
 33 | 
 34 |         return $this;
 35 |     }
 36 | 
 37 |     /**
 38 |      * Assert that the user is authenticated.
 39 |      *
 40 |      * @param  string|null  $guard
 41 |      * @return $this
 42 |      */
 43 |     public function assertAuthenticated($guard = null)
 44 |     {
 45 |         $this->assertTrue($this->isAuthenticated($guard), 'The user is not authenticated');
 46 | 
 47 |         return $this;
 48 |     }
 49 | 
 50 |     /**
 51 |      * Assert that the user is not authenticated.
 52 |      *
 53 |      * @param  string|null  $guard
 54 |      * @return $this
 55 |      */
 56 |     public function assertGuest($guard = null)
 57 |     {
 58 |         $this->assertFalse($this->isAuthenticated($guard), 'The user is authenticated');
 59 | 
 60 |         return $this;
 61 |     }
 62 | 
 63 |     /**
 64 |      * Return true if the user is authenticated, false otherwise.
 65 |      *
 66 |      * @param  string|null  $guard
 67 |      * @return bool
 68 |      */
 69 |     protected function isAuthenticated($guard = null)
 70 |     {
 71 |         return auth()->guard($guard)->check();
 72 |     }
 73 | 
 74 |     /**
 75 |      * Assert that the user is authenticated as the given user.
 76 |      *
 77 |      * @param  \Fluent\Auth\Contracts\AuthenticatorInterface  $user
 78 |      * @param  string|null  $guard
 79 |      * @return $this
 80 |      */
 81 |     public function assertAuthenticatedAs($user, $guard = null)
 82 |     {
 83 |         $expected = auth()->guard($guard)->user();
 84 | 
 85 |         $this->assertNotNull($expected, 'The current user is not authenticated.');
 86 | 
 87 |         $this->assertInstanceOf(
 88 |             get_class($expected), $user,
 89 |             'The currently authenticated user is not who was expected'
 90 |         );
 91 | 
 92 |         $this->assertSame(
 93 |             $expected->getAuthId(), $user->getAuthId(),
 94 |             'The currently authenticated user is not who was expected'
 95 |         );
 96 | 
 97 |         return $this;
 98 |     }
 99 | 
100 |     /**
101 |      * Assert that the given credentials are valid.
102 |      *
103 |      * @param  array  $credentials
104 |      * @param  string|null  $guard
105 |      * @return $this
106 |      */
107 |     public function assertCredentials(array $credentials, $guard = null)
108 |     {
109 |         $this->assertTrue(
110 |             $this->hasCredentials($credentials, $guard), 'The given credentials are invalid.'
111 |         );
112 | 
113 |         return $this;
114 |     }
115 | 
116 |     /**
117 |      * Assert that the given credentials are invalid.
118 |      *
119 |      * @param  array  $credentials
120 |      * @param  string|null  $guard
121 |      * @return $this
122 |      */
123 |     public function assertInvalidCredentials(array $credentials, $guard = null)
124 |     {
125 |         $this->assertFalse(
126 |             $this->hasCredentials($credentials, $guard), 'The given credentials are valid.'
127 |         );
128 | 
129 |         return $this;
130 |     }
131 | 
132 |     /**
133 |      * Return true if the credentials are valid, false otherwise.
134 |      *
135 |      * @param  array  $credentials
136 |      * @param  string|null  $guard
137 |      * @return bool
138 |      */
139 |     protected function hasCredentials(array $credentials, $guard = null)
140 |     {
141 |         $provider = auth()->guard($guard)->getProvider();
142 | 
143 |         $user = $provider->findByCredentials($credentials);
144 | 
145 |         return $user && $provider->validateCredentials($user, $credentials);
146 |     }
147 | }


--------------------------------------------------------------------------------
/src/Passwords/Hash/AbstractManager.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Passwords\Hash;
  4 | 
  5 | use Closure;
  6 | use CodeIgniter\Config\Factories;
  7 | use Fluent\Auth\Config\Hashing;
  8 | use InvalidArgumentException;
  9 | 
 10 | use function is_null;
 11 | use function method_exists;
 12 | use function sprintf;
 13 | use function ucfirst;
 14 | 
 15 | abstract class AbstractManager
 16 | {
 17 |     /**
 18 |      * The configuration repository instance.
 19 |      *
 20 |      * @var Hashing
 21 |      */
 22 |     protected $config;
 23 | 
 24 |     /**
 25 |      * The registered custom driver creators.
 26 |      *
 27 |      * @var array
 28 |      */
 29 |     protected $customCreators = [];
 30 | 
 31 |     /**
 32 |      * The array of created "drivers".
 33 |      *
 34 |      * @var array
 35 |      */
 36 |     protected $drivers = [];
 37 | 
 38 |     /**
 39 |      * Create a new manager instance.
 40 |      *
 41 |      * @param bool getShared
 42 |      * @return void
 43 |      */
 44 |     public function __construct(Factories $factory, bool $getShared = true)
 45 |     {
 46 |         $this->config = $factory::config('Hashing', ['getShared' => $getShared]);
 47 |     }
 48 | 
 49 |     /**
 50 |      * Get the default driver name.
 51 |      *
 52 |      * @return string
 53 |      */
 54 |     abstract public function getDefaultDriver();
 55 | 
 56 |     /**
 57 |      * Get a driver instance.
 58 |      *
 59 |      * @param  string|null  $driver
 60 |      * @return mixed
 61 |      * @throws InvalidArgumentException
 62 |      */
 63 |     public function driver($driver = null)
 64 |     {
 65 |         $driver = $driver ?: $this->getDefaultDriver();
 66 | 
 67 |         if (is_null($driver)) {
 68 |             throw new InvalidArgumentException(sprintf(
 69 |                 'Unable to resolve NULL driver for [%s].',
 70 |                 static::class
 71 |             ));
 72 |         }
 73 | 
 74 |         // If the given driver has not been created before, we will create the instances
 75 |         // here and cache it so we can return it next time very quickly. If there is
 76 |         // already a driver created by this name, we'll just return that instance.
 77 |         if (! isset($this->drivers[$driver])) {
 78 |             $this->drivers[$driver] = $this->createDriver($driver);
 79 |         }
 80 | 
 81 |         return $this->drivers[$driver];
 82 |     }
 83 | 
 84 |     /**
 85 |      * Create a new driver instance.
 86 |      *
 87 |      * @param  string  $driver
 88 |      * @return mixed
 89 |      * @throws InvalidArgumentException
 90 |      */
 91 |     protected function createDriver($driver)
 92 |     {
 93 |         // First, we will determine if a custom driver creator exists for the given driver and
 94 |         // if it does not we will check for a creator method for the driver. Custom creator
 95 |         // callbacks allow developers to build their own "drivers" easily using Closures.
 96 |         if (isset($this->customCreators[$driver])) {
 97 |             return $this->callCustomCreator($driver);
 98 |         } else {
 99 |             $method = 'create' . ucfirst($driver) . 'Driver';
100 | 
101 |             if (method_exists($this, $method)) {
102 |                 return $this->$method();
103 |             }
104 |         }
105 | 
106 |         throw new InvalidArgumentException("Driver [$driver] not supported.");
107 |     }
108 | 
109 |     /**
110 |      * Call a custom driver creator.
111 |      *
112 |      * @param  string  $driver
113 |      * @return mixed
114 |      */
115 |     protected function callCustomCreator($driver)
116 |     {
117 |         return $this->customCreators[$driver]($this->config);
118 |     }
119 | 
120 |     /**
121 |      * Register a custom driver creator Closure.
122 |      *
123 |      * @param  string  $driver
124 |      * @return $this
125 |      */
126 |     public function extend($driver, Closure $callback)
127 |     {
128 |         $this->customCreators[$driver] = $callback;
129 | 
130 |         return $this;
131 |     }
132 | 
133 |     /**
134 |      * Get all of the created "drivers".
135 |      *
136 |      * @return array
137 |      */
138 |     public function getDrivers()
139 |     {
140 |         return $this->drivers;
141 |     }
142 | 
143 |     /**
144 |      * Dynamically call the default driver instance.
145 |      *
146 |      * @param  string  $method
147 |      * @param  array  $parameters
148 |      * @return mixed
149 |      */
150 |     public function __call($method, $parameters)
151 |     {
152 |         return $this->driver()->$method(...$parameters);
153 |     }
154 | }
155 | 


--------------------------------------------------------------------------------
/src/Views/Auth/reset_password.php:
--------------------------------------------------------------------------------
 1 | <?= $this->extend('Auth/layout') ?>
 2 | 
 3 | <?= $this->section('content') ?>
 4 | <section class="vh-lg-100 mt-5 mt-lg-0 bg-soft d-flex align-items-center">
 5 |     <div class="container">
 6 |         <div class="row justify-content-center form-bg-image">
 7 |             <p class="text-center"><a href="<?= route_to('login') ?>" class="d-flex align-items-center justify-content-center">
 8 |                     <svg class="icon icon-xs me-2" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
 9 |                         <path fill-rule="evenodd" d="M7.707 14.707a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414l4-4a1 1 0 011.414 1.414L5.414 9H17a1 1 0 110 2H5.414l2.293 2.293a1 1 0 010 1.414z" clip-rule="evenodd"></path>
10 |                     </svg>
11 |                     Back to log in
12 |                 </a>
13 |             </p>
14 |             <div class="col-12 d-flex align-items-center justify-content-center">
15 |                 <div class="bg-white shadow border-0 rounded p-4 p-lg-5 w-100 fmxw-500">
16 |                     <h1 class="h3 mb-4 text-center">Reset password</h1>
17 |                     <!-- Validation Errors and Message -->
18 |                     <?= $this->include('Auth/messages') ?>
19 |                     <form method="post" action="<?= route_to('password.update') ?>">
20 |                         <?= csrf_field() ?>
21 |                         <!-- Password Reset Token -->
22 |                         <input type="hidden" name="token" value="<?= $token ?>">
23 |                         <!-- Form -->
24 |                         <div class="mb-4">
25 |                             <label for="email">Your Email</label>
26 |                             <div class="input-group">
27 |                                 <input type="email" value="<?= $email ?>" class="form-control" placeholder="example@company.com" id="email" required disabled>
28 |                                 <input type="hidden" name="email" value="<?= $email ?>">
29 |                             </div>
30 |                         </div>
31 |                         <!-- End of Form -->
32 |                         <!-- Form -->
33 |                         <div class="form-group mb-4">
34 |                             <label for="password">Your Password</label>
35 |                             <div class="input-group">
36 |                                 <span class="input-group-text" id="basic-addon2">
37 |                                     <svg class="icon icon-xs text-gray-600" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
38 |                                         <path fill-rule="evenodd" d="M5 9V7a5 5 0 0110 0v2a2 2 0 012 2v5a2 2 0 01-2 2H5a2 2 0 01-2-2v-5a2 2 0 012-2zm8-2v2H7V7a3 3 0 016 0z" clip-rule="evenodd"></path>
39 |                                     </svg>
40 |                                 </span>
41 |                                 <input type="password" name="password" placeholder="Password" class="form-control" id="password" required>
42 |                             </div>
43 |                         </div>
44 |                         <!-- End of Form -->
45 |                         <!-- Form -->
46 |                         <div class="form-group mb-4">
47 |                             <label for="confirm_password">Confirm Password</label>
48 |                             <div class="input-group">
49 |                                 <span class="input-group-text" id="basic-addon2">
50 |                                     <svg class="icon icon-xs text-gray-600" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
51 |                                         <path fill-rule="evenodd" d="M5 9V7a5 5 0 0110 0v2a2 2 0 012 2v5a2 2 0 01-2 2H5a2 2 0 01-2-2v-5a2 2 0 012-2zm8-2v2H7V7a3 3 0 016 0z" clip-rule="evenodd"></path>
52 |                                     </svg>
53 |                                 </span>
54 |                                 <input type="password" name="password_confirmation" placeholder="Confirm Password" class="form-control" id="confirm_password" required>
55 |                             </div>
56 |                         </div>
57 |                         <!-- End of Form -->
58 |                         <div class="d-grid">
59 |                             <button type="submit" class="btn btn-gray-800">Reset password</button>
60 |                         </div>
61 |                     </form>
62 |                 </div>
63 |             </div>
64 |         </div>
65 |     </div>
66 | </section>
67 | <?= $this->endSection() ?>


--------------------------------------------------------------------------------
/src/Traits/HasAccessTokensTrait.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Traits;
  4 | 
  5 | use Fluent\Auth\Entities\AccessToken;
  6 | use Fluent\Auth\Models\AccessTokenModel;
  7 | 
  8 | use function bin2hex;
  9 | use function hash;
 10 | use function random_bytes;
 11 | 
 12 | /**
 13 |  * Trait HasAccessTokensTrait
 14 |  *
 15 |  * Provides functionality needed to generate, revoke,
 16 |  * and retrieve Personal Access Tokens.
 17 |  *
 18 |  * Intended to be used with User entities.
 19 |  */
 20 | trait HasAccessTokensTrait
 21 | {
 22 |     /**
 23 |      * Generates a new personal access token for this user.
 24 |      *
 25 |      * @param array $scopes
 26 |      * @return object
 27 |      */
 28 |     public function generateAccessToken(string $name, array $scopes = ['*'])
 29 |     {
 30 |         $tokens = new AccessTokenModel();
 31 | 
 32 |         $tokens->insert(new AccessToken([
 33 |             'user_id' => $this->id,
 34 |             'name'    => $name,
 35 |             'token'   => hash('sha256', $rawToken = bin2hex(random_bytes(64))),
 36 |             'scopes'  => $scopes,
 37 |         ]));
 38 | 
 39 |         $token = $tokens->find($tokens->insertId());
 40 | 
 41 |         $token->raw_token = $rawToken;
 42 | 
 43 |         return $token;
 44 |     }
 45 | 
 46 |     /**
 47 |      * Given the token, will retrieve the token to
 48 |      * verify it exists, then delete it.
 49 |      *
 50 |      * @return mixed
 51 |      */
 52 |     public function revokeAccessToken(string $token)
 53 |     {
 54 |         $tokens = new AccessTokenModel();
 55 | 
 56 |         return $tokens->where('user_id', $this->id)
 57 |             ->where('token', hash('sha256', $token))
 58 |             ->delete();
 59 |     }
 60 | 
 61 |     /**
 62 |      * Revokes all access tokens for this user.
 63 |      *
 64 |      * @return mixed
 65 |      */
 66 |     public function revokeAllAccessTokens()
 67 |     {
 68 |         $tokens = new AccessTokenModel();
 69 | 
 70 |         return $tokens->where('user_id', $this->id)
 71 |             ->delete();
 72 |     }
 73 | 
 74 |     /**
 75 |      * Retrieves all personal access tokens for this user.
 76 |      *
 77 |      * @return array
 78 |      */
 79 |     public function accessTokens(): array
 80 |     {
 81 |         $tokens = new AccessTokenModel();
 82 | 
 83 |         return $tokens->where('user_id', $this->id)
 84 |             ->find();
 85 |     }
 86 | 
 87 |     /**
 88 |      * Given a raw token, will hash it and attemp to
 89 |      * locate it within the system.
 90 |      *
 91 |      * @return AccessToken|null
 92 |      */
 93 |     public function getAccessToken(?string $token)
 94 |     {
 95 |         if (empty($token)) {
 96 |             return null;
 97 |         }
 98 | 
 99 |         $tokens = new AccessTokenModel();
100 | 
101 |         return $tokens->where('user_id', $this->id)
102 |             ->where('token', hash('sha256', $token))
103 |             ->first();
104 |     }
105 | 
106 |     /**
107 |      * Given the ID, returns the given access token.
108 |      *
109 |      * @return AccessToken|null
110 |      */
111 |     public function getAccessTokenById(int $id)
112 |     {
113 |         $tokens = new AccessTokenModel();
114 | 
115 |         return $tokens->where('user_id', $this->id)
116 |             ->where('id', $id)
117 |             ->first();
118 |     }
119 | 
120 |     /**
121 |      * Determines whether the user's token grants permissions to $scope.
122 |      * First checks against $this->activeToken, which is set during
123 |      * authentication. If it hasn't been set, returns false.
124 |      */
125 |     public function tokenCan(string $scope): bool
126 |     {
127 |         if (! $this->currentAccessToken() instanceof AccessToken) {
128 |             return false;
129 |         }
130 | 
131 |         return $this->currentAccessToken()->can($scope);
132 |     }
133 | 
134 |     /**
135 |      * Determines whether the user's token does NOT grant permissions to $scope.
136 |      * First checks against $this->activeToken, which is set during
137 |      * authentication. If it hasn't been set, returns true.
138 |      */
139 |     public function tokenCant(string $scope): bool
140 |     {
141 |         if (! $this->currentAccessToken() instanceof AccessToken) {
142 |             return true;
143 |         }
144 | 
145 |         return $this->currentAccessToken()->cant($scope);
146 |     }
147 | 
148 |     /**
149 |      * Returns the current access token for the user.
150 |      *
151 |      * @return AccessToken
152 |      */
153 |     public function currentAccessToken()
154 |     {
155 |         return $this->attributes['activeAccessToken'] ?? null;
156 |     }
157 | 
158 |     /**
159 |      * Sets the current active token for this user.
160 |      *
161 |      * @return $this
162 |      */
163 |     public function withAccessToken(?AccessToken $accessToken)
164 |     {
165 |         $this->attributes['activeAccessToken'] = $accessToken;
166 | 
167 |         return $this;
168 |     }
169 | }
170 | 


--------------------------------------------------------------------------------
/src/Views/Auth/login.php:
--------------------------------------------------------------------------------
 1 | <?= $this->extend('Auth/layout') ?>
 2 | 
 3 | <?= $this->section('content') ?>
 4 | <section class="vh-lg-100 mt-5 mt-lg-0 bg-soft d-flex align-items-center">
 5 |     <div class="container">
 6 |         <p class="text-center">
 7 |             <a href="/" class="d-flex align-items-center justify-content-center">
 8 |                 <svg class="icon icon-xs me-2" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
 9 |                     <path fill-rule="evenodd" d="M7.707 14.707a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414l4-4a1 1 0 011.414 1.414L5.414 9H17a1 1 0 110 2H5.414l2.293 2.293a1 1 0 010 1.414z" clip-rule="evenodd"></path>
10 |                 </svg>
11 |                 Back to homepage
12 |             </a>
13 |         </p>
14 |         <div class="row justify-content-center form-bg-image">
15 |             <div class="col-12 d-flex align-items-center justify-content-center">
16 |                 <div class="bg-white shadow border-0 rounded border-light p-4 p-lg-5 w-100 fmxw-500">
17 |                     <div class="text-center text-md-center mb-4 mt-md-0">
18 |                         <h1 class="mb-0 h3">Sign in to our platform</h1>
19 |                     </div>
20 |                     <!-- Validation Errors and Message -->
21 |                     <?= $this->include('Auth/messages') ?>
22 |                     <form method="post" action="<?= route_to('login') ?>" class="mt-4">
23 |                         <!-- Form -->
24 |                         <?= csrf_field() ?>
25 |                         <div class="form-group mb-4">
26 |                             <label for="email">Your Email</label>
27 |                             <div class="input-group">
28 |                                 <span class="input-group-text" id="basic-addon1">
29 |                                     <svg class="icon icon-xs text-gray-600" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
30 |                                         <path d="M2.003 5.884L10 9.882l7.997-3.998A2 2 0 0016 4H4a2 2 0 00-1.997 1.884z"></path>
31 |                                         <path d="M18 8.118l-8 4-8-4V14a2 2 0 002 2h12a2 2 0 002-2V8.118z"></path>
32 |                                     </svg>
33 |                                 </span>
34 |                                 <input type="email" value="<?= old('email') ?>" name="email" class="form-control" placeholder="example@company.com" id="email" autofocus="" required="">
35 |                             </div>
36 |                         </div>
37 |                         <!-- End of Form -->
38 |                         <div class="form-group">
39 |                             <!-- Form -->
40 |                             <div class="form-group mb-4">
41 |                                 <label for="password">Your Password</label>
42 |                                 <div class="input-group">
43 |                                     <span class="input-group-text" id="basic-addon2">
44 |                                         <svg class="icon icon-xs text-gray-600" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
45 |                                             <path fill-rule="evenodd" d="M5 9V7a5 5 0 0110 0v2a2 2 0 012 2v5a2 2 0 01-2 2H5a2 2 0 01-2-2v-5a2 2 0 012-2zm8-2v2H7V7a3 3 0 016 0z" clip-rule="evenodd"></path>
46 |                                         </svg>
47 |                                     </span>
48 |                                     <input type="password" name="password" placeholder="Password" class="form-control" id="password" required="">
49 |                                 </div>
50 |                             </div>
51 |                             <!-- End of Form -->
52 |                             <div class="d-flex justify-content-between align-items-top mb-4">
53 |                                 <div class="form-check">
54 |                                     <input class="form-check-input" type="checkbox" name="remember" id="remember">
55 |                                     <label class="form-check-label mb-0" for="remember">
56 |                                         Remember me
57 |                                     </label>
58 |                                 </div>
59 |                                 <div><a href="<?= route_to('password.request') ?>" class="small text-right">Lost password?</a></div>
60 |                             </div>
61 |                         </div>
62 |                         <div class="d-grid">
63 |                             <button type="submit" class="btn btn-gray-800">Sign in</button>
64 |                         </div>
65 |                     </form>
66 |                     <div class="d-flex justify-content-center align-items-center mt-4">
67 |                         <span class="fw-normal">
68 |                             Not registered?
69 |                             <a href="<?= route_to('register') ?>" class="fw-bold">Create account</a>
70 |                         </span>
71 |                     </div>
72 |                 </div>
73 |             </div>
74 |         </div>
75 |     </div>
76 | </section>
77 | <?= $this->endSection() ?>


--------------------------------------------------------------------------------
/src/Config/Auth.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Config;
  4 | 
  5 | use CodeIgniter\Config\BaseConfig;
  6 | use Fluent\Auth\Adapters\SessionAdapter;
  7 | use Fluent\Auth\Adapters\TokenAdapter;
  8 | use Fluent\Auth\Models\UserModel;
  9 | 
 10 | class Auth extends BaseConfig
 11 | {
 12 |     /**
 13 |      * --------------------------------------------------------------------------
 14 |      * Authentication Defaults
 15 |      * --------------------------------------------------------------------------
 16 |      *
 17 |      * This option controls the default authentication "guard" and password
 18 |      * reset option for your application. You may change these defaults
 19 |      * as required, but they're a perfect start for most applications.
 20 |      *
 21 |      * @var array
 22 |      */
 23 |     public $defaults = [
 24 |         'guard'    => 'web',
 25 |         'provider' => 'users',
 26 |         'password' => 'users',
 27 |     ];
 28 | 
 29 |     /**
 30 |      * --------------------------------------------------------------------------
 31 |      * Authentication Guards
 32 |      * --------------------------------------------------------------------------
 33 |      *
 34 |      * Next, you may define every authentication adapter for your application.
 35 |      * Of course, a great default configuration has been defined for you
 36 |      * here which uses session storage and the user provider.
 37 |      *
 38 |      * All authentication drivers have a user provider. This defines how the
 39 |      * users are actually retrieved out of your database or other storage
 40 |      * mechanisms used by this application to persist your user's data.
 41 |      *
 42 |      * Supported: "session", "token"
 43 |      *
 44 |      * @var array
 45 |      */
 46 |     public $guards = [
 47 |         'web'   => [
 48 |             'driver'   => SessionAdapter::class,
 49 |             'provider' => 'users',
 50 |         ],
 51 |         'token' => [
 52 |             'driver'   => TokenAdapter::class,
 53 |             'provider' => 'users',
 54 |         ],
 55 |         // etc your implementation
 56 |     ];
 57 | 
 58 |     /**
 59 |      * --------------------------------------------------------------------------
 60 |      * User Providers
 61 |      * --------------------------------------------------------------------------
 62 |      *
 63 |      * All authentication drivers have a user provider. This defines how the
 64 |      * users are actually retrieved out of your database or other storage
 65 |      * mechanisms used by this application to persist your user's data.
 66 |      *
 67 |      * If you have multiple user tables or models you may configure multiple
 68 |      * sources which represent each model / table. These sources may then
 69 |      * be assigned to any extra authentication guards you have defined.
 70 |      *
 71 |      * Supported: "model", "database"
 72 |      *
 73 |      * @var array
 74 |      */
 75 |     public $providers = [
 76 |         'users'    => [
 77 |             'driver' => 'model',
 78 |             'table'  => UserModel::class,
 79 |         ],
 80 |         'database' => [
 81 |             'connection' => 'default',
 82 |             'driver'     => 'connection',
 83 |             'table'      => 'users',
 84 |         ],
 85 |     ];
 86 | 
 87 |     /**
 88 |      * --------------------------------------------------------------------------
 89 |      * Resetting Passwords
 90 |      * --------------------------------------------------------------------------
 91 |      *
 92 |      * You may specify multiple password reset configurations if you have more
 93 |      * than one user table or model in the application and you want to have
 94 |      * separate password reset settings based on the specific user types.
 95 |      *
 96 |      * The expire time is the number of minutes that the reset token should be
 97 |      * considered valid. This security feature keeps tokens short-lived so
 98 |      * they have less time to be guessed. You may change this as needed.
 99 |      *
100 |      * @var array
101 |      */
102 |     public $passwords = [
103 |         'users' => [
104 |             'provider'   => 'users',
105 |             'connection' => 'default',
106 |             'table'      => 'auth_password_resets',
107 |             'expire'     => 60,
108 |             'throttle'   => 60,
109 |         ],
110 |     ];
111 | 
112 |     /**
113 |      * --------------------------------------------------------------------------
114 |      * Password Confirmation Timeout
115 |      * --------------------------------------------------------------------------
116 |      *
117 |      * Here you may define the amount of seconds before a password confirmation
118 |      * times out and the user is prompted to re-enter their password via the
119 |      * confirmation screen. By default, the timeout lasts for three hours.
120 |      *
121 |      * @var int
122 |      */
123 |     public $passwordTimeout = 3 * HOUR;
124 | 
125 |     /**
126 |      * --------------------------------------------------------------------------
127 |      * Redirect Authenticated
128 |      * --------------------------------------------------------------------------
129 |      *
130 |      * Here you may define the redirect if authenticated success.
131 |      *
132 |      * @var string
133 |      */
134 |     public $home = 'dashboard';
135 | }
136 | 


--------------------------------------------------------------------------------
/src/Passwords/Hash/ArgonHasher.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Passwords\Hash;
  4 | 
  5 | use Fluent\Auth\Contracts\HasherInterface;
  6 | use Fluent\Auth\Passwords\Hash\AbstractHasher;
  7 | use RuntimeException;
  8 | 
  9 | use function is_string;
 10 | use function password_hash;
 11 | use function password_needs_rehash;
 12 | 
 13 | use const PASSWORD_ARGON2I;
 14 | 
 15 | class ArgonHasher extends AbstractHasher implements HasherInterface
 16 | {
 17 |     /**
 18 |      * The default memory cost factor.
 19 |      *
 20 |      * @var int
 21 |      */
 22 |     protected $memory = 1024;
 23 | 
 24 |     /**
 25 |      * The default time cost factor.
 26 |      *
 27 |      * @var int
 28 |      */
 29 |     protected $time = 2;
 30 | 
 31 |     /**
 32 |      * The default threads factor.
 33 |      *
 34 |      * @var int
 35 |      */
 36 |     protected $threads = 2;
 37 | 
 38 |     /**
 39 |      * Indicates whether to perform an algorithm check.
 40 |      *
 41 |      * @var bool
 42 |      */
 43 |     protected $verifyAlgorithm = false;
 44 | 
 45 |     /**
 46 |      * Create a new hasher instance.
 47 |      *
 48 |      * @param  array  $options
 49 |      * @return void
 50 |      */
 51 |     public function __construct(array $options = [])
 52 |     {
 53 |         $this->time            = $options['time'] ?? $this->time;
 54 |         $this->memory          = $options['memory'] ?? $this->memory;
 55 |         $this->threads         = $options['threads'] ?? $this->threads;
 56 |         $this->verifyAlgorithm = $options['verify'] ?? $this->verifyAlgorithm;
 57 |     }
 58 | 
 59 |     /**
 60 |      * Hash the given value.
 61 |      *
 62 |      * @param  string  $value
 63 |      * @param  array  $options
 64 |      * @return string
 65 |      * @throws RuntimeException
 66 |      */
 67 |     public function make($value, array $options = [])
 68 |     {
 69 |         $hash = @password_hash($value, $this->algorithm(), [
 70 |             'memory_cost' => $this->memory($options),
 71 |             'time_cost'   => $this->time($options),
 72 |             'threads'     => $this->threads($options),
 73 |         ]);
 74 | 
 75 |         if (! is_string($hash)) {
 76 |             throw new RuntimeException('Argon2 hashing not supported.');
 77 |         }
 78 | 
 79 |         return $hash;
 80 |     }
 81 | 
 82 |     /**
 83 |      * Get the algorithm that should be used for hashing.
 84 |      *
 85 |      * @return int
 86 |      */
 87 |     protected function algorithm()
 88 |     {
 89 |         return PASSWORD_ARGON2I;
 90 |     }
 91 | 
 92 |     /**
 93 |      * Check the given plain value against a hash.
 94 |      *
 95 |      * @param  string  $value
 96 |      * @param  string  $hashedValue
 97 |      * @param  array  $options
 98 |      * @return bool
 99 |      * @throws RuntimeException
100 |      */
101 |     public function check($value, $hashedValue, array $options = [])
102 |     {
103 |         if ($this->verifyAlgorithm && $this->info($hashedValue)['algoName'] !== 'argon2i') {
104 |             throw new RuntimeException('This password does not use the Argon2i algorithm.');
105 |         }
106 | 
107 |         return parent::check($value, $hashedValue, $options);
108 |     }
109 | 
110 |     /**
111 |      * Check if the given hash has been hashed using the given options.
112 |      *
113 |      * @param  string  $hashedValue
114 |      * @param  array  $options
115 |      * @return bool
116 |      */
117 |     public function needsRehash($hashedValue, array $options = [])
118 |     {
119 |         return password_needs_rehash($hashedValue, $this->algorithm(), [
120 |             'memory_cost' => $this->memory($options),
121 |             'time_cost'   => $this->time($options),
122 |             'threads'     => $this->threads($options),
123 |         ]);
124 |     }
125 | 
126 |     /**
127 |      * Set the default password memory factor.
128 |      *
129 |      * @return $this
130 |      */
131 |     public function setMemory(int $memory)
132 |     {
133 |         $this->memory = $memory;
134 | 
135 |         return $this;
136 |     }
137 | 
138 |     /**
139 |      * Set the default password timing factor.
140 |      *
141 |      * @return $this
142 |      */
143 |     public function setTime(int $time)
144 |     {
145 |         $this->time = $time;
146 | 
147 |         return $this;
148 |     }
149 | 
150 |     /**
151 |      * Set the default password threads factor.
152 |      *
153 |      * @return $this
154 |      */
155 |     public function setThreads(int $threads)
156 |     {
157 |         $this->threads = $threads;
158 | 
159 |         return $this;
160 |     }
161 | 
162 |     /**
163 |      * Extract the memory cost value from the options array.
164 |      *
165 |      * @param  array  $options
166 |      * @return int
167 |      */
168 |     protected function memory(array $options)
169 |     {
170 |         return $options['memory'] ?? $this->memory;
171 |     }
172 | 
173 |     /**
174 |      * Extract the time cost value from the options array.
175 |      *
176 |      * @param  array  $options
177 |      * @return int
178 |      */
179 |     protected function time(array $options)
180 |     {
181 |         return $options['time'] ?? $this->time;
182 |     }
183 | 
184 |     /**
185 |      * Extract the threads value from the options array.
186 |      *
187 |      * @param  array  $options
188 |      * @return int
189 |      */
190 |     protected function threads(array $options)
191 |     {
192 |         return $options['threads'] ?? $this->threads;
193 |     }
194 | }
195 | 


--------------------------------------------------------------------------------
/src/Views/Email/layout.php:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 2 | <html xmlns="http://www.w3.org/1999/xhtml">
 3 | 
 4 | <head>
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 7 |     <meta name="color-scheme" content="light">
 8 |     <meta name="supported-color-schemes" content="light">
 9 | </head>
10 | 
11 | <body style="box-sizing: border-box; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'; position: relative; -webkit-text-size-adjust: none; background-color: #ffffff; color: #718096; height: 100%; line-height: 1.4; margin: 0; padding: 0; width: 100% !important;">
12 |     <style>
13 |         @media only screen and (max-width: 600px) {
14 |             .inner-body {
15 |                 width: 100% !important;
16 |             }
17 | 
18 |             .footer {
19 |                 width: 100% !important;
20 |             }
21 |         }
22 | 
23 |         @media only screen and (max-width: 500px) {
24 |             .button {
25 |                 width: 100% !important;
26 |             }
27 |         }
28 |     </style>
29 | 
30 |     <table class="wrapper" width="100%" cellpadding="0" cellspacing="0" role="presentation" style="box-sizing: border-box; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'; position: relative; -premailer-cellpadding: 0; -premailer-cellspacing: 0; -premailer-width: 100%; background-color: #edf2f7; margin: 0; padding: 0; width: 100%;">
31 |         <tr>
32 |             <td align="center" style="box-sizing: border-box; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'; position: relative;">
33 |                 <table class="content" width="100%" cellpadding="0" cellspacing="0" role="presentation" style="box-sizing: border-box; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'; position: relative; -premailer-cellpadding: 0; -premailer-cellspacing: 0; -premailer-width: 100%; margin: 0; padding: 0; width: 100%;">
34 |                     <tr>
35 |                         <td class="header" style="box-sizing: border-box; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'; position: relative; padding: 25px 0; text-align: center;">
36 |                             <a href="<?= site_url() ?>" style="box-sizing: border-box; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'; position: relative; color: #3d4852; font-size: 19px; font-weight: bold; text-decoration: none; display: inline-block;">
37 |                                 <img src="https://codeigniter.com/assets/images/codeigniter4logo.png" class="logo" alt="CodeIgniter Logo" style="box-sizing: border-box; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'; position: relative; max-width: 100%; border: none; height: 75px; width: 75px;">
38 |                             </a>
39 |                         </td>
40 |                     </tr>
41 | 
42 |                     <!-- Email Body -->
43 |                     <?php $this->renderSection('content') ?>
44 | 
45 |                     <tr>
46 |                         <td style="box-sizing: border-box; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'; position: relative;">
47 |                             <table class="footer" align="center" width="570" cellpadding="0" cellspacing="0" role="presentation" style="box-sizing: border-box; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'; position: relative; -premailer-cellpadding: 0; -premailer-cellspacing: 0; -premailer-width: 570px; margin: 0 auto; padding: 0; text-align: center; width: 570px;">
48 |                                 <tr>
49 |                                     <td class="content-cell" align="center" style="box-sizing: border-box; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'; position: relative; max-width: 100vw; padding: 32px;">
50 |                                         <p style="box-sizing: border-box; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol'; position: relative; line-height: 1.5em; margin-top: 0; color: #b0adc5; font-size: 12px; text-align: center;">© <?= date('Y') ?> <a href="https://github.com/agungsugiarto/codeigniter4-authentication">codeigniter4-authentication</a>. All rights reserved.</p>
51 | 
52 |                                     </td>
53 |                                 </tr>
54 |                             </table>
55 |                         </td>
56 |                     </tr>
57 |                 </table>
58 |             </td>
59 |         </tr>
60 |     </table>
61 | </body>
62 | 
63 | </html>
64 | 


--------------------------------------------------------------------------------
/src/Views/Auth/register.php:
--------------------------------------------------------------------------------
 1 | <?= $this->extend('Auth/layout') ?>
 2 | 
 3 | <?= $this->section('content') ?>
 4 | <section class="vh-lg-100 mt-5 mt-lg-0 bg-soft d-flex align-items-center">
 5 |     <div class="container">
 6 |         <p class="text-center">
 7 |             <a href="/" class="d-flex align-items-center justify-content-center">
 8 |                 <svg class="icon icon-xs me-2" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
 9 |                     <path fill-rule="evenodd" d="M7.707 14.707a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414l4-4a1 1 0 011.414 1.414L5.414 9H17a1 1 0 110 2H5.414l2.293 2.293a1 1 0 010 1.414z" clip-rule="evenodd"></path>
10 |                 </svg>
11 |                 Back to homepage
12 |             </a>
13 |         </p>
14 |         <div class="row justify-content-center form-bg-image">
15 |             <div class="col-12 d-flex align-items-center justify-content-center">
16 |                 <div class="bg-white shadow border-0 rounded border-light p-4 p-lg-5 w-100 fmxw-500">
17 |                     <div class="text-center text-md-center mb-4 mt-md-0">
18 |                         <h1 class="mb-0 h3">Create Account </h1>
19 |                     </div>
20 |                     <!-- Validation Errors and Message -->
21 |                     <?= $this->include('Auth/messages') ?>
22 |                     <form method="post" action="<?= route_to('register') ?>" class="mt-4">
23 |                         <!-- Form -->
24 |                         <?= csrf_field() ?>
25 |                         <div class="mb-4">
26 |                             <label for="email">Your Username</label>
27 |                             <div class="input-group">
28 |                                 <input type="text" value="<?= old('username') ?>" name="username" class="form-control" id="email" placeholder="johndoe" required="" autofocus="">
29 |                             </div>
30 |                         </div>
31 |                         <div class="form-group mb-4">
32 |                             <label for="email">Your Email</label>
33 |                             <div class="input-group">
34 |                                 <span class="input-group-text" id="basic-addon1">
35 |                                     <svg class="icon icon-xs text-gray-600" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
36 |                                         <path d="M2.003 5.884L10 9.882l7.997-3.998A2 2 0 0016 4H4a2 2 0 00-1.997 1.884z"></path>
37 |                                         <path d="M18 8.118l-8 4-8-4V14a2 2 0 002 2h12a2 2 0 002-2V8.118z"></path>
38 |                                     </svg>
39 |                                 </span>
40 |                                 <input type="email" value="<?= old('email') ?>" name="email" class="form-control" placeholder="example@company.com" id="email" autofocus="" required="">
41 |                             </div>
42 |                         </div>
43 |                         <!-- End of Form -->
44 |                         <div class="form-group">
45 |                             <!-- Form -->
46 |                             <div class="form-group mb-4">
47 |                                 <label for="password">Your Password</label>
48 |                                 <div class="input-group">
49 |                                     <span class="input-group-text" id="basic-addon2">
50 |                                         <svg class="icon icon-xs text-gray-600" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
51 |                                             <path fill-rule="evenodd" d="M5 9V7a5 5 0 0110 0v2a2 2 0 012 2v5a2 2 0 01-2 2H5a2 2 0 01-2-2v-5a2 2 0 012-2zm8-2v2H7V7a3 3 0 016 0z" clip-rule="evenodd"></path>
52 |                                         </svg>
53 |                                     </span>
54 |                                     <input type="password" name="password" placeholder="Password" class="form-control" id="password" required="">
55 |                                 </div>
56 |                             </div>
57 |                             <!-- End of Form -->
58 |                             <!-- Form -->
59 |                             <div class="form-group mb-4">
60 |                                 <label for="confirm_password">Confirm Password</label>
61 |                                 <div class="input-group">
62 |                                     <span class="input-group-text" id="basic-addon2">
63 |                                         <svg class="icon icon-xs text-gray-600" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
64 |                                             <path fill-rule="evenodd" d="M5 9V7a5 5 0 0110 0v2a2 2 0 012 2v5a2 2 0 01-2 2H5a2 2 0 01-2-2v-5a2 2 0 012-2zm8-2v2H7V7a3 3 0 016 0z" clip-rule="evenodd"></path>
65 |                                         </svg>
66 |                                     </span>
67 |                                     <input type="password" name="password_confirmation" placeholder="Confirm Password" class="form-control" id="password_confirmation" required="">
68 |                                 </div>
69 |                             </div>
70 |                             <!-- End of Form -->
71 |                         </div>
72 |                         <div class="d-grid">
73 |                             <button type="submit" class="btn btn-gray-800">Sign up</button>
74 |                         </div>
75 |                     </form>
76 |                     <div class="d-flex justify-content-center align-items-center mt-4">
77 |                         <span class="fw-normal">
78 |                             Already have an account?
79 |                             <a href="<?= route_to('login') ?>" class="fw-bold">Login here</a>
80 |                         </span>
81 |                     </div>
82 |                 </div>
83 |             </div>
84 |         </div>
85 |     </div>
86 | </section>
87 | <?= $this->endSection() ?>


--------------------------------------------------------------------------------
/src/Passwords/PasswordBroker.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Fluent\Auth\Passwords;
  4 | 
  5 | use Closure;
  6 | use Fluent\Auth\Contracts\PasswordBrokerInterface;
  7 | use Fluent\Auth\Contracts\PasswordResetRepositoryInterface;
  8 | use Fluent\Auth\Contracts\ResetPasswordInterface;
  9 | use Fluent\Auth\Contracts\UserProviderInterface;
 10 | use Fluent\Auth\Contracts\VerifyEmailInterface;
 11 | use Fluent\Auth\Helpers\Arr;
 12 | use UnexpectedValueException;
 13 | 
 14 | use function is_null;
 15 | 
 16 | class PasswordBroker implements PasswordBrokerInterface
 17 | {
 18 |     /** @var PasswordResetRepositoryInterface */
 19 |     protected $tokens;
 20 | 
 21 |     /** @var UserProviderInterface */
 22 |     protected $users;
 23 | 
 24 |     public function __construct(PasswordResetRepositoryInterface $tokens, UserProviderInterface $users)
 25 |     {
 26 |         $this->tokens = $tokens;
 27 |         $this->users  = $users;
 28 |     }
 29 | 
 30 |     /**
 31 |      * {@inheritdoc}
 32 |      */
 33 |     public function sendResetLink(array $credentials, ?Closure $callback = null)
 34 |     {
 35 |         // First we will check to see if we found a user at the given credentials and
 36 |         // if we did not we will redirect back to this current URI with a piece of
 37 |         // "flash" data in the session to indicate to the developers the errors.
 38 |         $user = $this->getUser($credentials);
 39 | 
 40 |         if (is_null($user)) {
 41 |             return static::INVALID_USER;
 42 |         }
 43 | 
 44 |         if ($this->tokens->recentlyCreatedToken($user)) {
 45 |             return static::RESET_THROTTLED;
 46 |         }
 47 | 
 48 |         $token = $this->tokens->create($user);
 49 | 
 50 |         if ($callback) {
 51 |             $callback($user, $token);
 52 |         } else {
 53 |             // Once we have the reset token, we are ready to send the message out to this
 54 |             // user with a link to reset their password. We will then redirect back to
 55 |             // the current URI having nothing set in the session to indicate errors.
 56 |             $user->sendPasswordResetNotification($token);
 57 |         }
 58 | 
 59 |         return static::RESET_LINK_SENT;
 60 |     }
 61 | 
 62 |     /**
 63 |      * {@inheritdoc}
 64 |      */
 65 |     public function sendVerifyLink(array $credentials, ?Closure $callback = null)
 66 |     {
 67 |         // First we will check to see if we found a user at the given credentials and
 68 |         // if we did not we will redirect back to this current URI with a piece of
 69 |         // "flash" data in the session to indicate to the developers the errors.
 70 |         $user = $this->getUser($credentials);
 71 | 
 72 |         if (is_null($user)) {
 73 |             return static::INVALID_USER;
 74 |         }
 75 | 
 76 |         if (! $user instanceof VerifyEmailInterface) {
 77 |             return static::RESET_THROTTLED;
 78 |         }
 79 | 
 80 |         if ($callback) {
 81 |             $callback($user);
 82 |         } else {
 83 |             // We are ready to send verify the message out to this user with a link
 84 |             // to their email. We will then redirect back to the current URI
 85 |             // having nothing set in the session to indicate errors.
 86 |             $user->sendEmailVerificationNotification();
 87 |         }
 88 | 
 89 |         return static::VERIFY_LINK_SENT;
 90 |     }
 91 | 
 92 |     /**
 93 |      * {@inheritdoc}
 94 |      */
 95 |     public function reset(array $credentials, Closure $callback)
 96 |     {
 97 |         $user = $this->validateReset($credentials);
 98 | 
 99 |         // If the responses from the validate method is not a user instance, we will
100 |         // assume that it is a redirect and simply return it from this method and
101 |         // the user is properly redirected having an error message on the post.
102 |         if (! $user instanceof ResetPasswordInterface) {
103 |             return $user;
104 |         }
105 | 
106 |         $password = $credentials['password'];
107 | 
108 |         // Once the reset has been validated, we'll call the given callback with the
109 |         // new password. This gives the user an opportunity to store the password
110 |         // in their persistent storage. Then we'll delete the token and return.
111 |         $callback($user, $password);
112 | 
113 |         $this->tokens->destroy($user);
114 | 
115 |         return static::PASSWORD_RESET;
116 |     }
117 | 
118 |     /**
119 |      * Validate a password reset for the given credentials.
120 |      *
121 |      * @param  array  $credentials
122 |      * @return ResetPasswordInterface|string
123 |      */
124 |     protected function validateReset(array $credentials)
125 |     {
126 |         if (is_null($user = $this->getUser($credentials))) {
127 |             return static::INVALID_USER;
128 |         }
129 | 
130 |         if (! $this->tokens->exists($user, $credentials['token'])) {
131 |             return static::INVALID_TOKEN;
132 |         }
133 | 
134 |         return $user;
135 |     }
136 | 
137 |     /**
138 |      * {@inheritdoc}
139 |      */
140 |     public function getUser(array $credentials)
141 |     {
142 |         $credentials = Arr::except($credentials, ['token']);
143 | 
144 |         $user = $this->users->findByCredentials($credentials);
145 | 
146 |         if ($user && ! $user instanceof ResetPasswordInterface) {
147 |             throw new UnexpectedValueException('User must implement ResetPasswordInterface.');
148 |         }
149 | 
150 |         return $user;
151 |     }
152 | 
153 |     /**
154 |      * {@inheritdoc}
155 |      */
156 |     public function createToken(ResetPasswordInterface $user)
157 |     {
158 |         return $this->tokens->create($user);
159 |     }
160 | 
161 |     /**
162 |      * {@inheritdoc}
163 |      */
164 |     public function deleteToken(ResetPasswordInterface $user)
165 |     {
166 |         $this->tokens->destroy($user);
167 |     }
168 | 
169 |     /**
170 |      * {@inheritdoc}
171 |      */
172 |     public function tokenExists(ResetPasswordInterface $user, $token)
173 |     {
174 |         return $this->tokens->exists($user, $token);
175 |     }
176 | 
177 |     /**
178 |      * {@inheritdoc}
179 |      */
180 |     public function getRepository()
181 |     {
182 |         return $this->tokens;
183 |     }
184 | }
185 | 


--------------------------------------------------------------------------------