Tinyissue\Repository\Project\ProjectRepository

Complexity

Total Complexity

28

Size/Duplication

Total Lines	258
Duplicated Lines	14.73 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getActiveProjects()	0	4	1
A	getNotes()	0	4	1
A	getPublicProjects()	0	4	1
A	getNotMembers()	0	4	1
B	getIssues()	5	27	3
A	getAssignedOrCreatedIssues()	0	8	2
A	getCreatedIssues()	0	8	1
A	getAssignedIssues()	0	8	1
A	getRecentActivities()	0	15	3
A	getPublicProjectsWithRecentIssues()	0	9	1
A	getKanbanTagsForUser()	0	4	1
A	getKanbanTags()	0	4	1
A	getUsersCanFixIssue()	0	8	1
A	sortByUpdated()	0	4	1
B	sortByTag()	23	23	5
A	getProjectsWithOpenIssuesCount()	10	10	2
A	getProjectsWithCountIssues()	0	7	1

<?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\Repository\Project;

use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Relations\Relation;
use Tinyissue\Contracts\Model\UserInterface;
use Tinyissue\Contracts\Repository\Project\ProjectRepository as ProjectContract;
use Tinyissue\Model\Project;
use Tinyissue\Model\User;
use Tinyissue\Repository\Repository;

class ProjectRepository extends Repository implements ProjectContract
{
    protected $updaterClass = UpdaterRepository::class;
    protected $counterClass = CounterRepository::class;

    public function __construct(Project $model)
    {
        $this->model = $model;
    }

    /**
     * Returns collection of active projects.
     *
     * @return Eloquent\Collection
     */
    public function getActiveProjects()
    {
        return $this->model->active()->orderBy('name', 'ASC')->get();
    }

    public function getNotes()
    {
        return $this->model->notes()->with('createdBy')->get();
    }

    /**
     * Returns collection of public projects.
     *
     * @return Eloquent\Collection
     */
    public function getPublicProjects()
    {
        return $this->model->public()->orderBy('name', 'ASC')->get();
    }

    /**
     * Returns all users that are not assigned in the current project.
     *
     * @return array
     */
    public function getNotMembers()
    {
        return (new User())->notDeleted()->notMemberOfProject($this->model)->get();

The method notDeleted() does not exist on Tinyissue\Model\User. Did you maybe mean delete()?

    }

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

        $query = $this->model->issues()
            ->with('countComments', 'user', 'updatedBy', 'tags', 'tags.parent')
            ->with([
                'tags' => function (Relation $query) use ($sortOrder) {
                    $query->orderBy('name', $sortOrder);
                },
            ])
            ->status($status)
            ->assignedTo(array_get($filter, 'assignto'))
            ->searchContent(array_get($filter, 'keyword'))
            ->createdBy(array_get($filter, 'created_by'))
            ->whereTags(array_get($filter, 'tag_status'), array_get($filter, 'tag_type'));

        // Sort
        if ($sortBy === 'updated') {

This code seems to be duplicated across your project.

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

The return type of return $this->sortByTag($query, $tagGroup, $sortOrder); (Tinyissue\Repository\Project\Eloquent\Collection) is incompatible with the return type declared by the interface Tinyissue\Contracts\Repository\Project\ProjectRepository::getIssues of type Illuminate\Database\Eloquent\Collection.

        }

        return $query->get();
    }

    /**
     * Fetch issues assigned to a user.
     *
     * @param UserInterface $user
     *
     * @return \Illuminate\Database\Eloquent\Collection
     */
    public function getAssignedOrCreatedIssues(UserInterface $user)
    {
        if ($user->isUser()) {
            return $this->getCreatedIssues($user);
        }

        return $this->getAssignedIssues($user);
    }

    public function getCreatedIssues(UserInterface $user)
    {
        return $this->model->openIssues()
            ->with('countComments', 'user', 'updatedBy')
            ->createdBy($user)
            ->orderBy('updated_at', 'DESC')
            ->get();
    }

    public function getAssignedIssues(UserInterface $user)
    {
        return $this->model->openIssues()
            ->with('countComments', 'user', 'updatedBy')
            ->assignedTo($user)
            ->orderBy('updated_at', 'DESC')
            ->get();
    }

    public function getRecentActivities(UserInterface $user, $limit = 10)
    {
        $activities = $this->model->activities()
            ->with('activity', 'issue', 'user', 'assignTo', 'comment', 'note')
            ->orderBy('users_activity.created_at', 'DESC')
            ->take($limit);

        // Internal project and logged user can see created only
        if ($this->isPrivateInternal() && $user->isUser()) {

The method isPrivateInternal does not exist on object<Tinyissue\Repository\Project\ProjectRepository>? Since you implemented __call, maybe consider adding a @method annotation.

            $activities->join('projects_issues', 'projects_issues.id', '=', 'item_id');
            $activities->where('created_by', '=', $user->id);

Accessing id on the interface Tinyissue\Contracts\Model\UserInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        }

        return $activities;
    }

    /**
     * Returns projects with issues details eager loaded.
     *
     * @return Relations\HasMany
     */
    public function getPublicProjectsWithRecentIssues()
    {
        return $this->model
            ->active()
            ->public()
            ->with('openIssuesWithUpdater', 'issues.user', 'issues.countComments')
            ->orderBy('name')
            ->get();
    }

    /**
     * Returns collection of tags for Kanban view.
     *
     * @param UserInterface $user
     *
     * @return mixed
     */
    public function getKanbanTagsForUser(UserInterface $user)
    {
        return $this->model->kanbanTags()->accessibleToUser($user)->get();
    }

    public function getKanbanTags()
    {
        return $this->model->kanbanTags()->get();
    }

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

    /**
     * Sort by updated_at column.
     *
     * @param HasMany $query
     * @param string  $order
     *
     * @return void
     */
    protected function sortByUpdated(HasMany $query, $order = 'asc')
    {
        $query->orderBy('updated_at', $order);
    }

    /**
     * Sort by issues tag group
     * Note: this sort will return the collection.
     *
     * @param HasMany $query
     * @param string  $tagGroup
     * @param string  $order
     *
     * @return Eloquent\Collection
     */
    protected function sortByTag(HasMany $query, $tagGroup, $order = 'asc')

This method seems to be duplicated in your project.

    {
        // If tag group is string prefixed with tag:
        if (!is_numeric($tagGroup)) {
            $tagGroup = substr($tagGroup, strlen('tag:'));
        }

        $results = $query->get()
            ->sort(function (Project\Issue $issue1, Project\Issue $issue2) use ($tagGroup, $order) {
                $tag1 = $issue1->tags->where('parent.id', $tagGroup, false)->first();
                $tag2 = $issue2->tags->where('parent.id', $tagGroup, false)->first();
                $tag1 = $tag1 ? $tag1->name : '';
                $tag2 = $tag2 ? $tag2->name : '';

                if ($order === 'asc') {
                    return strcmp($tag1, $tag2);
                }

                return strcmp($tag2, $tag1);
            });

        return $results;
    }

    /**
     * Returns projects with open issue count.
     *
     * @param int $status
     * @param int $private
     *
     * @return Collection
     */
    public function getProjectsWithOpenIssuesCount($status = Project::STATUS_OPEN, $private = Project::PRIVATE_YES)

This method seems to be duplicated in your project.

    {
        $query = $this->model->with('countOpenIssues')->status($status);

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

        return $query->get();
    }

    /**
     * Return projects with count of open & closed issues.
     *
     * @param array $projectIds
     *
     * @return Collection
     */
    public function getProjectsWithCountIssues(array $projectIds)
    {
        return $this->model
            ->with('countOpenIssues', 'countOpenIssues')
            ->whereIn('id', $projectIds)
            ->get();
    }
}