Tinyissue\Model\Traits\Project\QueryTrait

Complexity

Total Complexity

15

Size/Duplication

Total Lines	187
Duplicated Lines	3.21 %

Coupling/Cohesion

Components	3
Dependencies	4

Test Coverage

Coverage

61.11%

Importance

Changes	12
Bugs	1	Features	1

9 Methods

Rating	Name	Duplication	Size	Complexity
A	activeProjects()	0	6	1
A	usersNotIn()	0	11	2
B	listIssues()	0	30	3
A	listAssignedOrCreatedIssues()	0	11	2
A	getKanbanTagsForUser()	0	11	1
A	issuesGroupByTags()	0	15	1
A	usersCanFixIssue()	0	4	1
A	publicProjects()	0	6	1
B	projectsWidthIssues()	6	25	3

<?php

/*
 * This file is part of the Tinyissue package.
 *
 * (c) Mohamed Alsharaf <mohamed.alsharaf@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Tinyissue\Model\Traits\Project;

use Illuminate\Database\Eloquent;
use Illuminate\Database\Eloquent\Relations;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Database\Query;
use Tinyissue\Model\Project;
use Tinyissue\Model\Role;
use Tinyissue\Model\User;

/**
 * QueryTrait is trait class containing the database queries methods for the Project model.
 *
 * @author Mohamed Alsharaf <mohamed.alsharaf@gmail.com>
 *
 * @property int $id
 *
 * @method   Eloquent\Model      where($column, $operator = null, $value = null, $boolean = 'and')
 * @method   Query\Builder       join($table, $one, $operator = null, $two = null, $type = 'inner', $where = false)
 * @method   Relations\HasMany   users()
 * @method   Relations\HasMany   issues()
 * @method   void                filterAssignTo(Relations\HasMany $query, $userId)
 * @method   void                filterTitleOrBody(Relations\HasMany $query, $keyword)
 * @method   void                filterTags(Relations\HasMany $query, array $tags)
 * @method   void                sortByUpdated(Relations\HasMany $query, $order = 'asc')
 * @method   Eloquent\Collection sortByTag(Relations\HasMany $query, $tagGroup, $order = 'asc')
 */
trait QueryTrait
{
    /**
     * Returns collection of active projects.
     *
     * @return Eloquent\Collection
     */
    public static function activeProjects()
    {
        return static::where('status', '=', Project::STATUS_OPEN)
            ->orderBy('name', 'ASC')
            ->get();
    }

    /**
     * Returns collection of public projects.
     *
     * @return Eloquent\Collection
     */
    public function publicProjects()
    {
        return $this->where('private', '=', Project::PRIVATE_NO)
            ->orderBy('name', 'ASC')
            ->get();
    }

    /**
     * Returns all users that are not assigned in the current project.
     *
     * @return array
     */
    public function usersNotIn()
    {
        if ($this->id > 0) {
            $userIds = $this->users()->lists('user_id')->all();
            $users   = User::where('deleted', '=', User::NOT_DELETED_USERS)->whereNotIn('id', $userIds)->get();
        } else {
            $users = User::where('deleted', '=', User::NOT_DELETED_USERS)->get();
        }

        return $users->lists('fullname', 'id')->all();
    }

    /**
     * Fetch and filter issues in the project.
     *
     * @param int   $status
     * @param array $filter
     *
     * @return \Illuminate\Database\Eloquent\Collection
     */
    public function listIssues($status = Project\Issue::STATUS_OPEN, array $filter = [])
    {
        $sortOrder = array_get($filter, 'sort.sortorder', 'desc');
        $sortBy    = array_get($filter, 'sort.sortby', null);

        $query = $this->issues()
            ->with('countComments', 'user', 'updatedBy', 'tags', 'tags.parent')
            ->with([
                'tags' => function (Relation $query) use ($sortOrder) {
                    $query->orderBy('name', $sortOrder);
                },
            ])
            ->where('status', '=', $status);

        // Filter issues
        $this->filterAssignTo($query, array_get($filter, 'assignto'));
        $this->filterTitleOrBody($query, array_get($filter, 'keyword'));
        $this->filterTags($query, array_get($filter, 'tag_status'));
        $this->filterTags($query, array_get($filter, 'tag_type'));
        $this->filterCreatedBy($query, array_get($filter, 'created_by'), $this->isPrivateInternal());

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

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

        // Sort
        if ($sortBy == 'updated') {
            $this->sortByUpdated($query, $sortOrder);
        } elseif (($tagGroup = substr($sortBy, strlen('tag:'))) > 0) {
            return $this->sortByTag($query, $tagGroup, $sortOrder);
        }

        return $query->get();
    }

    /**
     * Fetch issues assigned to a user.
     *
     * @param User $user
     *
     * @return \Illuminate\Database\Eloquent\Collection
     */
    public function listAssignedOrCreatedIssues(User $user)
    {
        $assignedOrCreate = $user->isUser() ? 'created_by' : 'assigned_to';

        return $this->issues()
            ->with('countComments', 'user', 'updatedBy')
            ->where('status', '=', Project\Issue::STATUS_OPEN)
            ->where($assignedOrCreate, '=', $user->id)
            ->orderBy('updated_at', 'DESC')
            ->get();
    }

    /**
     * Returns projects with issues details eager loaded.
     *
     * @param int $status
     * @param int $private
     *
     * @return Relations\HasMany
     */
    public function projectsWidthIssues($status = Project::STATUS_OPEN, $private = Project::PRIVATE_NO)
    {
        $query = $this
            ->where('status', '=', $status)
            ->orderBy('name');

        if ($private !== Project::PRIVATE_ALL) {
            $query->where('private', '=', $private);
        }

        $query->with([
            'issues' => function (Relations\Relation $query) use ($status) {

This code seems to be duplicated across your project.

                $query->with('updatedBy');
                if ($status === Project::STATUS_OPEN) {
                    $query->where('status', '=', Project\Issue::STATUS_OPEN);
                }
            },
            'issues.user' => function () {
            },
            'issues.countComments' => function () {
            },
        ]);

        return $query;
    }

    /**
     * Returns collection of tags for Kanban view.
     *
     * @param User $user
     *
     * @return mixed
     */
    public function getKanbanTagsForUser(User $user)
    {
        $tags = $this->kanbanTags()

The method kanbanTags() does not exist on Tinyissue\Model\Traits\Project\QueryTrait. Did you maybe mean getKanbanTagsForUser()?

            ->where(function (Eloquent\Builder $query) use ($user) {
                $query->where('role_limit', '<=', $user->role_id);
                $query->orWhere('role_limit', '=', null);
            })
            ->get();

        return $tags;
    }

    /**
     * Returns collection of issues grouped by tags.
     *
     * @param $tagIds
     *
     * @return mixed
     */
    public function issuesGroupByTags($tagIds)
    {
        $issues = $this->issues()
        ->with('user', 'tags')
            ->where('status', '=', Project\Issue::STATUS_OPEN)
            ->whereIn('projects_issues_tags.tag_id', $tagIds)
            ->join('projects_issues_tags', 'issue_id', '=', 'id')
            ->orderBy('id')
            ->get()
            ->groupBy(function (Project\Issue $issue) {
                return $issue->getStatusTag()->name;
            });

        return $issues;
    }

    /**
     * Returns users assigned to the project that can fix issues (with edit permission).
     *
     * @return Relations\BelongsToMany
     */
    public function usersCanFixIssue()
    {
        return $this->users()->where('users.role_id', '>', 1)->where('users.deleted', '=', User::NOT_DELETED_USERS);
    }
}