ValidationStatusExtension::doValidationApprove() - Code Metrics - lekoala/silverstripe-common-extensions - Measure and Improve Code Quality continuously with Scrutinizer

ValidationStatusExtension::doValidationApprove() A
last analyzed 2024-02-02 15:18 UTC

↳ Parent: ValidationStatusExtension

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
eloc	4
c	2
b	0
f	1
dl	0
loc	8
rs	10
cc	1
nc	1
nop	0

<?php

namespace LeKoala\CommonExtensions;

use SilverStripe\ORM\DataObject;
use SilverStripe\Forms\FieldList;
use SilverStripe\Security\Member;
use SilverStripe\ORM\DataExtension;
use LeKoala\CmsActions\CustomAction;
use SilverStripe\Security\Permission;
use SilverStripe\ORM\ValidationResult;
use SilverStripe\Security\LoginAttempt;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\ORM\FieldType\DBDatetime;

/**
 * Allow to enable/disable login for your objects based on status
 *
 * @property DataObject|Member $owner
 * @property string $ValidationStatus
 */
class ValidationStatusExtension extends DataExtension
{
    use Configurable;

    const VALIDATION_STATUS_PENDING = 'pending';
    const VALIDATION_STATUS_APPROVED = 'approved';
    const VALIDATION_STATUS_DISABLED = 'disabled';

    /**
     * A time string in the future (eg: +7 days) based on LastVisited column
     * This require a LastVisited field on your Member class to be really accurate
     * @config
     * @var string
     */
    private static $account_expiration = null;


    /**
     * @config
     * @var boolean
     */
    private static $status_prevent_login = true;

    private static $db = [

        "ValidationStatus" => "NiceEnum('pending,approved,disabled')"
    ];

    /**
     * @return array
     */
    public static function listStatus()
    {
        return [
            self::VALIDATION_STATUS_PENDING => _t('ValidationStatusExtension.VALIDATION_STATUS_PENDING', 'pending'),
            self::VALIDATION_STATUS_APPROVED => _t('ValidationStatusExtension.VALIDATION_STATUS_APPROVED', 'approved'),
            self::VALIDATION_STATUS_DISABLED => _t('ValidationStatusExtension.VALIDATION_STATUS_DISABLED', 'disabled'),
        ];
    }


    /**
     * @param Member $member
     * @return boolean
     */
    public function canView($member = null)
    {
        // Can always see approved
        if ($this->IsValidationStatusApproved()) {
            return true;
        }
        return Permission::check('ADMIN', 'any', $member);
    }

    /**
     * This is called by Member::validateCanLogin which is typically called in MemberAuthenticator::authenticate::authenticateMember
     * which is used in LoginHandler::doLogin::checkLogin
     *
     * This means canLogIn is called before 2FA, for instance
     *
     * @param ValidationResult $result
     * @return void
     */
    public function canLogIn(ValidationResult $result)
    {
        if (Permission::check('ADMIN', 'any', $this->owner)) {
            return;
        }

        if ($this->IsAccountExpired()) {
            // This allows you to send an activation email if necessary
            $this->owner->extend('onExpiredLoginAttempt');

            $result->addError(_t('ValidationStatusExtension.ACCOUNT_EXPIRED', "Your account has expired"));
        }

        // Check general status
        if (self::config()->get('status_prevent_login')) {
            if ($this->owner->IsValidationStatusPending()) {
                $result->addError(_t('ValidationStatusExtension.ACCOUNT_PENDING', "Your account is currently pending"));
            }
            if ($this->owner->IsValidationStatusDisabled()) {
                $result->addError(_t('ValidationStatusExtension.ACCOUNT_DISABLED', "Your account has been disabled"));
            }
        }
    }

    public function IsAccountExpired()
    {
        $account_expiration = self::config()->get("account_expiration");
        if (!$account_expiration) {
            return false;
        }
        $lastVisited = null;
        if ($this->owner->hasField('LastVisited')) {
            $lastVisited = $this->owner->LastVisited;
        } else {
            // Use last valid attempt as fallback
            $lastValidAttempt = LoginAttempt::getByEmail($this->Email)

                ->filter('Status', 'Success')
                ->sort('Created', 'DESC')
                ->first();
            if ($lastValidAttempt) {
                $lastVisited = $lastValidAttempt->Created;
            }
        }
        // It needs at least one visit to be able to expire
        if ($lastVisited) {
            $checkTime = strtotime($account_expiration, strtotime($lastVisited));
            // It has expired
            if ($checkTime < DBDatetime::now()->getTimestamp()) {
                return true;
            }
        }
        return false;
    }

    public function updateCMSFields(FieldList $fields)
    {
        $fields->makeFieldReadonly('ValidationStatus');
    }

    public function updateCMSActions(FieldList $actions)
    {
        if ($this->IsValidationStatusPending()) {
            $actions->push(new CustomAction('doValidationApprove', _t('ValidationStatusExtension.APPROVE', 'Approve')));
            $actions->push(new CustomAction('doValidationDisable', _t('ValidationStatusExtension.DISABLE', 'Disable')));
        }
        if ($this->IsValidationStatusApproved()) {
            $actions->push(new CustomAction('doValidationDisable', _t('ValidationStatusExtension.DISABLE', 'Disable')));
        }
        if ($this->IsValidationStatusDisabled()) {
            $actions->push(new CustomAction('doValidationApprove', _t('ValidationStatusExtension.APPROVE', 'Approve')));
        }
    }

    public function doValidationApprove()
    {
        $this->owner->ValidationStatus = self::VALIDATION_STATUS_APPROVED;
        $this->owner->write();

        $this->owner->extend('onValidationApprove');

        return _t('ValidationStatusExtension.APPROVED', 'Approved');
    }

    public function doValidationDisable()
    {
        $this->owner->ValidationStatus = self::VALIDATION_STATUS_DISABLED;
        $this->owner->write();

        $this->owner->extend('onValidationDisable');

        return _t('ValidationStatusExtension.DISABLED', 'Disabled');
    }

    public function IsValidationStatusPending()
    {
        return $this->owner->ValidationStatus == self::VALIDATION_STATUS_PENDING;
    }

    public function IsValidationStatusApproved()
    {
        return $this->owner->ValidationStatus == self::VALIDATION_STATUS_APPROVED;
    }

    public function IsValidationStatusDisabled()
    {
        return $this->owner->ValidationStatus == self::VALIDATION_STATUS_DISABLED;
    }

    public function IsNotValidationStatusPending()
    {
        return $this->owner->ValidationStatus != self::VALIDATION_STATUS_PENDING;
    }

    public function IsNotValidationStatusApproved()
    {
        return $this->owner->ValidationStatus != self::VALIDATION_STATUS_APPROVED;
    }

    public function IsNotValidationStatusDisabled()
    {
        return $this->owner->ValidationStatus != self::VALIDATION_STATUS_DISABLED;
    }
}


1			<?php
2
3			namespace LeKoala\CommonExtensions;
4
5			use SilverStripe\ORM\DataObject;
6			use SilverStripe\Forms\FieldList;
7			use SilverStripe\Security\Member;
8			use SilverStripe\ORM\DataExtension;
9			use LeKoala\CmsActions\CustomAction;
10			use SilverStripe\Security\Permission;
11			use SilverStripe\ORM\ValidationResult;
12			use SilverStripe\Security\LoginAttempt;
13			use SilverStripe\Core\Config\Configurable;
14			use SilverStripe\ORM\FieldType\DBDatetime;
15
16			/**
17			* Allow to enable/disable login for your objects based on status
18			*
19			* @property DataObject\|Member $owner
20			* @property string $ValidationStatus
21			*/
22			class ValidationStatusExtension extends DataExtension
23			{
24			use Configurable;
25
26			const VALIDATION_STATUS_PENDING = 'pending';
27			const VALIDATION_STATUS_APPROVED = 'approved';
28			const VALIDATION_STATUS_DISABLED = 'disabled';
29
30			/**
31			* A time string in the future (eg: +7 days) based on LastVisited column
32			* This require a LastVisited field on your Member class to be really accurate
33			* @config
34			* @var string
35			*/
36			private static $account_expiration = null;
			0 ignored issues – show introduced 2022-01-27 10:38 UTC by Report Bug Copy Issue Report The private property `$account_expiration` is not used, and could be removed. Loading history...
37
38			/**
39			* @config
40			* @var boolean
41			*/
42			private static $status_prevent_login = true;
			0 ignored issues – show introduced 2022-01-27 10:38 UTC by Report Bug Copy Issue Report The private property `$status_prevent_login` is not used, and could be removed. Loading history...
43			private static $db = [
			0 ignored issues – show introduced 2021-02-16 11:04 UTC by Report Bug Copy Issue Report The private property `$db` is not used, and could be removed. Loading history...
44			"ValidationStatus" => "NiceEnum('pending,approved,disabled')"
45			];
46
47			/**
48			* @return array
49			*/
50			public static function listStatus()
51			{
52			return [
53			self::VALIDATION_STATUS_PENDING => _t('ValidationStatusExtension.VALIDATION_STATUS_PENDING', 'pending'),
54			self::VALIDATION_STATUS_APPROVED => _t('ValidationStatusExtension.VALIDATION_STATUS_APPROVED', 'approved'),
55			self::VALIDATION_STATUS_DISABLED => _t('ValidationStatusExtension.VALIDATION_STATUS_DISABLED', 'disabled'),
56			];
57			}
58
59
60			/**
61			* @param Member $member
62			* @return boolean
63			*/
64			public function canView($member = null)
65			{
66			// Can always see approved
67			if ($this->IsValidationStatusApproved()) {
68			return true;
69			}
70			return Permission::check('ADMIN', 'any', $member);
71			}
72
73			/**
74			* This is called by Member::validateCanLogin which is typically called in MemberAuthenticator::authenticate::authenticateMember
75			* which is used in LoginHandler::doLogin::checkLogin
76			*
77			* This means canLogIn is called before 2FA, for instance
78			*
79			* @param ValidationResult $result
80			* @return void
81			*/
82			public function canLogIn(ValidationResult $result)
83			{
84			if (Permission::check('ADMIN', 'any', $this->owner)) {
85			return;
86			}
87
88			if ($this->IsAccountExpired()) {
89			// This allows you to send an activation email if necessary
90			$this->owner->extend('onExpiredLoginAttempt');
91
92			$result->addError(_t('ValidationStatusExtension.ACCOUNT_EXPIRED', "Your account has expired"));
93			}
94
95			// Check general status
96			if (self::config()->get('status_prevent_login')) {
97			if ($this->owner->IsValidationStatusPending()) {
98			$result->addError(_t('ValidationStatusExtension.ACCOUNT_PENDING', "Your account is currently pending"));
99			}
100			if ($this->owner->IsValidationStatusDisabled()) {
101			$result->addError(_t('ValidationStatusExtension.ACCOUNT_DISABLED', "Your account has been disabled"));
102			}
103			}
104			}
105
106			public function IsAccountExpired()
107			{
108			$account_expiration = self::config()->get("account_expiration");
109			if (!$account_expiration) {
110			return false;
111			}
112			$lastVisited = null;
113			if ($this->owner->hasField('LastVisited')) {
114			$lastVisited = $this->owner->LastVisited;
115			} else {
116			// Use last valid attempt as fallback
117			$lastValidAttempt = LoginAttempt::getByEmail($this->Email)
			0 ignored issues – show Bug Best Practice introduced 2022-01-27 10:38 UTC by Report Bug Copy Issue Report The property `Email` does not exist on `LeKoala\CommonExtensions\ValidationStatusExtension`. Did you maybe forget to declare it? Loading history...
118			->filter('Status', 'Success')
119			->sort('Created', 'DESC')
120			->first();
121			if ($lastValidAttempt) {
122			$lastVisited = $lastValidAttempt->Created;
123			}
124			}
125			// It needs at least one visit to be able to expire
126			if ($lastVisited) {
127			$checkTime = strtotime($account_expiration, strtotime($lastVisited));
128			// It has expired
129			if ($checkTime < DBDatetime::now()->getTimestamp()) {
130			return true;
131			}
132			}
133			return false;
134			}
135
136			public function updateCMSFields(FieldList $fields)
137			{
138			$fields->makeFieldReadonly('ValidationStatus');
139			}
140
141			public function updateCMSActions(FieldList $actions)
142			{
143			if ($this->IsValidationStatusPending()) {
144			$actions->push(new CustomAction('doValidationApprove', _t('ValidationStatusExtension.APPROVE', 'Approve')));
145			$actions->push(new CustomAction('doValidationDisable', _t('ValidationStatusExtension.DISABLE', 'Disable')));
146			}
147			if ($this->IsValidationStatusApproved()) {
148			$actions->push(new CustomAction('doValidationDisable', _t('ValidationStatusExtension.DISABLE', 'Disable')));
149			}
150			if ($this->IsValidationStatusDisabled()) {
151			$actions->push(new CustomAction('doValidationApprove', _t('ValidationStatusExtension.APPROVE', 'Approve')));
152			}
153			}
154
155			public function doValidationApprove()
156			{
157			$this->owner->ValidationStatus = self::VALIDATION_STATUS_APPROVED;
158			$this->owner->write();
159
160			$this->owner->extend('onValidationApprove');
161
162			return _t('ValidationStatusExtension.APPROVED', 'Approved');
163			}
164
165			public function doValidationDisable()
166			{
167			$this->owner->ValidationStatus = self::VALIDATION_STATUS_DISABLED;
168			$this->owner->write();
169
170			$this->owner->extend('onValidationDisable');
171
172			return _t('ValidationStatusExtension.DISABLED', 'Disabled');
173			}
174
175			public function IsValidationStatusPending()
176			{
177			return $this->owner->ValidationStatus == self::VALIDATION_STATUS_PENDING;
178			}
179
180			public function IsValidationStatusApproved()
181			{
182			return $this->owner->ValidationStatus == self::VALIDATION_STATUS_APPROVED;
183			}
184
185			public function IsValidationStatusDisabled()
186			{
187			return $this->owner->ValidationStatus == self::VALIDATION_STATUS_DISABLED;
188			}
189
190			public function IsNotValidationStatusPending()
191			{
192			return $this->owner->ValidationStatus != self::VALIDATION_STATUS_PENDING;
193			}
194
195			public function IsNotValidationStatusApproved()
196			{
197			return $this->owner->ValidationStatus != self::VALIDATION_STATUS_APPROVED;
198			}
199
200			public function IsNotValidationStatusDisabled()
201			{
202			return $this->owner->ValidationStatus != self::VALIDATION_STATUS_DISABLED;
203			}
204			}
205

lekoala / silverstripe-common-extensions

ValidationStatusExtension::doValidationApprove() A last analyzed 2024-02-02 15:18 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ValidationStatusExtension::doValidationApprove() A
last analyzed 2024-02-02 15:18 UTC