Miliooo\Messaging\Model\Thread

Complexity

Total Complexity

30

Size/Duplication

Total Lines	284
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes	1
Bugs	0	Features	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getId()	0	4	1
A	setSubject()	0	4	1
A	getSubject()	0	4	1
A	setCreatedBy()	0	4	1
A	getCreatedBy()	0	4	1
A	setCreatedAt()	0	4	1
A	getCreatedAt()	0	4	1
A	addMessage()	0	5	1
A	getMessages()	0	4	1
A	getFirstMessage()	0	4	1
A	getLastMessage()	0	4	1
A	setLastMessage()	0	4	1
A	getThreadMeta()	0	4	1
A	addThreadMeta()	0	5	1
A	getThreadMetaForParticipant()	0	10	3
A	getParticipants()	0	4	1
A	isParticipant()	0	4	1
A	getParticipantsCollection()	0	20	4
A	getOtherParticipants()	0	11	2
A	addParticipantFromThreadMeta()	0	15	4

<?php

/*
 * This file is part of the MilioooMessageBundle package.
 *
 * (c) Michiel boeckaert <boeckaert@gmail.com>
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Miliooo\Messaging\Model;

use Miliooo\Messaging\User\ParticipantInterface;
use Doctrine\Common\Collections\ArrayCollection;

/**
 * The thread model
 *
 * @author Michiel Boeckaert <boeckaert@gmail.com>
 */
abstract class Thread implements ThreadInterface

Thread does not seem to conform to the naming convention (^Abstract|Factory$).

{
    /**
     * The unique id of the thread
     *
     * @var integer
     */
    protected $id;

    /**
     * The subject of the thread
     *
     * @var string
     */
    protected $subject;

    /**
     * The participant who created the thread
     *
     * @var ParticipantInterface
     */
    protected $createdBy;

    /**
     * The datetime when the thread was created
     *
     * @var \DateTime
     */
    protected $createdAt;

    /**
     * An array collection of messages for this thread
     *
     * @var ArrayCollection|MessageInterface[]
     */
    protected $messages;

    /**
     * An array collection of thread metas for this thread
     *
     * @var ArrayCollection|ThreadMeta[]
     */
    protected $threadMeta;

    /**
     * An array collection with participants
     *
     * @var ArrayCollection
     */
    protected $participants;

    /**
     * The last message posted in this thread.
     *
     * @var MessageInterface
     */
    protected $lastMessage;

    /**
     * Constructor.
     */
    public function __construct()
    {
        $this->messages = new ArrayCollection();
        $this->threadMeta = new ArrayCollection();
        $this->participants = new ArrayCollection();
    }

    /**
     * {@inheritdoc}
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * {@inheritdoc}
     */
    public function setSubject($subject)
    {
        $this->subject = $subject;
    }

    /**
     * {@inheritdoc}
     */
    public function getSubject()
    {
        return $this->subject;
    }

    /**
     * {@inheritdoc}
     */
    public function setCreatedBy(ParticipantInterface $participant)
    {
        $this->createdBy = $participant;
    }

    /**
     * {@inheritdoc}
     */
    public function getCreatedBy()
    {
        return $this->createdBy;
    }

    /**
     * {@inheritdoc}
     */
    public function setCreatedAt(\DateTime $createdAt)
    {
        $this->createdAt = $createdAt;
    }

    /**
     * {@inheritdoc}
     */
    public function getCreatedAt()
    {
        return $this->createdAt;
    }

    /**
     * {@inheritdoc}
     */
    public function addMessage(MessageInterface $message)
    {
        $message->setThread($this);
        $this->messages->add($message);
    }

    /**
     * {@inheritdoc}
     */
    public function getMessages()
    {
        return $this->messages;

The expression $this->messages; of type Doctrine\Common\Collections\ArrayCollection|Miliooo\Messaging\Model\MessageInterface[] adds the type Miliooo\Messaging\Model\MessageInterface[] to the return on line 159 which is incompatible with the return type declared by the interface Miliooo\Messaging\Model\ThreadInterface::getMessages of type Doctrine\Common\Collections\ArrayCollection.

    }

    /**
     * {@inheritdoc}
     */
    public function getFirstMessage()
    {
        return $this->messages->first();
    }

    /**
     * {@inheritdoc}
     */
    public function getLastMessage()
    {
        return $this->lastMessage;
    }

    /**
     * {@inheritdoc}
     */
    public function setLastMessage(MessageInterface $message)
    {
        $this->lastMessage = $message;
    }

    /**
     * {@inheritdoc}
     */
    public function getThreadMeta()
    {
        return $this->threadMeta;

The expression $this->threadMeta; of type Doctrine\Common\Collections\ArrayCollection|Miliooo\Messaging\Model\ThreadMeta[] adds the type Miliooo\Messaging\Model\ThreadMeta[] to the return on line 191 which is incompatible with the return type declared by the interface Miliooo\Messaging\Model\ThreadInterface::getThreadMeta of type Doctrine\Common\Collections\ArrayCollection.

    }

    /**
     * {@inheritdoc}
     */
    public function addThreadMeta(ThreadMetaInterface $threadMeta)
    {
        $threadMeta->setThread($this);
        $this->threadMeta->add($threadMeta);
    }

    /**
     * {@inheritdoc}
     */
    public function getThreadMetaForParticipant(ParticipantInterface $participant)
    {
        foreach ($this->threadMeta as $meta) {
            if ($meta->getParticipant()->getParticipantId() == $participant->getParticipantId()) {
                return $meta;
            }
        }

        return null;
    }

    /**
     * {@inheritdoc}
     */
    public function getParticipants()
    {
        return $this->getParticipantsCollection()->toArray();
    }

     /**
     * {@inheritdoc}
     */
    public function isParticipant(ParticipantInterface $participant)
    {
        return $this->getParticipantsCollection()->contains($participant);
    }

    /**
     * Returns an array collection of participants for the given thread.
     *
     * We do not map the participantscollection because the thread meta allready
     * gives us all the information needed. It contains the thread AND the participant
     *
     * So in order to get the participants we need to loop over the threadmeta
     * Get the participant and add it to the collection.
     *
     * if we want to add a participant to the thread collection we need to create that threadmeta.
     *
     * @return ArrayCollection
     */
    protected function getParticipantsCollection()
    {
        //doctrine skips constructor and does not make an array collection
        //since there is no mapping taking place
        if ($this->participants == null) {
            $this->participants = new ArrayCollection();
        }

        // no point in looping over the threadmeta since there is none
        if ($this->threadMeta->count() === 0) {
            return $this->participants;
        }

        //there is thread meta in the collection so let's loop over it
        foreach ($this->threadMeta as $threadMeta) {
            $this->addParticipantFromThreadMeta($threadMeta);
        }

        return $this->participants;
    }

    /**
     * {@inheritdoc}
     */
    public function getOtherParticipants(ParticipantInterface $participant)
    {
        $otherParticipants = $this->getParticipants();
        $key = array_search($participant, $otherParticipants, true);

        if (false !== $key) {
            unset($otherParticipants[$key]);
        }

        return array_values($otherParticipants);
    }

    /**
     * Adds a participant form the thread meta
     *
     * @param ThreadMetaInterface $threadMeta The threadmeta we extract the participant from
     *
     * @throws \InvalidArgumentException if participant is not instance of participantinterface
     */
    protected function addParticipantFromThreadMeta(ThreadMetaInterface $threadMeta)
    {
        $participant = $threadMeta->getParticipant();

        //this should not happen unless you did not delete the messages from deleted users
        //If there is no longer a link between those there could be other problems though...
        // Let's throw an exception here for the moment...
        if (!is_object($participant) || !$participant instanceof ParticipantInterface) {
            throw new \InvalidArgumentException('ThreadMeta contains participant with no participantinterface');
        }

        if (!$this->participants->contains($participant)) {
            $this->participants->add($participant);
        }
    }
}