6 |
7 |
8 |
9 | formRenderDesign() ?>
10 |
--------------------------------------------------------------------------------
/docs/auth-bearer-tokens.md:
--------------------------------------------------------------------------------
1 | # Auth Bearer Tokens
2 |
3 | The `Auth` implements a native bearer token implementation (JWT).
4 |
5 | ## Generating a Token
6 |
7 | When working with authentication via bearer tokens, the `getBearerToken` method can be used to obtain a bearer token (JWT) for the current user. It expires after 1 hour by default.
8 |
9 | ```php
10 | $token = Auth::getBearerToken();
11 | ```
12 |
13 | You may also pass a user to this method to get a token for a specified user.
14 |
15 | ```php
16 | $token = Auth::getBearerToken($user);
17 | ```
18 |
19 | When using the [Session component](./component-session.md), the `token` variable is available on this object.
20 |
21 | ```twig
22 | {{ session.key}}
23 | ```
24 |
25 | ## Verifying a Token
26 |
27 | When verifying a token, use the `checkBearerToken` method that will return a valid user who is associated token, or false if the token is invalid or that user is no longer found.
28 |
29 | ```php
30 | $user = Auth::checkBearerToken($token);
31 | ```
32 |
33 | The `loginUsingBearerToken` method is used to verify a supplied token and authenticate the user. The method returns the user if the verification was successful.
34 |
35 | ```php
36 | if ($jwtToken = Request::bearerToken()) {
37 | Auth::loginUsingBearerToken($jwtToken);
38 | }
39 | ```
40 |
41 | > **Note**: Further configuration for this functionality can be found in the **rainlab.user::config.bearer_token** configuration value.
42 |
43 | ## Working with APIs
44 |
45 | When [building API endpoints using CMS pages](https://docs.octobercms.com/3.x/cms/resources/building-apis.html) it can be useful to use a page for handling the authentication logic. The following is a simple example that includes various API endpoints.
46 |
47 | ```twig
48 | title = "User API Page"
49 | url = "/api/user/:action"
50 |
51 | [resetPassword]
52 | [account]
53 | [session]
54 | checkToken = 1
55 | ==
56 | {% if this.param.action == 'signin' %}
57 | {% do response(
58 | ajaxHandler('onLogin').withVars({
59 | token: session.token()
60 | })
61 | ) %}
62 | {% endif %}
63 |
64 | {% if this.param.action == 'register' %}
65 | {% do response(ajaxHandler('onRegister')) %}
66 | {% endif %}
67 |
68 | {% if this.param.action == 'logout' %}
69 | {% do response(ajaxHandler('onLogout')) %}
70 | {% endif %}
71 |
72 | {% if this.param.action == 'refresh' %}
73 | {% do response({ data: {
74 | token: session.token()
75 | }}) %}
76 | {% endif %}
77 | ```
78 |
79 | An API layout to verify the user can be used for other API endpoints.
80 |
81 | ```twig
82 | description = "Auth API Layout"
83 | is_priority = 1
84 |
85 | [session]
86 | checkToken = 1
87 | ==
88 | {% if session.user %}
89 | {% page %}
90 | {% else %}
91 | {% do abort(403, 'Access Denied') %}
92 | {% endif %}
93 | ```
94 |
95 | ### Email Verification Example
96 |
97 | The following example shows how to implement the email verification process as an API, with the supported actions of **request** (default) and **confirm**.
98 |
99 | The `setUrlForEmailVerification` method call overrides the verification URL in the email sent to the user. The `verify` code in the URL acts as a one-time bearer token that authenticates the user (`session.user`) for a single page cycle. The standard redirect is disabled by adding `redirect=0` to the verification URL.
100 |
101 | ```twig
102 | title = "User Email Verification API"
103 | url = "/api/user/verify/:action?request"
104 |
105 | [account]
106 | [session]
107 | checkToken = 1
108 | ==
109 | {% if not session.user %}
110 | {% do response({
111 | error: 'Access Denied'
112 | }, 403) %}
113 | {% endif %}
114 |
115 | {% if this.param.action == 'request' %}
116 | {% do session.user.setUrlForEmailVerification(
117 | this|page({ action: 'confirm' }) ~ '?redirect=0'
118 | ) %}
119 |
120 | {% do response(ajaxHandler('onVerifyEmail')) %}
121 | {% endif %}
122 |
123 | {% if this.param.action == 'confirm' %}
124 | {% if session.user.hasVerifiedEmail %}
125 | {% do response({
126 | success: "Thank you for verifying your email."
127 | }, 201) %}
128 | {% else %}
129 | {% do response({
130 | error: "The provided email verification code was invalid."
131 | }, 400) %}
132 | {% endif %}
133 | {% endif %}
134 | ```
135 |
--------------------------------------------------------------------------------
/docs/auth-impersonation.md:
--------------------------------------------------------------------------------
1 | # Auth Impersonation
2 |
3 | The `Auth` facade supports user impersonation. Use the `impersonate` method to impersonate another user.
4 |
5 | ```php
6 | Auth::impersonate($user);
7 | ```
8 |
9 | To stop impersonating, use the `stopImpersonate` method. This will restore the account that was previously logged in, if applicable.
10 |
11 | ```php
12 | Auth::stopImpersonate();
13 | ```
14 |
15 | The `isImpersonator` method can be used to check if the user is currently impersonating.
16 |
17 | ```php
18 | if (Auth::isImpersonator()) {
19 | // User is currently impersonating another user
20 | }
21 | ```
22 |
23 | Use the `getRealUser` method to return the underlying user they are impersonating someone else, or it will return the active user if they are not impersonating.
24 |
25 | ```php
26 | $user = Auth::getRealUser();
27 | ```
28 |
--------------------------------------------------------------------------------
/docs/auth-manager.md:
--------------------------------------------------------------------------------
1 | # Auth Manager
2 |
3 | There is an `Auth` facade you may use for common tasks, it primarily inherits the `October\Rain\Auth\Manager` class for functionality.
4 |
5 | You may use `create` method on the `User` model to register an account.
6 |
7 | ```php
8 | $user = \RainLab\User\Models\User::create([
9 | 'first_name' => 'Some',
10 | 'last_name' => 'User',
11 | 'email' => 'some@website.tld',
12 | 'password' => 'ChangeMe888',
13 | 'password_confirmation' => 'ChangeMe888',
14 | ]);
15 | ```
16 |
17 | The `markEmailAsVerified` method can be used to activate an existing user.
18 |
19 | ```php
20 | // Auto activate this user
21 | $user->markEmailAsVerified();
22 | ```
23 |
24 | The `check` method is a quick way to check if the user is signed in.
25 |
26 | ```php
27 | // Returns true if signed in.
28 | $loggedIn = Auth::check();
29 | ```
30 |
31 | To return the user model that is signed in, use `user` method instead.
32 |
33 | ```php
34 | // Returns the signed in user
35 | $user = Auth::user();
36 | ```
37 |
38 | You may authenticate a user by providing their login and password with the `attempt` method.
39 |
40 | ```php
41 | // Authenticate user by credentials
42 | $user = Auth::attempt([
43 | 'email' => post('email'),
44 | 'password' => post('password')
45 | ]);
46 | ```
47 |
48 | The second argument is used to store a non-expire cookie for the user.
49 |
50 | ```php
51 | $user = Auth::attempt([...], true);
52 | ```
53 |
54 | You can also authenticate as a user simply by passing the user model along with the `login` method.
55 |
56 | ```php
57 | // Sign in as a specific user
58 | Auth::login($user);
59 | ```
60 |
61 | The second argument will store the non-expire cookie for the user.
62 |
63 | ```php
64 | // Sign in and remember the user
65 | Auth::login($user, true);
66 | ```
67 |
68 | You may look up a user by their email or login name using the `retrieveByCredentials` method via the provider class.
69 |
70 | ```php
71 | $user = Auth::getProvider()->retrieveByCredentials([
72 | 'email' => 'some@email.tld'
73 | ]);
74 | ```
75 |
76 | ## Guest Users
77 |
78 | Creating a guest user allows the registration process to be deferred. For example, making a purchase without needing to register first. Guest users are not able to sign in and will be added to the user group with the code `guest`.
79 |
80 | > **Note**: If you are upgrading from an older version of this plugin, to enable guest users you may need to remove the UNIQUE index on the `email` column in the `users` table.
81 |
82 | Use the `is_guest` attribute to create a guest user, it will return a user object and can be called multiple times. The unique identifier is the email address, which is a required field.
83 |
84 | ```php
85 | $user = \RainLab\User\Models\User::create([
86 | 'first_name' => 'Some',
87 | 'last_name' => 'User',
88 | 'email' => 'person@acme.tld',
89 | 'is_guest' => true
90 | ]);
91 | ```
92 |
93 | When a user registers with the same email address using the `create` method, another account is created and they will not inherit the existing guest user account.
94 |
95 | ```php
96 | // This will not throw an "Email already taken" error
97 | $user = \RainLab\User\Models\User::create([
98 | 'first_name' => 'Some',
99 | 'last_name' => 'User',
100 | 'email' => 'person@acme.tld',
101 | 'password' => 'ChangeMe888',
102 | 'password_confirmation' => 'ChangeMe888',
103 | ]);
104 | ```
105 |
106 | You may convert a guest to a registered user with the `convertToRegistered` method. This will send them an invitation using the `user:invite_email` template to set up a new password. When a user is converted they will be added to the user group with the code `registered`.
107 |
108 | ```php
109 | User::where('email', 'person@acme.tld')->first();
110 | $user->convertToRegistered();
111 | ```
112 |
113 | To disable the notification and password reset, pass the first argument as false.
114 |
115 | ```php
116 | $user->convertToRegistered(false);
117 | ```
118 |
--------------------------------------------------------------------------------
/docs/component-account.md:
--------------------------------------------------------------------------------
1 | # Account Component
2 |
3 | The account component provides a method to update the logged in user profile, verify email address, enable two-factor authentication, clear browser sessions and delete their account.
4 |
5 | ```ini
6 | title = "Account"
7 | url = "/account/:code?"
8 |
9 | [account]
10 | isDefault = 1
11 | ==
12 | ...
13 | ```
14 |
15 | For displaying and clearing other browser sessions for the user, the session driver must be set to `database`. Open the **config/session.php** file and change the driver, this can also be set in the **.env** file with the `SESSION_DRIVER` variable.
16 |
17 | ```php
18 | 'driver' => env('SESSION_DRIVER', 'database'),
19 | ```
20 |
21 | ## API
22 |
23 | These AJAX handlers are available.
24 |
25 | Handler | Description
26 | ------- | -------------
27 | **onUpdateProfile** | Updates the user profile
28 | **onVerifyEmail** | Verifies the user email address
29 | **onEnableTwoFactor** | Enables two-factor authentication
30 | **onConfirmTwoFactor** | Confirms two-factor authentication using a valid code
31 | **onShowTwoFactorRecoveryCodes** | Displays the two-factor recovery codes
32 | **onRegenerateTwoFactorRecoveryCodes** | Deletes and recreates the recovery codes
33 | **onDisableTwoFactor** | Disables two-factor authentication
34 | **onDeleteOtherSessions** | Logs out other user sessions
35 | **onDeleteUser** | Deletes the user account
36 |
37 | These variables are available on the component object.
38 |
39 | Variable | Description
40 | -------- | -------------
41 | `user` | returns the logged in user
42 | `sessions` | returns browser sessions for the user
43 | `twoFactorEnabled` | returns true if the user has two factor enabled
44 | `twoFactorRecoveryCodes` | returns an array of recovery codes, if available
45 |
46 | ## Examples
47 |
48 | The following example shows how to update the user profile using the `onUpdateProfile` handler.
49 |
50 | ```html
51 |
80 | ```
81 |
--------------------------------------------------------------------------------
/docs/component-authentication.md:
--------------------------------------------------------------------------------
1 | # Authentication Component
2 |
3 | ## Overriding Functionality
4 |
5 | Here is how you would override the `onLogin()` handler to log any error messages. Inside the page code, define this method:
6 |
7 | ```php
8 | function onLogin()
9 | {
10 | try {
11 | return $this->account->onLogin();
12 | }
13 | catch (Exception $ex) {
14 | Log::error($ex);
15 | }
16 | }
17 | ```
18 |
19 | Here the local handler method will take priority over the **account** component's event handler. Then we simply inherit the logic by calling the parent handler manually, via the component object (`$this->account`).
20 |
--------------------------------------------------------------------------------
/docs/component-registration.md:
--------------------------------------------------------------------------------
1 | # Registration Component
2 |
3 | ## Using a Login Name
4 |
5 | By default the User plugin will use the email address as the login name. To switch to using a user defined login name, navigate to the backend under System > Users > User Settings and change the Login attribute under the Sign in tab to be **Username**. Then simply ask for a username upon registration by adding the username field:
6 |
7 | ```twig
8 |
23 | ```
24 |
25 | We can add any other additional fields here too, such as `phone`, `company`, etc.
26 |
27 |
28 |
29 | ## Password Requirements
30 |
31 | ### Password Length
32 |
33 | By default, the User plugin requires a minimum password length of 8 characters for all users when registering or changing their password. You can change this length requirement by going to backend and navigating to System > Users > User Settings. Inside the Registration tab, a **Minimum password length** field is provided, allowing you to increase or decrease this limit to your preferred length.
34 |
35 | ### Password Confirmation
36 |
37 | The `password_confirmation` field can be used to prompt the user to enter their password a second time. This input name is optional, if it is found in the postback data, then it will be validated. The following is an example.
38 |
39 | ```twig
40 |
41 |
42 | ```
43 |
44 | ## Error Handling
45 |
46 | ### Flash Messages
47 |
48 | This plugin makes use of October's [`Flash API`](https://octobercms.com/docs/markup/tag-flash). In order to display the error messages, you need to place the following snippet in your layout or page.
49 |
50 | ```twig
51 | {% flash %}
52 |
{{ message }}
53 | {% endflash %}
54 | ```
55 |
56 | ### AJAX Errors
57 |
58 | The User plugin displays AJAX error messages in a simple ``alert()``-box by default. However, this might scare non-technical users. You can change the default behavior of an AJAX error from displaying an ``alert()`` message, like this:
59 |
60 | ```js
61 |
72 | ```
73 |
74 | ### Checking Email/Username Availability
75 |
76 | Here is a simple example of how you can quickly check if an email address / username is available in your registration forms. First, inside the page code, define the following AJAX handler to check the login name, here we are using the email address:
77 |
78 | ```php
79 | public function onCheckEmail()
80 | {
81 | $user = Auth::getProvider()->retrieveByCredentials([
82 | 'email' => post('email')
83 | ]);
84 |
85 | return ['isTaken' => $user ? 1 : 0];
86 | }
87 | ```
88 |
89 | For the email input we use the `data-request` and `data-track-input` attributes to call the `onCheckEmail` handler any time the field is updated. The `data-request-success` attribute will call some jQuery code to toggle the alert box.
90 |
91 | ```html
92 |
93 |
94 |
101 |
102 |
103 |
104 | Sorry, that login name is already taken.
105 |
106 | ```
107 |
--------------------------------------------------------------------------------
/docs/component-reset-password.md:
--------------------------------------------------------------------------------
1 | # Reset Password Component
2 |
3 | The reset password component allows a user to reset their password if they have forgotten it.
4 |
5 | ```ini
6 | title = "Forgotten your password?"
7 | url = "/forgot-password/:code?"
8 |
9 | [resetPassword]
10 | paramCode = "code"
11 | ==
12 | {% component 'resetPassword' %}
13 | ```
14 |
15 | This will display the initial restoration request form and also the password reset form used after the verification email has been received by the user. The `paramCode` is the URL routing code used for resetting the password.
16 |
--------------------------------------------------------------------------------
/docs/component-session.md:
--------------------------------------------------------------------------------
1 | # Session Component
2 |
3 | The session component should be added to a layout that has registered users. It has no default markup.
4 |
5 | ## User Variable
6 |
7 | You can check the logged in user by accessing the **{{ user }}** Twig variable:
8 |
9 | ```twig
10 | {% if user %}
11 |
Hello {{ user.first_name }}
12 | {% else %}
13 |
Nobody is logged in
14 | {% endif %}
15 | ```
16 |
17 | ## Signing Out
18 |
19 | The Session component allows a user to sign out of their session.
20 |
21 | ```html
22 | Sign out
23 | ```
24 |
25 | ## Page Restriction
26 |
27 | The Session component allows the restriction of a page or layout by allowing only signed in users, only guests or no restriction. This example shows how to restrict a page to users only:
28 |
29 | ```ini
30 | title = "Restricted page"
31 | url = "/users-only"
32 |
33 | [session]
34 | security = "user"
35 | redirect = "home"
36 | ```
37 |
38 | The `security` property can be user, guest or all. The `redirect` property refers to a page name to redirect to when access is restricted.
39 |
40 | ## Route Restriction
41 |
42 | Access to routes can be restricted by applying the `AuthMiddleware`.
43 |
44 | ```php
45 | Route::group(['middleware' => \RainLab\User\Classes\AuthMiddleware::class], function () {
46 | // All routes here will require authentication
47 | });
48 | ```
49 |
50 | ## Token Variable
51 |
52 | The `token` Twig variable can be used for generating a new bearer token for the signed in user.
53 |
54 | ```twig
55 | {% do response(
56 | ajaxHandler('onLogin').withVars({
57 | token: session.token
58 | })
59 | ) %}
60 | ```
61 |
62 | The `checkToken` property of the component is used to verify a supplied token in the request headers `(Authorization: Bearer TOKEN)`.
63 |
64 | ```ini
65 | [session]
66 | checkToken = 1
67 | ```
68 |
--------------------------------------------------------------------------------
/docs/docs.yaml:
--------------------------------------------------------------------------------
1 | #
2 | # JSON Documentation
3 | #
4 | # Compile in console:
5 | #
6 | # php artisan october:util compile docs --value=rainlab.user
7 | #
8 | navigation:
9 | -
10 | title: "Introduction"
11 | link: "./introduction.md"
12 | description: "explains how to get started using the User plugin"
13 | children:
14 | -
15 | title: "Events"
16 | link: "./events.md"
17 | description: "lists all the available events found in this plugin"
18 | -
19 | title: "Tailor Integration"
20 | link: "./tailor.md"
21 | description: "guide on integration with TAilor"
22 | -
23 | title: "Components"
24 | description: "lists all the available components found in this plugin"
25 | children:
26 | -
27 | title: "Session"
28 | link: "./component-session.md"
29 | description: "checks the user session and includes the user object on the page"
30 | -
31 | title: "Account"
32 | link: "./component-account.md"
33 | description: "user management form for updating profile and security details"
34 | -
35 | title: "Authentication"
36 | link: "./component-authentication.md"
37 | description: "provides services for logging a user in"
38 | -
39 | title: "Registration"
40 | link: "./component-registration.md"
41 | description: "provides services for registering a user"
42 | -
43 | title: "Reset Password"
44 | link: "./component-reset-password.md"
45 | description: "confirms and resets the user with a new password"
46 | -
47 | title: "Services"
48 | children:
49 | -
50 | title: "Auth Manager"
51 | link: "./auth-manager.md"
52 | description: "services for managing the user session"
53 | -
54 | title: "Impersonation"
55 | link: "./auth-impersonation.md"
56 | description: "extra services for impersonating users"
57 | -
58 | title: "Bearer Tokens"
59 | link: "./auth-bearer-tokens.md"
60 | description: "extra services for JWT authentication"
61 |
--------------------------------------------------------------------------------
/docs/events.md:
--------------------------------------------------------------------------------
1 | # Events
2 |
3 | This plugin will fire some global events that can be useful for interacting with other plugins.
4 |
5 | Events | Description
6 | ------ | ---------------
7 | **rainlab.user.beforeAuthenticate** | Before the user is attempting to authenticate using the Authentication component.
8 | **rainlab.user.authenticate** | Provides custom response logic after authentication.
9 | **rainlab.user.login** | The user has successfully signed in.
10 | **rainlab.user.logout** | The user has successfully signed out.
11 | **rainlab.user.lockout** | Provides custom logic when a login attempt has been rate limited.
12 | **rainlab.user.activate** | The user has verified their email address.
13 | **rainlab.user.deactivate** | The user has opted-out of the site by deactivating their account. This should be used to disable any content the user may want removed.
14 | **rainlab.user.beforeRegister** | Before the user's registration is processed. Passed the `$input` variable by reference to enable direct modifications to the user input.
15 | **rainlab.user.register** | Provides custom response logic after registration.
16 | **rainlab.user.passwordReset** | Provides custom logic for resetting a user password.
17 | **rainlab.user.beforeUpdate** | Before the user updates their profile from the Account component.
18 | **rainlab.user.update** | The user has updated their profile information.
19 | **rainlab.user.canDeleteUser** | Triggered before a user is deleted. This event should return true if the user has dependencies and should be soft deleted to retain those relationships and allow the user to be restored. Otherwise, it will be deleted forever.
20 | **rainlab.user.getNotificationVars** | Fires when sending a user notification to enable passing more variables to the email templates. Passes the `$user` model the template will be for.
21 | **rainlab.user.view.extendListToolbar** | Fires when the user listing page's toolbar is rendered.
22 | **rainlab.user.view.extendPreviewToolbar** | Fires when the user preview page's toolbar is rendered.
23 | **rainlab.user.view.extendPreviewTabs** | Provides an opportunity to add tabs to the user preview page in the admin panel. The event should return an array of `[Tab Name => ~/path/to/partial.php]`
24 |
25 | Here is an example of hooking an event:
26 |
27 | ```php
28 | Event::listen('rainlab.user.deactivate', function($user) {
29 | // Hide all posts by the user
30 | });
31 | ```
32 |
33 | A common requirement is to adapt another to a legacy authentication system. In the example below, the `WordPressLogin::check` method would check the user password using an alternative hashing method, and if successful, update to the new one used by October.
34 |
35 | ```php
36 | Event::listen('rainlab.user.beforeAuthenticate', function($component, $credentials) {
37 | $email = $credentials['email'] ?? null;
38 | $password = $credentials['password'] ?? null;
39 |
40 | // Check that the user exists with the provided email
41 | $user = Auth::getProvider()->retrieveByCredentials(['email' => $email]);
42 | if (!$user) {
43 | return;
44 | }
45 |
46 | // The user is logging in with their old WordPress account
47 | // for the first time. Rehash their password using the new
48 | // October system.
49 | if (WordPressLogin::check($user->password, $password)) {
50 | $user->password = $user->password_confirmation = $password;
51 | $user->forceSave();
52 | }
53 | });
54 | ```
55 |
--------------------------------------------------------------------------------
/docs/introduction.md:
--------------------------------------------------------------------------------
1 | # Introduction
2 |
3 | The User plugin brings frontend users to the CMS, allowing your users to register and sign in to their account.
4 |
5 | To get started, we recommend installing this plugin with the `RainLab.Vanilla` theme to demonstrate its functionality.
6 |
7 | - https://github.com/rainlab/vanilla-theme
8 |
--------------------------------------------------------------------------------
/docs/tailor.md:
--------------------------------------------------------------------------------
1 | # Tailor Integration
2 |
3 | This plugin includes integration with Tailor by providing content fields.
4 |
5 | ## Users Field
6 |
7 | The `users` field type allows association to one or more users via a Tailor Blueprint. The functionality is introduced by the `RainLab\User\ContentFields\UsersField` PHP class.
8 |
9 | The simplest example is to associate to a single user (belongs to relationship).
10 |
11 | ```yaml
12 | users:
13 | label: Users
14 | type: users
15 | maxItems: 1
16 | ```
17 |
18 | Set the `maxItems` to **0** to associate to an unlimited number of users (belongs to many relationship).
19 |
20 | ```yaml
21 | users:
22 | label: Users
23 | type: users
24 | maxItems: 0
25 | ```
26 |
27 | Set the `displayMode` to **controller** to show a more advanced user interface for user management.
28 |
29 | ```yaml
30 | users:
31 | label: Users
32 | type: users
33 | maxItems: 0
34 | displayMode: controller
35 | ```
36 |
37 | You may also set the `displayMode` to **taglist** to select users by their email address.
38 |
39 | ```yaml
40 | users:
41 | label: Users
42 | type: users
43 | maxItems: 0
44 | displayMode: taglist
45 | ```
46 |
--------------------------------------------------------------------------------
/helpers/User.php:
--------------------------------------------------------------------------------
1 | AdminGroup::class,
51 | ];
52 |
53 | /**
54 | * initSettingsData
55 | */
56 | public function initSettingsData()
57 | {
58 | $this->block_persistence = Config::get('rainlab.user::block_persistence', false);
59 | $this->allow_registration = Config::get('rainlab.user::allow_registration', true);
60 | $this->login_attribute = Config::get('rainlab.user::login_attribute', self::LOGIN_EMAIL);
61 |
62 | $this->password_min_length = Config::get('rainlab.user::password_policy.min_length', 8);
63 | $this->password_require_mixed_case = Config::get('rainlab.user::password_policy.require_mixed_case', false);
64 | $this->password_require_uncompromised = Config::get('rainlab.user::password_policy.require_uncompromised', false);
65 | $this->password_require_number = Config::get('rainlab.user::password_policy.require_number', true);
66 | $this->password_require_symbol = Config::get('rainlab.user::password_policy.require_symbol', false);
67 |
68 | $this->user_message_template = 'user:welcome_email';
69 | $this->system_message_template = 'user:new_user_internal';
70 | }
71 |
72 | /**
73 | * getLoginAttributeOptions
74 | */
75 | public function getLoginAttributeOptions()
76 | {
77 | return [
78 | self::LOGIN_EMAIL => ["Email"],
79 | self::LOGIN_USERNAME => ["Username"]
80 | ];
81 | }
82 |
83 | /**
84 | * makePasswordRule
85 | */
86 | public static function makePasswordRule(): PasswordRule
87 | {
88 | $setting = static::instance();
89 | $rule = PasswordRule::default();
90 |
91 | if ($setting->password_min_length) {
92 | $rule->length($setting->password_min_length);
93 | }
94 |
95 | if ($setting->password_require_mixed_case) {
96 | $rule->mixedCase();
97 | }
98 |
99 | if ($setting->password_require_uncompromised) {
100 | $rule->uncompromised();
101 | }
102 |
103 | if ($setting->password_require_number) {
104 | $rule->numbers();
105 | }
106 |
107 | if ($setting->password_require_symbol) {
108 | $rule->symbols();
109 | }
110 |
111 | return $rule;
112 | }
113 | }
114 |
--------------------------------------------------------------------------------
/models/UserGroup.php:
--------------------------------------------------------------------------------
1 | 'required|between:3,64',
36 | 'code' => 'required|regex:/^[a-zA-Z0-9_\-]+$/|unique:user_groups',
37 | ];
38 |
39 | /**
40 | * @var array Relations
41 | */
42 | public $belongsToMany = [
43 | 'users' => [
44 | User::class,
45 | 'table' => 'users_groups'
46 | ],
47 | 'users_count' => [
48 | User::class,
49 | 'table' => 'users_groups',
50 | 'count' => true
51 | ]
52 | ];
53 |
54 | /**
55 | * @var array The attributes that are mass assignable.
56 | */
57 | protected $fillable = [
58 | 'name',
59 | 'code',
60 | 'description'
61 | ];
62 |
63 | /**
64 | * delete the group
65 | * @return bool
66 | */
67 | public function delete()
68 | {
69 | $this->users()->detach();
70 |
71 | return parent::delete();
72 | }
73 |
74 | /**
75 | * getGuestGroup returns the default guest user group.
76 | */
77 | public static function getGuestGroup(): ?static
78 | {
79 | return static::findByCode(self::GROUP_GUEST);
80 | }
81 |
82 | /**
83 | * getRegisteredGroup returns the default registered user group.
84 | */
85 | public static function getRegisteredGroup(): ?static
86 | {
87 | return static::findByCode(self::GROUP_REGISTERED);
88 | }
89 |
90 | /**
91 | * scopeWithoutGuest
92 | */
93 | public function scopeWithoutGuest($query)
94 | {
95 | return $query->where('code', '<>', self::GROUP_GUEST);
96 | }
97 | }
98 |
--------------------------------------------------------------------------------
/models/UserLog.php:
--------------------------------------------------------------------------------
1 | [
69 | User::class,
70 | 'scope' => 'withTrashed'
71 | ]
72 | ];
73 |
74 | /**
75 | * createRecord adds a log for a user
76 | */
77 | public static function createRecord($userId, $type, $data = [])
78 | {
79 | $data['ip_address'] = Request::ip();
80 |
81 | $obj = new static;
82 | $obj->user_id = $userId;
83 | $obj->type = $type;
84 | $obj->data = $data;
85 | $obj->is_comment = false;
86 | $obj->is_system = false;
87 | $obj->setExpandoAttributes($data);
88 | $obj->save();
89 |
90 | return $obj;
91 | }
92 |
93 | /**
94 | * createSystemRecord adds a log for a user, generated by an administrator
95 | */
96 | public static function createSystemRecord($userId, $type, $data = [])
97 | {
98 | $data['ip_address'] = Request::ip();
99 |
100 | $obj = new static;
101 | $obj->user_id = $userId;
102 | $obj->type = $type;
103 | $obj->data = $data;
104 | $obj->is_comment = false;
105 | $obj->is_system = true;
106 | $obj->setExpandoAttributes($data);
107 | $obj->save();
108 |
109 | return $obj;
110 | }
111 |
112 | /**
113 | * createSystemComment adds a comment log for a user, generated by an administrator
114 | */
115 | public static function createSystemComment($userId, $comment)
116 | {
117 | $data = [];
118 | $data['ip_address'] = Request::ip();
119 |
120 | $obj = new static;
121 | $obj->user_id = $userId;
122 | $obj->type = self::TYPE_INTERNAL_COMMENT;
123 | $obj->comment = $comment;
124 | $obj->is_comment = true;
125 | $obj->is_system = true;
126 | $obj->data = $data;
127 | $obj->save();
128 |
129 | return $obj;
130 | }
131 | }
132 |
--------------------------------------------------------------------------------
/models/setting/fields.yaml:
--------------------------------------------------------------------------------
1 | # ===================================
2 | # Field Definitions
3 | # ===================================
4 |
5 | tabs:
6 | fields:
7 |
8 | # Sign In tab
9 |
10 | login_attribute:
11 | label: Login Attribute
12 | span: auto
13 | commentAbove: Select what primary user detail should be used for signing in.
14 | type: radio
15 | tab: Sign In
16 |
17 | block_persistence:
18 | label: Prevent Concurrent Sessions
19 | span: full
20 | comment: When enabled users cannot sign in to multiple devices at the same time.
21 | type: checkbox
22 | tab: Sign In
23 |
24 | # Registration tab
25 |
26 | allow_registration:
27 | label: Allow User Registration
28 | span: full
29 | comment: If this is disabled users can only be created by administrators.
30 | type: switch
31 | tab: Registration
32 |
33 | _registration_ruler:
34 | type: ruler
35 | tab: Registration
36 |
37 | password_min_length:
38 | label: Password Length
39 | span: left
40 | type: number
41 | commentAbove: Minimum password length required for users
42 | tab: Registration
43 |
44 | password_require_mixed_case:
45 | label: Require Mixed Case
46 | span: left
47 | type: checkbox
48 | comment: Require at least one uppercase and lowercase letter
49 | tab: Registration
50 |
51 | password_require_uncompromised:
52 | label: Require Uncompromised
53 | span: right
54 | type: checkbox
55 | comment: Require a password not found in a leaked password database
56 | tab: Registration
57 |
58 | password_require_number:
59 | label: Require Number
60 | span: left
61 | type: checkbox
62 | comment: Require at least one number
63 | tab: Registration
64 |
65 | password_require_symbol:
66 | label: Require Special Character
67 | span: right
68 | type: checkbox
69 | comment: Require at least one non-alphanumeric character
70 | tab: Registration
71 |
72 | # Notifications tab
73 |
74 | _template_hint:
75 | type: hint
76 | comment: You can customize mail templates by selecting Mail → Mail Templates from the settings menu.
77 | tab: Notifications
78 |
79 | notify_user:
80 | label: Notify User
81 | type: checkbox
82 | tab: Notifications
83 | comment: Send a welcome message to the user when they confirm their email address.
84 |
85 | user_message_template:
86 | label: User Message Template
87 | commentAbove: Select the mail template to send to the user.
88 | type: dropdown
89 | optionsMethod: System\Models\MailTemplate::listAllTemplates
90 | valueTrans: false
91 | tab: Notifications
92 | cssClass: field-indent
93 | trigger:
94 | action: enable
95 | field: notify_user
96 | condition: checked
97 |
98 | notify_system:
99 | label: Notify Administrators
100 | type: checkbox
101 | tab: Notifications
102 | comment: Notify administrators when a new user confirms their email.
103 |
104 | system_message_template:
105 | label: System Message Template
106 | commentAbove: Select the mail template to send to the admins.
107 | type: dropdown
108 | optionsMethod: System\Models\MailTemplate::listAllTemplates
109 | valueTrans: false
110 | tab: Notifications
111 | cssClass: field-indent
112 | trigger:
113 | action: enable
114 | field: notify_system
115 | condition: checked
116 |
117 | admin_group:
118 | label: Notify Admin Group
119 | commentAbove: Specify the administrator group that should receive a notification when a new user joins.
120 | type: relation
121 | tab: Notifications
122 | span: full
123 | cssClass: field-indent
124 | trigger:
125 | action: enable
126 | field: notify_system
127 | condition: checked
128 |
--------------------------------------------------------------------------------
/models/user/HasAuthenticatable.php:
--------------------------------------------------------------------------------
1 | getKeyName();
20 | }
21 |
22 | /**
23 | * getAuthIdentifier for the user.
24 | */
25 | public function getAuthIdentifier()
26 | {
27 | return $this->{$this->getAuthIdentifierName()};
28 | }
29 |
30 | /**
31 | * getAuthPasswordName of the password attribute for the user.
32 | */
33 | public function getAuthPasswordName()
34 | {
35 | return 'password';
36 | }
37 |
38 | /**
39 | * getAuthIdentifierForBroadcasting
40 | */
41 | public function getAuthIdentifierForBroadcasting()
42 | {
43 | return $this->getAuthIdentifier();
44 | }
45 |
46 | /**
47 | * getAuthPassword for the user.
48 | * @return string
49 | */
50 | public function getAuthPassword()
51 | {
52 | return $this->password;
53 | }
54 |
55 | /**
56 | * getRememberToken value for the "remember me" session.
57 | * @return string|null
58 | */
59 | public function getRememberToken()
60 | {
61 | if (!empty($this->getRememberTokenName())) {
62 | return (string) $this->{$this->getRememberTokenName()};
63 | }
64 | }
65 |
66 | /**
67 | * setRememberToken value for the "remember me" session.
68 | * @param string $value
69 | */
70 | public function setRememberToken($value)
71 | {
72 | if (!empty($this->getRememberTokenName())) {
73 | $this->{$this->getRememberTokenName()} = $value;
74 | }
75 | }
76 |
77 | /**
78 | * getRememberTokenName gets the column name for the "remember me" token.
79 | * @return string
80 | */
81 | public function getRememberTokenName()
82 | {
83 | return $this->rememberTokenName;
84 | }
85 | }
86 |
--------------------------------------------------------------------------------
/models/user/HasModelAttributes.php:
--------------------------------------------------------------------------------
1 | {$attribute};
28 | }
29 |
30 | /**
31 | * getFullNameAttribute
32 | */
33 | public function getFullNameAttribute()
34 | {
35 | return "{$this->first_name} {$this->last_name}";
36 | }
37 |
38 | /**
39 | * getAvatarUrl
40 | */
41 | public function getAvatarUrlAttribute()
42 | {
43 | return $this->relationLoaded('avatar')
44 | ? $this->getAvatarThumb()
45 | : null;
46 | }
47 |
48 | /**
49 | * getIsBannedAttribute
50 | */
51 | public function getIsBannedAttribute()
52 | {
53 | return $this->banned_at !== null;
54 | }
55 |
56 | /**
57 | * getIsActivatedAttribute
58 | */
59 | public function getIsActivatedAttribute()
60 | {
61 | return $this->activated_at !== null;
62 | }
63 |
64 | /**
65 | * getIsTwoFactorEnabledAttribute
66 | */
67 | public function getIsTwoFactorEnabledAttribute()
68 | {
69 | return $this->two_factor_confirmed_at !== null;
70 | }
71 |
72 | /**
73 | * setIsTwoFactorEnabledAttribute
74 | */
75 | public function setIsTwoFactorEnabledAttribute($value)
76 | {
77 | if ($value && !$this->two_factor_confirmed_at) {
78 | $this->two_factor_confirmed_at = $this->freshTimestamp();
79 | }
80 |
81 | if (!$value) {
82 | $this->two_factor_confirmed_at = null;
83 | }
84 | }
85 |
86 | /**
87 | * setPasswordAttribute protects the password from being reset to null
88 | */
89 | public function setPasswordAttribute($value)
90 | {
91 | if ($this->exists && empty($value)) {
92 | unset($this->attributes['password']);
93 | }
94 | else {
95 | $this->attributes['password'] = $value;
96 | }
97 | }
98 |
99 | /**
100 | * @deprecated use `login` attribute
101 | * @see getLoginAttribute
102 | */
103 | public function getLogin()
104 | {
105 | return $this->login;
106 | }
107 | }
108 |
--------------------------------------------------------------------------------
/models/user/HasModelScopes.php:
--------------------------------------------------------------------------------
1 | where('is_guest', false);
17 | }
18 |
19 | /**
20 | * applyStatusCode
21 | */
22 | public function scopeApplyStatusCode($query, $value)
23 | {
24 | if ($value instanceof \Backend\Classes\FilterScope) {
25 | $value = $value->value;
26 | }
27 |
28 | if ($value === 'deleted') {
29 | return $query->onlyTrashed();
30 | }
31 |
32 | if ($value === 'active') {
33 | return $query->withoutTrashed()->whereNotNull('activated_at');
34 | }
35 |
36 | if ($value === 'inactive') {
37 | return $query->withoutTrashed()->whereNull('activated_at');
38 | }
39 |
40 | return $query->withoutTrashed();
41 | }
42 |
43 | /**
44 | * scopeIsActivated
45 | */
46 | public function scopeIsActivated($query)
47 | {
48 | return $query->whereNotNull('activated_at');
49 | }
50 |
51 | /**
52 | * scopeApplyPrimaryGroup
53 | */
54 | public function scopeApplyPrimaryGroup($query, $filter)
55 | {
56 | if ($filter instanceof \Backend\Classes\FilterScope) {
57 | $filter = $filter->value;
58 | }
59 |
60 | return $query->whereIn('primary_group_id', (array) $filter);
61 | }
62 |
63 | /**
64 | * scopeApplyGroups
65 | */
66 | public function scopeApplyGroups($query, $filter)
67 | {
68 | return $query->whereHas('groups', function($group) use ($filter) {
69 | $group->whereIn('id', $filter);
70 | });
71 | }
72 |
73 | /**
74 | * @deprecated
75 | */
76 | public function scopeFilterByGroup($query, $filter)
77 | {
78 | return $this->scopeApplyGroups($query, $filter);
79 | }
80 | }
81 |
--------------------------------------------------------------------------------
/models/user/HasPasswordReset.php:
--------------------------------------------------------------------------------
1 | passwordResetUrl = $url;
24 | }
25 |
26 | /**
27 | * getEmailForPasswordReset
28 | * @return string
29 | */
30 | public function getEmailForPasswordReset()
31 | {
32 | return $this->email;
33 | }
34 |
35 | /**
36 | * sendPasswordResetNotification
37 | * @param string $token
38 | */
39 | public function sendPasswordResetNotification($token)
40 | {
41 | $url = $this->passwordResetUrl ?: Cms::entryUrl('resetPassword');
42 | $url .= str_contains($url, '?') ? '&' : '?';
43 | $url .= http_build_query([
44 | 'reset' => $token,
45 | 'email' => $this->getEmailForPasswordReset()
46 | ]);
47 |
48 | $data = [
49 | 'url' => $url,
50 | 'token' => $token,
51 | 'count' => Config::get('auth.passwords.users.expire')
52 | ];
53 |
54 | $data += $this->getNotificationVars();
55 |
56 | Mail::send('user:recover_password', $data, function($message) {
57 | $message->to($this->email, $this->full_name);
58 | });
59 | }
60 |
61 | /**
62 | * sendConfirmRegistrationNotification welcomes a new user an invites them to set a password
63 | */
64 | public function sendConfirmRegistrationNotification()
65 | {
66 | $token = Password::createToken($this);
67 |
68 | $url = $this->passwordResetUrl ?: Cms::entryUrl('resetPassword');
69 | $url .= str_contains($url, '?') ? '&' : '?';
70 | $url .= http_build_query([
71 | 'reset' => $token,
72 | 'email' => $this->getEmailForPasswordReset(),
73 | 'new' => true
74 | ]);
75 |
76 | $data = [
77 | 'url' => $url,
78 | 'token' => $token,
79 | 'count' => Config::get('auth.passwords.users.expire')
80 | ];
81 |
82 | $data += $this->getNotificationVars();
83 |
84 | Mail::send('user:invite_email', $data, function($message) {
85 | $message->to($this->email, $this->full_name);
86 | });
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/models/user/HasPersistCode.php:
--------------------------------------------------------------------------------
1 | persist_code) {
18 | return $this->persist_code;
19 | }
20 |
21 | $timestamps = $this->timestamps;
22 |
23 | $this->timestamps = false;
24 |
25 | $this->setPersistCode($code = $this->generatePersistCode());
26 |
27 | $this->save(['force' => true]);
28 |
29 | $this->timestamps = $timestamps;
30 |
31 | return $code;
32 | }
33 |
34 | /**
35 | * setPersistCode sets a persistence code
36 | */
37 | public function setPersistCode($code)
38 | {
39 | $this->persist_code = $code;
40 | }
41 |
42 | /**
43 | * generateRecoveryCode
44 | */
45 | public function generatePersistCode(): string
46 | {
47 | return Str::random(42);
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/models/user/HasTwoFactor.php:
--------------------------------------------------------------------------------
1 | generateSecretKey();
26 |
27 | $recoveryCodes = Collection::times(8, function() {
28 | return $this->generateRecoveryCode();
29 | })->all();
30 |
31 | $this->forceFill([
32 | 'two_factor_secret' => $secretKey,
33 | 'two_factor_recovery_codes' => json_encode($recoveryCodes),
34 | ]);
35 |
36 | $this->save();
37 | }
38 |
39 | /**
40 | * generateNewRecoveryCodes
41 | */
42 | public function generateNewRecoveryCodes()
43 | {
44 | $recoveryCodes = Collection::times(8, function() {
45 | return $this->generateRecoveryCode();
46 | })->all();
47 |
48 | $this->forceFill([
49 | 'two_factor_recovery_codes' => json_encode($recoveryCodes),
50 | ]);
51 |
52 | $this->save();
53 | }
54 |
55 | /**
56 | * disableTwoFactorAuthentication
57 | */
58 | public function disableTwoFactorAuthentication()
59 | {
60 | if ($this->two_factor_secret !== null ||
61 | $this->two_factor_recovery_codes !== null ||
62 | $this->two_factor_confirmed_at !== null
63 | ) {
64 | $this->forceFill([
65 | 'two_factor_secret' => null,
66 | 'two_factor_recovery_codes' => null,
67 | 'two_factor_confirmed_at' => null
68 | ]);
69 |
70 | $this->save();
71 | }
72 | }
73 |
74 | /**
75 | * @return bool hasEnabledTwoFactorAuthentication determines if two-factor authentication has been enabled.
76 | */
77 | public function hasEnabledTwoFactorAuthentication()
78 | {
79 | return $this->two_factor_secret !== null && $this->two_factor_confirmed_at !== null;
80 | }
81 |
82 | /**
83 | * recoveryCodes gets the user two factor authentication recovery codes.
84 | */
85 | public function recoveryCodes(): array
86 | {
87 | return json_decode($this->two_factor_recovery_codes, true);
88 | }
89 |
90 | /**
91 | * replaceRecoveryCode with a new one in the user's stored codes.
92 | */
93 | public function replaceRecoveryCode(string $code)
94 | {
95 | $this->forceFill([
96 | 'two_factor_recovery_codes' => str_replace(
97 | $code,
98 | $this->generateRecoveryCode(),
99 | $this->two_factor_recovery_codes
100 | ),
101 | ]);
102 |
103 | $this->save();
104 | }
105 |
106 | /**
107 | * twoFactorQrCodeSvg gets the QR code SVG of the user's two factor authentication QR code URL.
108 | */
109 | public function twoFactorQrCodeSvg(): string
110 | {
111 | $url = $this->twoFactorQrCodeUrl();
112 | if (!$url) {
113 | return '';
114 | }
115 |
116 | $svg = (new Writer(
117 | new ImageRenderer(
118 | new RendererStyle(192, 0, null, null, Fill::uniformColor(new Rgb(255, 255, 255), new Rgb(45, 55, 72))),
119 | new SvgImageBackEnd
120 | )
121 | ))->writeString($url);
122 |
123 | return trim(substr($svg, strpos($svg, "\n") + 1));
124 | }
125 |
126 | /**
127 | * twoFactorQrCodeUrl gets the two factor authentication QR code URL.
128 | */
129 | public function twoFactorQrCodeUrl(): string
130 | {
131 | if (!$this->two_factor_secret) {
132 | return '';
133 | }
134 |
135 | return TwoFactorManager::instance()->qrCodeUrl(
136 | Config::Get('app.name'),
137 | $this->{UserHelper::username()},
138 | $this->two_factor_secret
139 | );
140 | }
141 |
142 | /**
143 | * generateRecoveryCode
144 | */
145 | public function generateRecoveryCode(): string
146 | {
147 | return Str::random(10) . '-' . Str::random(10);
148 | }
149 | }
150 |
--------------------------------------------------------------------------------
/models/user/UserExport.php:
--------------------------------------------------------------------------------
1 | type));
27 |
28 | $path = plugins_path("rainlab/user/models/userlog/_detail_{$typeName}.php");
29 |
30 | if ($event = Event::fire('rainlab.user.extendLogDetailViewPath', [$this, $this->type], true)) {
31 | $path = $event;
32 | }
33 |
34 | return file_exists($path) ? View::file($path, ['record' => $this]) : "{$this->type} event";
35 | }
36 |
37 | /**
38 | * getActorNameAttribute returns the `actor_admin_name` attribute
39 | */
40 | public function getActorAdminNameAttribute()
41 | {
42 | if ($this->created_user_id) {
43 | return $this->created_user_id === $this->getUserFootprintAuth()->id()
44 | ? __("You")
45 | : ($this->created_user?->full_name ?: __("Admin"));
46 | }
47 |
48 | return __("System");
49 | }
50 |
51 | /**
52 | * getActorNameAttribute returns the `actor_user_name` attribute
53 | */
54 | public function getActorUserNameAttribute()
55 | {
56 | if ($this->user_full_name) {
57 | return $this->user_full_name;
58 | }
59 |
60 | if ($this->user_id) {
61 | return $this->user?->full_name ?: __("User");
62 | }
63 |
64 | return __("User");
65 | }
66 |
67 | /**
68 | * getUserBackendLinkageAttribute returns the `user_backend_linkage` attribute
69 | */
70 | public function getUserBackendLinkageAttribute()
71 | {
72 | if (App::runningInBackend() && $this->user) {
73 | return [
74 | Backend::url("user/users/preview/{$this->user->id}"),
75 | $this->user->full_name
76 | ];
77 | }
78 |
79 | return '';
80 | }
81 | }
82 |
--------------------------------------------------------------------------------
/models/userlog/_column_detail.php:
--------------------------------------------------------------------------------
1 | detail ?>
2 |
--------------------------------------------------------------------------------
/models/userlog/_detail_new_user.php:
--------------------------------------------------------------------------------
1 | is_system): ?>
2 | e($record->actor_admin_name)]) ?>
3 |
4 | e($record->actor_user_name)]) ?>
5 |
6 |
--------------------------------------------------------------------------------
/models/userlog/_detail_self_delete.php:
--------------------------------------------------------------------------------
1 | e($record->actor_user_name)]) ?>
2 |
--------------------------------------------------------------------------------
/models/userlog/_detail_self_login.php:
--------------------------------------------------------------------------------
1 | is_two_factor): ?>
2 | e($record->actor_user_name)]) ?>
3 |
4 | e($record->actor_user_name)]) ?>
5 |
6 |
--------------------------------------------------------------------------------
/models/userlog/_detail_self_verify.php:
--------------------------------------------------------------------------------
1 | e($record->actor_user_name),
3 | 'user_email' => e($record->user_email),
4 | ]) ?>
5 |
--------------------------------------------------------------------------------
/models/userlog/_detail_set_email.php:
--------------------------------------------------------------------------------
1 | e($record->old_value),
4 | 'new_value' => e($record->new_value)
5 | ];
6 | ?>
7 | is_system): ?>
8 | e($record->actor_admin_name),
10 | ]) ?>
11 |
12 | e($record->actor_user_name)
14 | ]) ?>
15 |
16 |
--------------------------------------------------------------------------------
/models/userlog/_detail_set_password.php:
--------------------------------------------------------------------------------
1 | is_system): ?>
2 | e($record->actor_admin_name),
4 | ]) ?>
5 |
6 | e($record->actor_user_name)
8 | ]) ?>
9 |
10 |
--------------------------------------------------------------------------------
/models/userlog/_detail_set_two_factor.php:
--------------------------------------------------------------------------------
1 | is_two_factor_enabled): ?>
2 | e($record->actor_user_name)]) ?>
3 |
4 | e($record->actor_user_name)]) ?>
5 |
6 |
--------------------------------------------------------------------------------
/models/userlog/columns-global.yaml:
--------------------------------------------------------------------------------
1 | # ===================================
2 | # List Column Definitions
3 | # ===================================
4 |
5 | columns:
6 | detail:
7 | label: Detail
8 | type: partial
9 | searchable: false
10 | sortable: false
11 |
12 | user_full_name:
13 | label: User
14 | relation: user
15 | valueFrom: fullname
16 | type: linkage
17 | displayFrom: user_backend_linkage
18 |
19 | created_at:
20 | label: Created
21 | type: timetense
22 | sortable: true
23 | searchable: false
24 |
--------------------------------------------------------------------------------
/models/userlog/columns.yaml:
--------------------------------------------------------------------------------
1 | # ===================================
2 | # List Column Definitions
3 | # ===================================
4 |
5 | columns:
6 | detail:
7 | label: Detail
8 | type: partial
9 | searchable: false
10 | sortable: false
11 |
12 | created_at:
13 | label: Created
14 | type: timetense
15 | sortable: true
16 | searchable: false
17 |
--------------------------------------------------------------------------------
/models/userlog/fields.yaml:
--------------------------------------------------------------------------------
1 | # ===================================
2 | # Form Field Definitions
3 | # ===================================
4 |
5 | fields:
6 | id:
7 | label: ID
8 | disabled: true
9 |
--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
1 |
2 |
13 |
14 |
15 | ./tests
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
--------------------------------------------------------------------------------
/tests/AuthManagerTest.php:
--------------------------------------------------------------------------------
1 | 'Some',
17 | 'last_name' => 'User',
18 | 'email' => 'some@website.tld',
19 | 'password' => 'ChangeMe888',
20 | 'password_confirmation' => 'ChangeMe888',
21 | ]);
22 |
23 | $this->assertEquals(1, User::count());
24 | $this->assertInstanceOf(User::class, $user);
25 |
26 | $this->assertFalse($user->is_activated);
27 | $this->assertEquals('Some User', $user->full_name);
28 | $this->assertEquals('some@website.tld', $user->email);
29 | }
30 |
31 | /**
32 | * testRegisterUserWithAutoActivation
33 | */
34 | public function testRegisterUserWithAutoActivation()
35 | {
36 | // Stop activation events from other plugins
37 | Event::forget('rainlab.user.activate');
38 |
39 | $user = User::create([
40 | 'first_name' => 'Some',
41 | 'last_name' => 'User',
42 | 'email' => 'some@website.tld',
43 | 'password' => 'ChangeMe888',
44 | 'password_confirmation' => 'ChangeMe888',
45 | ]);
46 |
47 | $user->markEmailAsVerified();
48 | Auth::loginQuietly($user);
49 |
50 | $this->assertTrue($user->is_activated);
51 | $this->assertTrue($user->hasVerifiedEmail());
52 | $this->assertNotNull(Auth::user());
53 | }
54 |
55 | /**
56 | * testRegisterGuest
57 | */
58 | public function testRegisterGuest()
59 | {
60 | $guest = User::create([
61 | 'first_name' => 'Some',
62 | 'last_name' => 'User',
63 | 'email' => 'person@acme.tld',
64 | 'is_guest' => true
65 | ]);
66 |
67 | $this->assertEquals(1, User::count());
68 | $this->assertInstanceOf(User::class, $guest);
69 |
70 | $this->assertTrue($guest->is_guest);
71 | $this->assertEquals('person@acme.tld', $guest->email);
72 |
73 | $secondGuest = User::create([
74 | 'first_name' => 'Some',
75 | 'last_name' => 'User',
76 | 'email' => 'person@acme.tld',
77 | 'password' => 'ChangeMe888',
78 | 'password_confirmation' => 'ChangeMe888',
79 | 'is_guest' => true
80 | ]);
81 |
82 | $this->assertEquals(2, User::count());
83 | $this->assertInstanceOf(User::class, $secondGuest);
84 | $this->assertTrue($guest->is_guest);
85 | $this->assertEquals('person@acme.tld', $guest->email);
86 |
87 | $firstGuest = User::where('email', 'person@acme.tld')->first();
88 | $firstGuest->convertToRegistered(false);
89 |
90 | $this->assertEquals('person@acme.tld', $firstGuest->email);
91 | $this->assertFalse($firstGuest->is_guest);
92 | }
93 |
94 | /**
95 | * testLoginAndCheckAuth
96 | */
97 | public function testLoginAndCheckAuth()
98 | {
99 | $this->assertFalse(Auth::check());
100 |
101 | $user = User::create([
102 | 'first_name' => 'Some',
103 | 'last_name' => 'User',
104 | 'email' => 'some@website.tld',
105 | 'password' => 'ChangeMe888',
106 | 'password_confirmation' => 'ChangeMe888',
107 | ]);
108 |
109 | $user->markEmailAsVerified();
110 |
111 | Auth::login($user);
112 |
113 | $this->assertTrue(Auth::check());
114 | }
115 | }
116 |
--------------------------------------------------------------------------------
/traits/ConfirmsPassword.php:
--------------------------------------------------------------------------------
1 | isUserPasswordValid(post('confirmable_password'))) {
23 | throw new ValidationException([
24 | 'confirmable_password' => __('This password does not match our records.'),
25 | ]);
26 | }
27 |
28 | Session::put(['auth.password_confirmed_at' => time()]);
29 |
30 | $this->dispatchBrowserEvent('app:password-confirmed');
31 |
32 | return ['passwordConfirmed' => true];
33 | }
34 |
35 | /**
36 | * isUserPasswordValid
37 | */
38 | protected function isUserPasswordValid(string $password): bool
39 | {
40 | $user = Auth::user();
41 | $username = UserHelper::username();
42 |
43 | if (!$user || !$password) {
44 | return false;
45 | }
46 |
47 | return Auth::validate([
48 | $username => $user->{$username},
49 | 'password' => $password
50 | ]);
51 | }
52 |
53 | /**
54 | * checkConfirmedPassword checks if the user password has been confirmed
55 | */
56 | protected function checkConfirmedPassword()
57 | {
58 | if ($this->passwordIsConfirmed()) {
59 | return;
60 | }
61 |
62 | $this->dispatchBrowserEvent('app:password-confirming');
63 |
64 | return ['confirmingPassword' => true];
65 | }
66 |
67 | /**
68 | * passwordIsConfirmed determine if the user's password has been recently confirmed.
69 | */
70 | protected function passwordIsConfirmed(?int $maxSecondsSinceConfirmation = null): bool
71 | {
72 | $maxSecondsSinceConfirmation = $maxSecondsSinceConfirmation ?: Config::get('auth.password_timeout', 900);
73 |
74 | return (time() - Session::get('auth.password_confirmed_at', 0)) < $maxSecondsSinceConfirmation;
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/updates/000001_create_users.php:
--------------------------------------------------------------------------------
1 | bigIncrements('id');
12 | $table->boolean('is_guest')->default(false);
13 | $table->boolean('is_mail_blocked')->default(false);
14 | $table->string('first_name')->nullable();
15 | $table->string('last_name')->nullable();
16 | $table->string('username')->nullable()->index();
17 | $table->string('email');
18 | $table->mediumText('notes')->nullable();
19 | $table->string('password');
20 | $table->string('activation_code')->nullable()->index();
21 | $table->string('persist_code')->nullable();
22 | $table->string('remember_token')->nullable();
23 | $table->text('two_factor_secret')->nullable();
24 | $table->text('two_factor_recovery_codes')->nullable();
25 | $table->bigInteger('primary_group_id')->nullable()->unsigned();
26 | $table->string('created_ip_address')->nullable();
27 | $table->string('last_ip_address')->nullable();
28 | $table->text('banned_reason')->nullable();
29 | $table->timestamp('banned_at')->nullable();
30 | $table->timestamp('activated_at')->nullable();
31 | $table->timestamp('two_factor_confirmed_at')->nullable();
32 | $table->timestamp('last_seen')->nullable();
33 | $table->timestamp('deleted_at')->nullable();
34 | $table->timestamps();
35 | });
36 | }
37 |
38 | public function down()
39 | {
40 | Schema::dropIfExists('users');
41 | }
42 | };
43 |
--------------------------------------------------------------------------------
/updates/000002_create_password_resets.php:
--------------------------------------------------------------------------------
1 | string('email')->primary();
12 | $table->string('token');
13 | $table->timestamp('created_at')->nullable();
14 | });
15 | }
16 |
17 | public function down()
18 | {
19 | Schema::dropIfExists('user_password_resets');
20 | }
21 | };
22 |
--------------------------------------------------------------------------------
/updates/000003_create_user_groups.php:
--------------------------------------------------------------------------------
1 | bigIncrements('id');
12 | $table->string('name');
13 | $table->string('code')->nullable()->index();
14 | $table->text('description')->nullable();
15 | $table->timestamps();
16 | });
17 |
18 | Schema::create('users_groups', function(Blueprint $table) {
19 | $table->bigInteger('user_id')->unsigned();
20 | $table->bigInteger('user_group_id')->unsigned();
21 | $table->primary(['user_id', 'user_group_id'], 'rainlab_user_group');
22 | });
23 | }
24 |
25 | public function down()
26 | {
27 | Schema::dropIfExists('user_groups');
28 | Schema::dropIfExists('users_groups');
29 | }
30 | };
31 |
--------------------------------------------------------------------------------
/updates/000004_create_user_preferences.php:
--------------------------------------------------------------------------------
1 | bigIncrements('id');
12 | $table->bigInteger('user_id')->unsigned()->nullable()->index();
13 | $table->string('item')->index()->nullable();
14 | $table->mediumText('value')->nullable();
15 | $table->timestamps();
16 | });
17 | }
18 |
19 | public function down()
20 | {
21 | Schema::dropIfExists('rainlab_user_preferences');
22 | }
23 | };
24 |
--------------------------------------------------------------------------------
/updates/000005_create_user_logs.php:
--------------------------------------------------------------------------------
1 | bigIncrements('id');
19 | $table->bigInteger('user_id')->unsigned()->nullable()->index();
20 | $table->string('type')->nullable();
21 | $table->mediumText('data')->nullable();
22 | $table->mediumText('comment')->nullable();
23 | $table->boolean('is_comment')->default(false)->index();
24 | $table->boolean('is_system')->default(false);
25 | $table->bigInteger('updated_user_id')->unsigned()->nullable();
26 | $table->bigInteger('created_user_id')->unsigned()->nullable();
27 | $table->timestamps();
28 | });
29 | }
30 |
31 | /**
32 | * down reverses the migration
33 | */
34 | public function down()
35 | {
36 | Schema::dropIfExists('rainlab_user_user_logs');
37 | }
38 | };
39 |
--------------------------------------------------------------------------------
/updates/migrate_v3_0_0.php:
--------------------------------------------------------------------------------
1 | setUp(__DIR__.'/000002_create_password_resets.php');
13 | $updater->setUp(__DIR__.'/000004_create_user_preferences.php');
14 | $updater->setUp(__DIR__.'/000005_create_user_logs.php');
15 | }
16 |
17 | if (!Schema::hasColumn('users', 'first_name')) {
18 | Schema::table('users', function(Blueprint $table) {
19 | $table->boolean('is_mail_blocked')->default(false);
20 | $table->string('first_name')->nullable();
21 | $table->string('last_name')->nullable();
22 | $table->mediumText('notes')->nullable();
23 | $table->bigInteger('primary_group_id')->nullable()->unsigned();
24 | $table->string('remember_token')->nullable();
25 | $table->text('banned_reason')->nullable();
26 | $table->timestamp('banned_at')->nullable();
27 | $table->text('two_factor_secret')->nullable();
28 | $table->text('two_factor_recovery_codes')->nullable();
29 | $table->timestamp('two_factor_confirmed_at')->nullable();
30 | });
31 |
32 | Db::update("update users set first_name=name, last_name=surname");
33 | }
34 |
35 | if (Schema::hasTable('rainlab_user_mail_blockers')) {
36 | $emails = Db::table('rainlab_user_mail_blockers')->where('template', '*')->pluck('email');
37 | foreach ($emails->chunk(100) as $chunks) {
38 | Db::table('users')->whereIn('email', $chunks)->update(['is_mail_blocked' => true]);
39 | }
40 | }
41 | }
42 |
43 | public function down()
44 | {
45 | }
46 | };
47 |
--------------------------------------------------------------------------------
/updates/migrate_v3_1_0.php:
--------------------------------------------------------------------------------
1 | string('activation_code')->nullable()->index();
13 | });
14 | }
15 | }
16 |
17 | public function down()
18 | {
19 | }
20 | };
21 |
--------------------------------------------------------------------------------
/updates/seed_tables.php:
--------------------------------------------------------------------------------
1 | 'Guest',
18 | 'code' => 'guest',
19 | 'description' => 'Default group for guest users.'
20 | ]);
21 |
22 | UserGroup::create([
23 | 'name' => 'Registered',
24 | 'code' => 'registered',
25 | 'description' => 'Default group for registered users.'
26 | ]);
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/updates/version.yaml:
--------------------------------------------------------------------------------
1 | v1.0.1: First version of User
2 | v1.0.2:
3 | - Set up database tables
4 | - 000001_create_users.php
5 | - 000002_create_password_resets.php
6 | - 000003_create_user_groups.php
7 | - 000004_create_user_preferences.php
8 | - 000005_create_user_logs.php
9 | v1.0.3:
10 | - Seed all database tables
11 | - seed_tables.php
12 | v1.1.0: Profile fields and Locations have been removed.
13 | v1.2.0: Users can now deactivate their own accounts.
14 | v1.3.0: Introduced guest user accounts.
15 | v1.4.0: The Notifications tab in User Settings has been removed.
16 | v1.5.0: Required password length is now a minimum of 8 characters. Previous passwords will not be affected until the next password change.
17 | v1.6.0: Apply persistence settings on activation and registration. Fixes last seen touched when impersonating. Fixes user suspension not clearing.
18 | v1.7.0: Add password policy
19 | v1.7.1: Fixes compatibility with legacy sites
20 | v2.0.0: Compatibility with October v3 only
21 | v2.1.0: Adds bearer token (JWT) support to session component
22 | v3.0.0:
23 | - Major Upgrade to User Plugin
24 | - migrate_v3_0_0.php
25 | v3.0.4: Fixes bug in JWT authentication check
26 | v3.0.5: Adds permission for viewing user activity log
27 | v3.0.7: Fixes missing notification variables in mail templates
28 | v3.1.0:
29 | - New email verification logic
30 | - migrate_v3_1_0.php
31 | v3.1.1: Fixes compatibility with Mall plugin
32 | v3.1.3: Translation updates
33 | v3.2.0: Fixes events with 2FA, requires October v3.7 or above
34 | v3.2.1: Fixes support with Tailor integration
35 |
--------------------------------------------------------------------------------
/views/mail/invite_email.htm:
--------------------------------------------------------------------------------
1 | subject = "An Account Has Been Created For You"
2 | description = "Invite a new user to the website"
3 | ==
4 | Hello {{ first_name }}
5 |
6 | You are receiving this email because we received a request to create a new user account for you. If you did not perform this request, you can safely ignore this email.
7 |
8 | {% partial 'button' url=url body %}
9 | Confirm Account
10 | {% endpartial %}
11 |
12 | This confirmation link will expire in {{ count }} minutes. You may attempt this again using our password recovery service.
13 |
14 | {% partial 'subcopy' body %}
15 | If you're having trouble clicking the button, copy the URL below into your browser.
16 |
17 | {{ url|raw }}
18 | {% endpartial %}
19 |
--------------------------------------------------------------------------------
/views/mail/new_user_internal.htm:
--------------------------------------------------------------------------------
1 | subject = "A new user has signed up"
2 | description = "Notify admins of a new sign up"
3 | layout = "system"
4 | ==
5 | A new user has just signed up. Here are there details:
6 |
7 | - ID: `{{ id }}`
8 | - Name: `{{ full_name }}`
9 | - Email: `{{ email }}`
10 |
--------------------------------------------------------------------------------
/views/mail/recover_password.htm:
--------------------------------------------------------------------------------
1 | subject = "Reset Password Notification"
2 | description = "User has requested to recover their password"
3 | ==
4 | # Hello {{ first_name }}
5 |
6 | You are receiving this email because we received a password recovery request for your account. If you did not perform this request, you can safely ignore this email.
7 |
8 | {% partial 'button' url=url body %}
9 | Reset Password
10 | {% endpartial %}
11 |
12 | This password reset link will expire in {{ count }} minutes.
13 |
14 | {% partial 'subcopy' body %}
15 | If you're having trouble clicking the button, copy the URL below into your browser.
16 |
17 | {{ url|raw }}
18 | {% endpartial %}
19 |
--------------------------------------------------------------------------------
/views/mail/verify_email.htm:
--------------------------------------------------------------------------------
1 | subject = "Confirm your email address"
2 | description = "Verification for a user email address"
3 | ==
4 | # Hello {{ first_name }}
5 |
6 | Please click the button below to verify your email address. If you did not create this account, no further action is required.
7 |
8 | {% partial 'button' url=url body %}
9 | Confirm Email Address
10 | {% endpartial %}
11 |
12 | {% partial 'subcopy' body %}
13 | If you're having trouble clicking the button, copy the URL below into your browser.
14 |
15 | {{ url|raw }}
16 | {% endpartial %}
17 |
--------------------------------------------------------------------------------
/views/mail/welcome_email.htm:
--------------------------------------------------------------------------------
1 | subject = "Your account has been confirmed!"
2 | ==
3 | Hello {{ name }},
4 |
5 | This is a message to inform you that your account has been activated successfully.
6 |
7 | ==
8 |
Hello {{ name }},
9 |
10 |
This is a message to inform you that your account has been activated successfully.
11 |