Saito\Posting\UserPosting\UserPostingTrait

Complexity

Total Complexity

24

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	isAnsweringForbidden()	0	8	2
A	isBookmarked()	0	3	1
A	isEditingAllowed()	0	3	1
A	setCurrentUser()	0	3	1
A	isEditingAsUserAllowed()	0	6	1
A	getCurrentUser()	0	3	1
A	isUnread()	0	10	2
B	_isEditingAllowed()	0	39	11
A	isIgnored()	0	3	1
A	hasNewAnswers()	0	13	3

<?php

declare(strict_types=1);

/**
 * Saito - The Threaded Web Forum
 *
 * @copyright Copyright (c) the Saito Project Developers
 * @link https://github.com/Schlaefer/Saito
 * @license http://opensource.org/licenses/MIT
 */

namespace Saito\Posting\UserPosting;

use Cake\Core\Configure;
use Saito\Posting\Basic\BasicPostingInterface;
use Saito\User\CurrentUser\CurrentUserInterface;
use Saito\User\Permission\ResourceAI;

/**
 * Implements UserPostingInterface
 */
trait UserPostingTrait
{
    /**
     * @var array
     */
    private $_userPostingTraitUnreadCache = [];

    /**
     * @var CurrentUserInterface
     */
    private $_CurrentUser;

    /**
     * {@inheritDoc}
     */
    public function getCurrentUser(): CurrentUserInterface
    {
        return $this->_CurrentUser;
    }

    /**
     * {@inheritDoc}
     */
    public function setCurrentUser(CurrentUserInterface $CurrentUser): void
    {
        $this->_CurrentUser = $CurrentUser;
    }

    /**
     * {@inheritDoc}
     */
    public function isAnsweringForbidden()
    {
        if ($this->isLocked()) {

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

            return 'locked';
        }
        $permission = $this->_CurrentUser->getCategories()->permission('answer', $this->get('category'));

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

        return !$permission;
    }

    /**
     * {@inheritDoc}
     */
    public function isBookmarked(): bool
    {
        return $this->_CurrentUser->hasBookmarked($this->get('id'));
    }

    /**
     * {@inheritDoc}
     */
    public function isEditingAllowed(): bool
    {
        return $this->_isEditingAllowed($this, $this->_CurrentUser);

$this of type Saito\Posting\UserPosting\UserPostingTrait is incompatible with the type Saito\Posting\Basic\BasicPostingInterface expected by parameter $posting of Saito\Posting\UserPosting\UserPostingTrait::_isEditingAllowed().

    }

    /**
     * {@inheritDoc}
     */
    public function isEditingAsUserAllowed(): bool
    {
        $MockedUser = clone $this->_CurrentUser;
        $MockedUser->set('user_type', 'user');

        return $this->_isEditingAllowed($this, $MockedUser);

$this of type Saito\Posting\UserPosting\UserPostingTrait is incompatible with the type Saito\Posting\Basic\BasicPostingInterface expected by parameter $posting of Saito\Posting\UserPosting\UserPostingTrait::_isEditingAllowed().

    }

    /**
     * Check if editing on the posting is forbidden.
     *
     * @param BasicPostingInterface $posting The posting.
     * @param CurrentUserInterface $User The user.
     * @return bool|string string if a reason is available.
     */
    protected function _isEditingAllowed(BasicPostingInterface $posting, CurrentUserInterface $User)
    {
        if ($User->isLoggedIn() !== true) {
            return false;
        }

        if ($User->permission('saito.core.posting.edit.unrestricted')) {
            return true;
        }

        /// Check category
        $action = $posting->isRoot() ? 'thread' : 'answer';
        $categoryAllowed = $User->getCategories()
            ->permission($action, $posting->get('category_id'));
        if (!$categoryAllowed) {
            return false;
        }

        $editPeriod = Configure::read('Saito.Settings.edit_period') * 60;
        $timeLimit = $editPeriod + ($posting->get('time')->format('U'));
        $isOverTime = time() > $timeLimit;

        $isOwn = $User->permission(
            'saito.core.posting.edit',
            (new ResourceAI())->onOwner($posting->get('user_id'))
        );

        if (!$isOverTime && $isOwn && !$this->isLocked()) {
            // Normal posting without special conditions.
            return true;
        }

        if ($User->permission('saito.core.posting.edit.restricted')) {
            if (!$isOwn || $posting->isPinned()) {
                return true;
            }
        }

        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function isIgnored(): bool
    {
        return $this->_CurrentUser->ignores($this->get('user_id'));

The expression return $this->_CurrentUser->ignores($this->get('user_id')) could return the type array which is incompatible with the type-hinted return boolean. Consider adding an additional type-check to rule them out.

    }

    /**
     * {@inheritDoc}
     */
    public function isUnread(): bool
    {
        if (!isset($this->_userPostingTraitUnreadCache['isUnread'])) {
            $id = $this->get('id');
            $time = $this->get('time');
            $this->_userPostingTraitUnreadCache['isUnread'] = !$this->getCurrentUser()
                ->getReadPostings()->isRead($id, $time);
        }

        return $this->_userPostingTraitUnreadCache['isUnread'];
    }

    /**
     * {@inheritDoc}
     */
    public function hasNewAnswers(): bool
    {
        if (!$this->isRoot()) {

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

            throw new \RuntimeException(
                'Posting with id ' . $this->get('id') . ' is no root posting.'
            );
        }
        if (!$this->_CurrentUser->get('last_refresh')) {
            return false;
        }

        return $this->_CurrentUser->get('last_refresh_unix') < strtotime(
            $this->get('last_answer')
        );
    }
}