rhosocial\base\models\traits\ConfirmationTrait

Complexity

Total Complexity

48

Size/Duplication

Total Lines	261
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

87.23%

Importance

Changes	1
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	applyConfirmation()	0	8	3
B	setConfirmCode()	0	17	5
A	getConfirmCode()	0	5	3
A	confirm()	0	8	3
A	generateConfirmationCode()	0	4	1
A	validateConfirmationCode()	0	8	3
A	getIsConfirmed()	0	5	3
A	onInitConfirmation()	0	10	3
B	onConfirmationChanged()	0	17	5
A	getConfirmationRules()	0	10	2
A	resetOthersConfirmation()	0	14	4
A	setConfirmation()	0	9	3
B	resetConfirmation()	0	17	7
A	getConfirmation()	0	5	3

<?php

/**
 *  _   __ __ _____ _____ ___  ____  _____
 * | | / // // ___//_  _//   ||  __||_   _|
 * | |/ // /(__  )  / / / /| || |     | |
 * |___//_//____/  /_/ /_/ |_||_|     |_|
 * @link https://vistart.me/
 * @copyright Copyright (c) 2016 - 2017 vistart
 * @license https://vistart.me/license/
 */

namespace rhosocial\base\models\traits;

use Yii;
use yii\base\ModelEvent;

/**
 * This trait allow its owner to enable the entity to be blamed by user.
 * @property-read boolean $isConfirmed
 * @property integer $confirmation
 * @property-read array $confirmationRules
 * @property string $confirmCode the confirm code used for confirming the content.
 * You can disable this attribute and create a new model for storing confirm code as
 * its low-frequency usage.
 * @version 1.0
 * @author vistart <i@vistart.me>
 */
trait ConfirmationTrait
{

    /**
     * @var int Unconfirmed.
     */
    public static $confirmFalse = 0;

    /**
     * @var int Confirmed.
     */
    public static $confirmTrue = 1;

    /**
     * @var string|false attribute name of confirmation, or false if disable confirmation features.
     */
    public $confirmationAttribute = false;

    /**
     * @var string This attribute specify the name of confirm_code attribute, if
     * this attribute is assigned to false, this feature will be ignored.
     * if $confirmationAttribute is empty or false, this attribute will be skipped.
     */
    public $confirmCodeAttribute = 'confirm_code';

    /**
     * @var integer The expiration in seconds. If $confirmCodeAttribute is
     * specified, this attribute must be specified.
     */
    public $confirmCodeExpiration = 3600;

    /**
     * @var string This attribute specify the name of confirm_time attribute. if
     * this attribute is assigned to false, this feature will be ignored.
     * if $confirmationAttribute is empty or false, this attribute will be skipped.
     */
    public $confirmTimeAttribute = 'confirmed_at';

    /**
     * @var string initialization confirm time.
     */
    public $initConfirmTime = '1970-01-01 00:00:00';
    public static $eventConfirmationChanged = "confirmationChanged";
    public static $eventConfirmationCanceled = "confirmationCanceled";
    public static $eventConfirmationSuceeded = "confirmationSucceeded";

    /**
     * Apply confirmation.
     * @return boolean
     * @throws \yii\base\NotSupportedException
     */
    public function applyConfirmation()
    {
        if (!$this->confirmCodeAttribute || empty($this->confirmCodeAttribute)) {
            throw new \yii\base\NotSupportedException('This method is not implemented.');
        }
        $this->setConfirmCode($this->generateConfirmationCode());
        return $this->save();

It seems like save() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Set confirm code.
     * @param string $code
     */
    public function setConfirmCode($code)
    {
        if (!$this->confirmCodeAttribute || empty($this->confirmCodeAttribute)) {
            return;
        }
        $confirmCodeAttribute = $this->confirmCodeAttribute;
        $this->$confirmCodeAttribute = $code;
        if (!$this->confirmTimeAttribute) {
            return;
        }
        $confirmTimeAttribute = $this->confirmTimeAttribute;
        if (!empty($code)) {
            $this->$confirmTimeAttribute = date('Y-m-d H:i:s');
            return;
        }
        $this->$confirmTimeAttribute = $this->initConfirmTime;
    }

    /**
     * Get confirm code.
     * @return string
     */
    public function getConfirmCode()
    {
        $confirmCodeAttribute = $this->confirmCodeAttribute;
        return (is_string($confirmCodeAttribute) && !empty($confirmCodeAttribute)) ? $this->$confirmCodeAttribute : null;
    }

    /**
     * Confirm the current content.
     * @param string $code
     * @return boolean
     */
    public function confirm($code = '')
    {
        if (!$this->confirmationAttribute || !$this->validateConfirmationCode($code)) {
            return false;
        }
        $this->confirmation = static::$confirmTrue;
        return $this->save();

It seems like save() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Generate confirmation code.
     * @return string code
     */
    public function generateConfirmationCode()
    {
        return substr(sha1(Yii::$app->security->generateRandomString()), 0, 17);
    }

    /**
     * Validate the confirmation code.
     * @param string $code
     * @return boolean Whether the confirmation code is valid.
     */
    public function validateConfirmationCode($code)
    {
        $ccAttribute = $this->confirmCodeAttribute;
        if (!$ccAttribute || empty($ccAttribute)) {
            return true;
        }
        return $this->$ccAttribute === $code;
    }

    /**
     * Get confirmation status of current model.
     * @return boolean Whether current model has been confirmed.
     */
    public function getIsConfirmed()
    {
        $cAttribute = $this->confirmationAttribute;
        return (is_string($cAttribute) && !empty($cAttribute)) ? $this->$cAttribute > static::$confirmFalse : true;
    }

    /**
     * Initialize the confirmation status.
     * This method is ONLY used for being triggered by event. DO NOT call,
     * override or modify it directly, unless you know the consequences.
     * @param ModelEvent $event
     */
    public function onInitConfirmation($event)
    {
        $sender = $event->sender;
        /* @var $sender static */
        if (!$sender->confirmationAttribute || empty($sender->confirmationAttribute)) {
            return;
        }
        $sender->confirmation = static::$confirmFalse;
        $sender->confirmCode = '';
    }

    /**
     * Set confirmation.
     * @param mixed $value
     */
    public function setConfirmation($value)
    {
        $cAttribute = $this->confirmationAttribute;
        if (!$cAttribute || empty($cAttribute)) {
            return;
        }
        $this->$cAttribute = $value;
        $this->trigger(static::$eventConfirmationChanged);

It seems like trigger() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Get confirmation.
     * @return mixed
     */
    public function getConfirmation()
    {
        $cAttribute = $this->confirmationAttribute;
        return (is_string($cAttribute) && !empty($cAttribute)) ? $this->$cAttribute : null;
    }

    /**
     * When confirmation status changed, this event will be triggered. If
     * confirmation succeeded, the confirm_time will be assigned to current time,
     * or the confirm_time will be assigned to initConfirmTime.
     * This method is ONLY used for being triggered by event. DO NOT call,
     * override or modify it directly, unless you know the consequences.
     * @param ModelEvent $event
     */
    public function onConfirmationChanged($event)
    {
        $sender = $event->sender;
        $cAttribute = $sender->confirmationAttribute;
        if (!$cAttribute || empty($cAttribute)) {
            return;
        }
        if ($sender->isAttributeChanged($cAttribute)) {
            $sender->confirmCode = '';
            if ($sender->$cAttribute == static::$confirmFalse) {
                $sender->trigger(static::$eventConfirmationCanceled);
                return;
            }
            $sender->trigger(static::$eventConfirmationSuceeded);
            $sender->resetOthersConfirmation();
        }
    }

    /**
     * Get rules associated with confirmation attributes.
     * if not enable confirmation feature, it will return empty array.
     * @return array
     */
    public function getConfirmationRules()
    {
        if (!$this->confirmationAttribute) {
            return [];
        }
        return [
            [[$this->confirmationAttribute], 'number', 'integerOnly' => true, 'min' => 0],
            [[$this->confirmTimeAttribute], 'safe'],
        ];
    }

    /**
     * When the content changed, reset confirmation status.
     */
    protected function resetConfirmation()
    {
        $contentAttribute = $this->contentAttribute;

The property contentAttribute does not exist. Did you maybe forget to declare it?

        if (!$contentAttribute || empty($contentAttribute)) {
            return;
        }
        if (is_array($contentAttribute)) {
            foreach ($contentAttribute as $attribute) {
                if ($this->isAttributeChanged($attribute)) {

It seems like isAttributeChanged() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                    $this->confirmation = static::$confirmFalse;
                    break;
                }
            }
        } elseif ($this->isAttributeChanged($contentAttribute)) {

It seems like isAttributeChanged() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $this->confirmation = static::$confirmFalse;
        }
    }

    /**
     * Reset others' confirmation when the others own the same content.
     */
    protected function resetOthersConfirmation()
    {
        if (!$this->confirmationAttribute || empty($this->hostClass)) {

The property hostClass does not exist. Did you maybe forget to declare it?

            return;
        }
        $contents = static::find()
            ->where([$this->contentAttribute => $this->getContent()])

It seems like getContent() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ->andWhere(['not like', $this->createdByAttribute, $this->user->getGUID()])

The property createdByAttribute does not exist. Did you maybe forget to declare it?

The property user does not exist. Did you maybe forget to declare it?

            ->all();
        foreach ($contents as $content) {
            $content->confirmation = static::$confirmFalse;
            $content->save();
        }
    }
}