Tinyissue\Model\Traits\Project\CountTrait

Complexity

Total Complexity

15

Size/Duplication

Total Lines	163
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

83.33%

Importance

Changes	6
Bugs	4	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
	hasOne()	0	1	?
	isPrivateInternal()	0	1	?
A	closedIssuesCount()	0	4	1
A	countPrivateProjects()	0	6	1
A	countOpenProjects()	0	4	1
A	countArchivedProjects()	0	4	1
A	countOpenIssues()	0	7	1
A	countClosedIssues()	0	10	1
A	issuesCount()	0	6	1
A	openIssuesCount()	0	4	1
A	issuesCountByStatus()	0	17	4
A	projectsWithCountIssues()	0	7	1
A	projectsWithOpenIssuesCount()	0	11	2

<?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 Tinyissue\Model\Project;
use Tinyissue\Model\User;

/**
 * CountTrait is trait class containing the methods for counting database records for the Project model.
 *
 * @author Mohamed Alsharaf <mohamed.alsharaf@gmail.com>
 *
 * @property static $this
 */
trait CountTrait
{
    /**
     * Count number of private projects.
     *
     * @return int
     */
    public function countPrivateProjects()
    {
        return $this

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

            ->where('private', '=', Project::PRIVATE_YES)
            ->orWhere('private', '=', Project::INTERNAL_YES)->count();
    }

    /**
     * Count number of open projects.
     *
     * @return int
     */
    public function countOpenProjects()
    {
        return $this->where('status', '=', Project::STATUS_OPEN)->count();

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

    }

    /**
     * Count number of archived projects.
     *
     * @return int
     */
    public function countArchivedProjects()
    {
        return $this->where('status', '=', Project::STATUS_ARCHIVED)->count();

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

    }

    /**
     * Count number of open issue in the project.
     *
     * @return int
     */
    public function countOpenIssues()
    {
        return Project\Issue::join('projects', 'projects.id', '=', 'projects_issues.project_id')
            ->where('projects.status', '=', Project::STATUS_OPEN)
            ->where('projects_issues.status', '=', Project\Issue::STATUS_OPEN)
            ->count();
    }

    /**
     * Count number of closed issue in the project.
     *
     * @return int
     */
    public function countClosedIssues()
    {
        return Project\Issue::join('projects', 'projects.id', '=', 'projects_issues.project_id')
            ->where(function (Eloquent\Builder $query) {
                $query->where('projects.status', '=', Project::STATUS_OPEN);
                $query->where('projects_issues.status', '=', Project\Issue::STATUS_CLOSED);
            })
            ->orWhere('projects_issues.status', '=', Project\Issue::STATUS_CLOSED)
            ->count();
    }

    /**
     * For eager loading: count number of issues.
     *
     * @return Eloquent\Relations\HasOne
     */
    public function issuesCount()
    {
        return $this->issues()

The method issues() does not exist on Tinyissue\Model\Traits\Project\CountTrait. Did you maybe mean countOpenIssues()?

            ->selectRaw('project_id, count(*) as aggregate')
            ->groupBy('project_id');
    }

    /**
     * For eager loading: include number of closed issues.
     *
     * @param User $limitByUser
     *
     * @return Eloquent\Relations\HasOne
     */
    public function closedIssuesCount(User $limitByUser = null)
    {
        return $this->issuesCountByStatus(Project\Issue::STATUS_CLOSED, $limitByUser);
    }

    /**
     * For eager loading: include number of open issues.
     *
     * @param User $limitByUser
     *
     * @return Eloquent\Relations\HasOne
     */
    public function openIssuesCount(User $limitByUser = null)
    {
        return $this->issuesCountByStatus(Project\Issue::STATUS_OPEN, $limitByUser);
    }

    /**
     * For eager loading: include number of issues by open/closed status.
     *
     * @param int       $status
     * @param User|null $limitByUser
     *
     * @return Eloquent\Relations\HasOne
     */
    protected function issuesCountByStatus($status, User $limitByUser = null)
    {
        $query = $this
            ->hasOne(
                'Tinyissue\Model\Project\Issue',
                'project_id'
            )
            ->selectRaw('project_id, count(*) as aggregate')
            ->where('status', '=', $status)
            ->groupBy('project_id');

        if ($limitByUser && $limitByUser->isUser() && $this->isPrivateInternal()) {
            $query->where('created_by', '=', $limitByUser->id);
        }

        return $query;
    }

    /**
     * Return projects with count of open & closed issues.
     *
     * @param array $projectIds
     *
     * @return Eloquent\Collection
     */
    public function projectsWithCountIssues(array $projectIds)
    {
        return $this

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

            ->with('openIssuesCount', 'closedIssuesCount')
            ->whereIn('id', $projectIds)
            ->get();
    }

    /**
     * Returns projects with open issue count.
     *
     * @param int $status
     * @param int $private
     *
     * @return mixed
     */
    public function projectsWithOpenIssuesCount($status = Project::STATUS_OPEN, $private = Project::PRIVATE_YES)
    {
        $query = $this->with('openIssuesCount')

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

            ->where('status', '=', $status);

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

        return $query;
    }

    abstract public function hasOne($related, $foreignKey = null, $localKey = null);
    abstract public function isPrivateInternal();
}