vistart\Models\traits\MessageTrait

Complexity

Total Complexity

26

Size/Duplication

Total Lines	132
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

69.01%

Importance

Changes	2
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	hasBeenReceived()	0	4	2
A	hasBeenRead()	0	4	2
A	touchReceived()	0	4	1
A	touchRead()	0	4	1
A	getReceivedAt()	0	8	2
A	getReadAt()	0	8	2
A	setReceivedAt()	0	8	2
A	setReadAt()	0	8	2
A	onInitReceivedAtAttribute()	0	6	1
A	onInitReadAtAttribute()	0	6	1
A	initMessageEvents()	0	5	1
A	getMessageRules()	0	17	4
A	rules()	0	4	1
A	enabledFields()	0	15	4

<?php

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

namespace vistart\Models\traits;

/**
 * This trait should be used in models extended from models used BlameableTrait.
 * Notice: The models used BlameableTrait are also models used EntityTrait.
 *
 * @author vistart <i@vistart.name>
 */
trait MessageTrait
{

    public $recipientGuidAttribute = 'other_guid';
    public $attachmentAttribute = 'attachment';
    public $expiration = 604800; // 7 days
    public $receivedAtAttribute = 'received_at';
    public $readAtAttribute = 'read_at';
    public static $eventMessageReceived = 'messageReceived';
    public static $eventMessageRead = 'messageRead';

    public function hasBeenReceived()
    {
        return is_string($this->receivedAtAttribute) ? $this->isInitDatetime($this->receivedAtAttribute) : false;

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

    }

    public function hasBeenRead()
    {
        return is_string($this->readAtAttribute) ? $this->isInitDatetim($this->readAtAttribute) : false;

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

    }

    public function touchReceived($event)
    {
        $this->setReceivedAt(static::getCurrentDatetime($event));
    }

    public function touchRead($event)
    {
        $this->setReadAt(static::getCurrentDatetime($event));
    }

    public function getReceivedAt()
    {
        if (is_string($this->receivedAtAttribute)) {
            $raAttribute = $this->receivedAtAttribute;
            return $this->$raAttribute;
        }
        return null;
    }

    public function setReceivedAt($receivedAt)
    {
        if (is_string($this->receivedAtAttribute)) {
            $raAttribute = $this->receivedAtAttribute;
            return $this->$raAttribute = $receivedAt;
        }
        return null;
    }

    public function getReadAt()
    {
        if (is_string($this->readAtAttribute)) {
            $raAttribute = $this->readAtAttribute;
            return $this->$raAttribute;
        }
        return null;
    }

    public function setReadAt($readAt)
    {
        if (is_string($this->readAtAttribute)) {
            $raAttribute = $this->readAtAttribute;
            return $this->$raAttribute = $readAt;
        }
        return null;
    }

    /**
     * @param \yii\base\ModelEvent $event
     */
    public function onInitReceivedAtAttribute($event)
    {
        $sender = $event->sender;
        /* @var $sender static */
        $sender->setReceivedAt(static::getInitDatetime($event));
    }

    /**
     * @param \yii\base\ModelEvent $event
     */
    public function onInitReadAtAttribute($event)
    {
        $sender = $event->sender;
        /* @var $sender static */
        $sender->setReadAt(static::getInitDatetime($event));
    }
    
    public function initMessageEvents()
    {
        $this->on(static::EVENT_BEFORE_INSERT, [$this, 'onInitReceivedAtAttribute']);

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

        $this->on(static::EVENT_BEFORE_INSERT, [$this, 'onInitReadAtAttribute']);

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

    }

    public function getMessageRules()
    {
        $rules = [
            [$this->recipientGuidAttribute, 'required'],
            [$this->recipientGuidAttribute, 'string', 'max' => 36],
        ];
        if (is_string($this->attachmentAttribute)) {
            $rules[] = [$this->attachmentAttribute, 'safe'];
        }
        if (is_string($this->receivedAtAttribute)) {
            $rules[] = [$this->receivedAtAttribute, 'safe'];
        }
        if (is_string($this->readAtAttribute)) {
            $rules[] = [$this->readAtAttribute, 'safe'];
        }
        return $rules;
    }

    public function rules()
    {
        return array_merge(parent::rules(), $this->getMessageRules());
    }

    public function enabledFields()
    {
        $fields = parent::enabledFields();
        $fields[] = $this->recipientGuidAttribute;
        if (is_string($this->attachmentAttribute)) {
            $fields[] = $this->attachmentAttribute;
        }
        if (is_string($this->receivedAtAttribute)) {
            $fields[] = $this->receivedAtAttribute;
        }
        if (is_string($this->readAtAttribute)) {
            $fields[] = $this->readAtAttribute;
        }
        return $fields;
    }
}