CountTrait::closedIssuesCount() - Code Metrics - Inspection of "Bug: added several tests cases & bugs fixes" - satrun77/tinyissue - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 335c93...e4583a )

by Mohamed

created 2016-07-29 09:51 UTC

CountTrait::closedIssuesCount() A

↳ Parent: CountTrait

Complexity

Conditions	4
Paths	2

Size

Total Lines	17
Code Lines	11

Duplication

Lines	17
Ratio	100 %

Code Coverage

Tests	9
CRAP Score	4.016

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	17
loc	17
ccs	9
cts	10
cp	0.9
rs	9.2
cc	4
eloc	11
nc	2
nop	1
crap	4.016

<?php

/*
 * This file is part of the Tinyissue package.
 *
 * (c) Mohamed Alsharaf <[email protected]>
 *
 * 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\Query;
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 <[email protected]>
 *
 * @property int   $id
 *
 * @method   Query\Builder where($column, $operator = null, $value = null, $boolean = 'and')
 * @method   Eloquent\Model hasOne($related, $foreignKey = null, $localKey = null)
 * @method   RelationTrait issues()
 */
trait CountTrait
{
    /**
     * Count number of private projects.
     *
     * @return int
     */
    public function countPrivateProjects()
    {
        return $this
            ->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();
    }

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

    /**
     * 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()
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->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($limitByUser = null)

    {
        $query = $this
            ->hasOne(
                'Tinyissue\Model\Project\Issue',
                'project_id'
            )
            ->selectRaw('project_id, count(*) as aggregate')
            ->where('status', '=', Project\Issue::STATUS_CLOSED)
            ->groupBy('project_id');

        if ($limitByUser && $limitByUser->isUser() && $this->isPrivateInternal()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            $query->where('created_by', '=', $limitByUser->id);
        }

        return $query;
    }

    /**
     * For eager loading: include number of open issues.
     *
     * @param User $limitByUser
     *
     * @return Eloquent\Relations\HasOne
     */
    public function openIssuesCount(User $limitByUser = null)

    {
        $query = $this
            ->hasOne(
                'Tinyissue\Model\Project\Issue',
                'project_id'
            )
            ->selectRaw('project_id, count(*) as aggregate')
            ->where('status', '=', Project\Issue::STATUS_OPEN)
            ->groupBy('project_id');

        if ($limitByUser && $limitByUser->isUser() && $this->isPrivateInternal()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            $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
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->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')
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->where('status', '=', $status);

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

        return $query;
    }
}


1			<?php
2
3			/*
4			* This file is part of the Tinyissue package.
5			*
6			* (c) Mohamed Alsharaf <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Tinyissue\Model\Traits\Project;
13
14			use Illuminate\Database\Eloquent;
15			use Illuminate\Database\Query;
16			use Tinyissue\Model\Project;
17			use Tinyissue\Model\User;
18
19			/**
20			* CountTrait is trait class containing the methods for counting database records for the Project model.
21			*
22			* @author Mohamed Alsharaf <[email protected]>
23			*
24			* @property int $id
25			*
26			* @method Query\Builder where($column, $operator = null, $value = null, $boolean = 'and')
27			* @method Eloquent\Model hasOne($related, $foreignKey = null, $localKey = null)
28			* @method RelationTrait issues()
29			*/
30			trait CountTrait
31			{
32			/**
33			* Count number of private projects.
34			*
35			* @return int
36			*/
37			public function countPrivateProjects()
38			{
39			return $this
40			->where('private', '=', Project::PRIVATE_YES)
41			->orWhere('private', '=', Project::INTERNAL_YES)->count();
42			}
43
44			/**
45			* Count number of open projects.
46			*
47			* @return int
48			*/
49	2		public function countOpenProjects()
50			{
51	2		return $this->where('status', '=', Project::STATUS_OPEN)->count();
52			}
53
54			/**
55			* Count number of archived projects.
56			*
57			* @return int
58			*/
59	2		public function countArchivedProjects()
60			{
61	2		return $this->where('status', '=', Project::STATUS_ARCHIVED)->count();
62			}
63
64			/**
65			* Count number of open issue in the project.
66			*
67			* @return int
68			*/
69	2		public function countOpenIssues()
70			{
71	2		return Project\Issue::join('projects', 'projects.id', '=', 'projects_issues.project_id')
72	2		->where('projects.status', '=', Project::STATUS_OPEN)
73	2		->where('projects_issues.status', '=', Project\Issue::STATUS_OPEN)
74	2		->count();
75			}
76
77			/**
78			* Count number of closed issue in the project.
79			*
80			* @return int
81			*/
82	2		public function countClosedIssues()
83			{
84	2		return Project\Issue::join('projects', 'projects.id', '=', 'projects_issues.project_id')
85	2		->where(function (Eloquent\Builder $query) {
86	2		$query->where('projects.status', '=', Project::STATUS_OPEN);
87	2		$query->where('projects_issues.status', '=', Project\Issue::STATUS_CLOSED);
88	2		})
89	2		->orWhere('projects_issues.status', '=', Project\Issue::STATUS_CLOSED)
90	2		->count();
91			}
92
93			/**
94			* For eager loading: count number of issues.
95			*
96			* @return Eloquent\Relations\HasOne
97			*/
98			public function issuesCount()
99			{
100			return $this->issues()
			0 ignored issues – show Bug introduced 2015-12-15 16:27 UTC by Report Bug Copy Issue Report It seems like `selectRaw()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
101			->selectRaw('project_id, count(*) as aggregate')
102			->groupBy('project_id');
103			}
104
105			/**
106			* For eager loading: include number of closed issues.
107			*
108			* @param User $limitByUser
109			*
110			* @return Eloquent\Relations\HasOne
111			*/
112	22	View Code Duplication	public function closedIssuesCount($limitByUser = null)
			0 ignored issues – show Duplication introduced 2016-07-27 09:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
113			{
114			$query = $this
115	22		->hasOne(
116	22		'Tinyissue\Model\Project\Issue',
117	22		'project_id'
118			)
119	22		->selectRaw('project_id, count(*) as aggregate')
120	22		->where('status', '=', Project\Issue::STATUS_CLOSED)
121	22		->groupBy('project_id');
122
123	22		if ($limitByUser && $limitByUser->isUser() && $this->isPrivateInternal()) {
			0 ignored issues – show Bug introduced 2016-07-27 09:46 UTC by Report Bug Copy Issue Report It seems like `isPrivateInternal()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
124			$query->where('created_by', '=', $limitByUser->id);
125			}
126
127	22		return $query;
128			}
129
130			/**
131			* For eager loading: include number of open issues.
132			*
133			* @param User $limitByUser
134			*
135			* @return Eloquent\Relations\HasOne
136			*/
137	23	View Code Duplication	public function openIssuesCount(User $limitByUser = null)
			0 ignored issues – show Duplication introduced 2016-07-27 09:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
138			{
139			$query = $this
140	23		->hasOne(
141	23		'Tinyissue\Model\Project\Issue',
142	23		'project_id'
143			)
144	23		->selectRaw('project_id, count(*) as aggregate')
145	23		->where('status', '=', Project\Issue::STATUS_OPEN)
146	23		->groupBy('project_id');
147
148	23		if ($limitByUser && $limitByUser->isUser() && $this->isPrivateInternal()) {
			0 ignored issues – show Bug introduced 2016-07-27 09:46 UTC by Report Bug Copy Issue Report It seems like `isPrivateInternal()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
149			$query->where('created_by', '=', $limitByUser->id);
150			}
151
152	23		return $query;
153			}
154
155			/**
156			* Return projects with count of open & closed issues.
157			*
158			* @param array $projectIds
159			*
160			* @return Eloquent\Collection
161			*/
162	1		public function projectsWithCountIssues(array $projectIds)
163			{
164			return $this
			0 ignored issues – show Bug introduced 2015-12-15 16:27 UTC by Report Bug Copy Issue Report It seems like `with()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
165	1		->with('openIssuesCount', 'closedIssuesCount')
166	1		->whereIn('id', $projectIds)
167	1		->get();
168			}
169
170			/**
171			* Returns projects with open issue count.
172			*
173			* @param int $status
174			* @param int $private
175			*
176			* @return mixed
177			*/
178	5		public function projectsWithOpenIssuesCount($status = Project::STATUS_OPEN, $private = Project::PRIVATE_YES)
179			{
180	5		$query = $this->with('openIssuesCount')
			0 ignored issues – show Bug introduced 2016-01-10 07:09 UTC by Report Bug Copy Issue Report It seems like `with()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
181	5		->where('status', '=', $status);
182
183	5		if ($private !== Project::PRIVATE_ALL) {
184	3		$query->where('private', '=', $private);
185			}
186
187	5		return $query;
188			}
189			}
190

satrun77 / tinyissue

Push — develop ( 335c93...e4583a )

CountTrait::closedIssuesCount() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like