CountsManager::increasePostCounts() - Code Metrics - Inspection of "fix termId and postId counts" - pryley/site-reviews - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( cec1ed...b70895 )

by Paul

created 2018-07-22 19:22 UTC

CountsManager::increasePostCounts() A

↳ Parent: CountsManager

Complexity

Conditions	3
Paths	3

Size

Total Lines	8
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	6.28

Importance

Changes

Metric	Value
cc	3
eloc	6
nc	3
nop	1
dl	0
loc	8
ccs	2
cts	7
cp	0.2857
crap	6.28
rs	10
c	0
b	0
f	0

<?php

namespace GeminiLabs\SiteReviews\Database;

use GeminiLabs\SiteReviews\Application;
use GeminiLabs\SiteReviews\Database\OptionManager;
use GeminiLabs\SiteReviews\Database\ReviewManager;
use GeminiLabs\SiteReviews\Database\SqlQueries;
use GeminiLabs\SiteReviews\Modules\Rating;
use GeminiLabs\SiteReviews\Review;
use WP_Post;
use WP_Term;

class CountsManager
{
	const META_AVERAGE = '_glsr_average';
	const META_COUNT = '_glsr_count';
	const META_RANKING = '_glsr_ranking';

	/**
	 * @param int $limit
	 * @return array
	 */
	public function buildCounts( $limit = 500 )
	{
		return $this->build( $limit );
	}

	/**
	 * @param int $postId
	 * @param int $limit
	 * @return array
	 */
	public function buildPostCounts( $postId, $limit = 500 )
	{
		return $this->build( $limit, ['post_id' => $postId] );
	}

	/**
	 * @param int $termId
	 * @param int $limit
	 * @return array
	 */
	public function buildTermCounts( $termId, $limit = 500 )
	{
		return $this->build( $limit, ['term_id' => $termId] );
	}

	/**
	 * @return void
	 */
	public function decrease( Review $review )
	{
		$this->decreaseCounts( $review );
		$this->decreasePostCounts( $review );
		$this->decreaseTermCounts( $review );
	}

	/**
	 * @return void
	 */
	public function decreaseCounts( Review $review )
	{
		$this->setCounts( $this->decreaseRating(
			$this->getCounts(),
			$review->review_type,
			$review->rating
		));
	}

	/**
	 * @return void
	 */
	public function decreasePostCounts( Review $review )
	{
		if( empty( $counts = $this->getPostCounts( $review->assigned_to )))return;
		$counts = $this->decreaseRating( $counts, $review->review_type, $review->rating );
		$this->setPostCounts( $review->assigned_to, $counts );
	}

	/**
	 * @return void
	 */
	public function decreaseTermCounts( Review $review )
	{
		foreach( $review->term_ids as $termId ) {
			if( empty( $counts = $this->getTermCounts( $termId )))continue;
			$counts = $this->decreaseRating( $counts, $review->review_type, $review->rating );
			$this->setTermCounts( $termId, $counts );
		}
	}

	/**
	 * @return array
	 */
	public function flatten( array $reviewCounts, array $args = [] )
	{
		$counts = [];
		array_walk_recursive( $reviewCounts, function( $num, $index ) use( &$counts ) {
			$counts[$index] = isset( $counts[$index] )
				? $num + $counts[$index]
				: $num;
		});
		$args = wp_parse_args( $args, [
			'max' => Rating::MAX_RATING,
			'min' => Rating::MIN_RATING,
		]);
		foreach( $counts as $index => &$num ) {
			if( $index >= intval( $args['min'] ) && $index <= intval( $args['max'] ))continue;
			$num = 0;
		}
		return $counts;
	}

	/**
	 * @return array
	 */
	public function get( array $args = [] )
	{
		$args = wp_parse_args( $args, [
			'post_ids' => [],
			'term_ids' => [],
			'type' => 'local',
		]);
		$counts = [];
		foreach( $args['post_ids'] as $postId ) {
			$counts[] = $this->getPostCounts( $postId );
		}
		foreach( $args['term_ids'] as $termId ) {
			$counts[] = $this->getTermCounts( $termId );
		}
		if( empty( $counts )) {
			$counts[] = $this->getCounts();
		}
		return array_column( $counts, $args['type'] );
	}

	/**
	 * @return array
	 */
	public function getCounts()
	{
		return glsr( OptionManager::class )->get( 'count', [] );
	}

	/**
	 * @param int $postId
	 * @return array
	 */
	public function getPostCounts( $postId )
	{
		return array_filter( (array)get_post_meta( $postId, static::META_COUNT, true ));
	}

	/**
	 * @param int $termId
	 * @return array
	 */
	public function getTermCounts( $termId )
	{
		return array_filter( (array)get_term_meta( $termId, static::META_COUNT, true ));
	}

	/**
	 * @return void
	 */
	public function increase( Review $review )
	{
		$this->increaseCounts( $review );
		$this->increasePostCounts( $review );
		$this->increaseTermCounts( $review );
	}

	/**
	 * @return void
	 */
	public function increaseCounts( Review $review )
	{
		if( empty( $counts = $this->getCounts() )) {
			$counts = $this->buildCounts();
		}
		$this->setCounts( $this->increaseRating(
			$counts,
			$review->review_type,
			$review->rating
		));
	}

	/**
	 * @return void
	 */
	public function increasePostCounts( Review $review )
	{
		if( !( get_post( $review->assigned_to ) instanceof WP_Post ))return;
		$counts = $this->getPostCounts( $review->assigned_to );
		$counts = empty( $counts )
			? $this->buildPostCounts( $review->assigned_to )
			: $this->increaseRating( $counts, $review->review_type, $review->rating );
		$this->setPostCounts( $review->assigned_to, $counts );
	}

	/**
	 * @return void
	 */
	public function increaseTermCounts( Review $review )
	{
		$termIds = glsr( ReviewManager::class )->normalizeTerms( implode( ',', $review->term_ids ));
		foreach( $termIds as $termId ) {
			$counts = $this->getTermCounts( $termId );
			$counts = empty( $counts )
				? $this->buildTermCounts( $termId )
				: $this->increaseRating( $counts, $review->review_type, $review->rating );
			$this->setTermCounts( $termId, $counts );
		}
	}

	/**
	 * @return void
	 */
	public function setCounts( array $reviewCounts )
	{
		glsr( OptionManager::class )->set( 'count', $reviewCounts );
	}

	/**
	 * @param int $postId
	 * @return void
	 */
	public function setPostCounts( $postId, array $reviewCounts )
	{
		$ratingCounts = glsr( CountsManager::class )->flatten( $reviewCounts );
		update_post_meta( $postId, static::META_COUNT, $reviewCounts );
		update_post_meta( $postId, static::META_AVERAGE, glsr( Rating::class )->getAverage( $ratingCounts ));
		update_post_meta( $postId, static::META_RANKING, glsr( Rating::class )->getRanking( $ratingCounts ));
	}

	/**
	 * @param int $termId
	 * @return void
	 */
	public function setTermCounts( $termId, array $reviewCounts )
	{
		if( !term_exists( $termId ))return;
		$ratingCounts = glsr( CountsManager::class )->flatten( $reviewCounts );
		update_term_meta( $termId, static::META_COUNT, $reviewCounts );
		update_term_meta( $termId, static::META_AVERAGE, glsr( Rating::class )->getAverage( $ratingCounts ));
		update_term_meta( $termId, static::META_RANKING, glsr( Rating::class )->getRanking( $ratingCounts ));
	}

	/**
	 * @param int $limit
	 * @return array
	 */
	protected function build( $limit, array $args = [] )
	{
		$counts = [];
		$lastPostId = 0;
		while( $reviews = $this->queryReviews( $args, $lastPostId, $limit )) {
			$types = array_keys( array_flip( array_column( $reviews, 'type' )));
			foreach( $types as $type ) {
				if( isset( $counts[$type] ))continue;
				$counts[$type] = array_fill_keys( range( 0, Rating::MAX_RATING ), 0 );
			}
			foreach( $reviews as $review ) {
				$counts[$review->type][$review->rating]++;
			}
			$lastPostId = end( $reviews )->ID;
		}
		return $counts;
	}

	/**
	 * @param string $type
	 * @param int $rating
	 * @return array
	 */
	protected function decreaseRating( array $reviewCounts, $type, $rating )
	{
		if( isset( $reviewCounts[$type][$rating] )) {
			$reviewCounts[$type][$rating] = max( 0, $reviewCounts[$type][$rating] - 1 );
		}
		return $reviewCounts;
	}

	/**
	 * @param string $type
	 * @param int $rating
	 * @return array
	 */
	protected function increaseRating( array $reviewCounts, $type, $rating )
	{
		if( !array_key_exists( $type, glsr()->reviewTypes )) {
			return $reviewCounts;
		}
		if( !array_key_exists( $type, $reviewCounts )) {
			$reviewCounts[$type] = [];
		}
		$reviewCounts = $this->normalize( $reviewCounts );
		$reviewCounts[$type][$rating] = intval( $reviewCounts[$type][$rating] ) + 1;
		return $reviewCounts;
	}

	/**
	 * @return array
	 */
	protected function normalize( array $reviewCounts )
	{
		foreach( $reviewCounts as &$counts ) {
			foreach( range( 0, Rating::MAX_RATING ) as $index ) {
				if( isset( $counts[$index] ))continue;
				$counts[$index] = 0;
			}
			ksort( $counts );
		}
		return $reviewCounts;
	}

	/**
	 * @param int $lastPostId
	 * @param int $limit
	 * @return void|array
	 */
	protected function queryReviews( array $args = [], $lastPostId, $limit )
	{
		$args = wp_parse_args( $args, array_fill_keys( ['post_id', 'term_id'], '' ));
		if( empty( array_filter( $args ))) {
			return glsr( SqlQueries::class )->getReviewCounts( $lastPostId, $limit );
		}
		if( !empty( $args['post_id'] )) {
			return glsr( SqlQueries::class )->getReviewPostCounts( $args['post_id'], $lastPostId, $limit );
		}
		if( !empty( $args['term_id'] )) {
			return glsr( SqlQueries::class )->getReviewTermCounts( $args['term_id'], $lastPostId, $limit );
		}
	}
}


1		<?php
2
3		namespace GeminiLabs\SiteReviews\Database;
4
5		use GeminiLabs\SiteReviews\Application;
6		use GeminiLabs\SiteReviews\Database\OptionManager;
7		use GeminiLabs\SiteReviews\Database\ReviewManager;
8		use GeminiLabs\SiteReviews\Database\SqlQueries;
9		use GeminiLabs\SiteReviews\Modules\Rating;
10		use GeminiLabs\SiteReviews\Review;
11		use WP_Post;
12		use WP_Term;
13
14		class CountsManager
15		{
16		const META_AVERAGE = '_glsr_average';
17		const META_COUNT = '_glsr_count';
18		const META_RANKING = '_glsr_ranking';
19
20		/**
21		* @param int $limit
22		* @return array
23		*/
24	1	public function buildCounts( $limit = 500 )
25		{
26	1	return $this->build( $limit );
27		}
28
29		/**
30		* @param int $postId
31		* @param int $limit
32		* @return array
33		*/
34		public function buildPostCounts( $postId, $limit = 500 )
35		{
36		return $this->build( $limit, ['post_id' => $postId] );
37		}
38
39		/**
40		* @param int $termId
41		* @param int $limit
42		* @return array
43		*/
44		public function buildTermCounts( $termId, $limit = 500 )
45		{
46		return $this->build( $limit, ['term_id' => $termId] );
47		}
48
49		/**
50		* @return void
51		*/
52		public function decrease( Review $review )
53		{
54		$this->decreaseCounts( $review );
55		$this->decreasePostCounts( $review );
56		$this->decreaseTermCounts( $review );
57		}
58
59		/**
60		* @return void
61		*/
62		public function decreaseCounts( Review $review )
63		{
64		$this->setCounts( $this->decreaseRating(
65		$this->getCounts(),
66		$review->review_type,
67		$review->rating
68		));
69		}
70
71		/**
72		* @return void
73		*/
74		public function decreasePostCounts( Review $review )
75		{
76		if( empty( $counts = $this->getPostCounts( $review->assigned_to )))return;
77		$counts = $this->decreaseRating( $counts, $review->review_type, $review->rating );
78		$this->setPostCounts( $review->assigned_to, $counts );
79		}
80
81		/**
82		* @return void
83		*/
84		public function decreaseTermCounts( Review $review )
85		{
86		foreach( $review->term_ids as $termId ) {
87		if( empty( $counts = $this->getTermCounts( $termId )))continue;
88		$counts = $this->decreaseRating( $counts, $review->review_type, $review->rating );
89		$this->setTermCounts( $termId, $counts );
90		}
91		}
92
93		/**
94		* @return array
95		*/
96		public function flatten( array $reviewCounts, array $args = [] )
97		{
98		$counts = [];
99		array_walk_recursive( $reviewCounts, function( $num, $index ) use( &$counts ) {
100		$counts[$index] = isset( $counts[$index] )
101		? $num + $counts[$index]
102		: $num;
103		});
104		$args = wp_parse_args( $args, [
105		'max' => Rating::MAX_RATING,
106		'min' => Rating::MIN_RATING,
107		]);
108		foreach( $counts as $index => &$num ) {
109		if( $index >= intval( $args['min'] ) && $index <= intval( $args['max'] ))continue;
110		$num = 0;
111		}
112		return $counts;
113		}
114
115		/**
116		* @return array
117		*/
118		public function get( array $args = [] )
119		{
120		$args = wp_parse_args( $args, [
121		'post_ids' => [],
122		'term_ids' => [],
123		'type' => 'local',
124		]);
125		$counts = [];
126		foreach( $args['post_ids'] as $postId ) {
127		$counts[] = $this->getPostCounts( $postId );
128		}
129		foreach( $args['term_ids'] as $termId ) {
130		$counts[] = $this->getTermCounts( $termId );
131		}
132		if( empty( $counts )) {
133		$counts[] = $this->getCounts();
134		}
135		return array_column( $counts, $args['type'] );
136		}
137
138		/**
139		* @return array
140		*/
141	1	public function getCounts()
142		{
143	1	return glsr( OptionManager::class )->get( 'count', [] );
144		}
145
146		/**
147		* @param int $postId
148		* @return array
149		*/
150		public function getPostCounts( $postId )
151		{
152		return array_filter( (array)get_post_meta( $postId, static::META_COUNT, true ));
153		}
154
155		/**
156		* @param int $termId
157		* @return array
158		*/
159		public function getTermCounts( $termId )
160		{
161		return array_filter( (array)get_term_meta( $termId, static::META_COUNT, true ));
162		}
163
164		/**
165		* @return void
166		*/
167	1	public function increase( Review $review )
168		{
169	1	$this->increaseCounts( $review );
170	1	$this->increasePostCounts( $review );
171	1	$this->increaseTermCounts( $review );
172	1	}
173
174		/**
175		* @return void
176		*/
177	1	public function increaseCounts( Review $review )
178		{
179	1	if( empty( $counts = $this->getCounts() )) {
180	1	$counts = $this->buildCounts();
181		}
182	1	$this->setCounts( $this->increaseRating(
183	1	$counts,
184	1	$review->review_type,
185	1	$review->rating
186		));
187	1	}
188
189		/**
190		* @return void
191		*/
192	1	public function increasePostCounts( Review $review )
193		{
194	1	if( !( get_post( $review->assigned_to ) instanceof WP_Post ))return;
195		$counts = $this->getPostCounts( $review->assigned_to );
196		$counts = empty( $counts )
197		? $this->buildPostCounts( $review->assigned_to )
198		: $this->increaseRating( $counts, $review->review_type, $review->rating );
199		$this->setPostCounts( $review->assigned_to, $counts );
200		}
201
202		/**
203		* @return void
204		*/
205	1	public function increaseTermCounts( Review $review )
206		{
207	1	$termIds = glsr( ReviewManager::class )->normalizeTerms( implode( ',', $review->term_ids ));
208	1	foreach( $termIds as $termId ) {
209		$counts = $this->getTermCounts( $termId );
210		$counts = empty( $counts )
211		? $this->buildTermCounts( $termId )
212		: $this->increaseRating( $counts, $review->review_type, $review->rating );
213		$this->setTermCounts( $termId, $counts );
214		}
215	1	}
216
217		/**
218		* @return void
219		*/
220	1	public function setCounts( array $reviewCounts )
221		{
222	1	glsr( OptionManager::class )->set( 'count', $reviewCounts );
223	1	}
224
225		/**
226		* @param int $postId
227		* @return void
228		*/
229		public function setPostCounts( $postId, array $reviewCounts )
230		{
231		$ratingCounts = glsr( CountsManager::class )->flatten( $reviewCounts );
232		update_post_meta( $postId, static::META_COUNT, $reviewCounts );
233		update_post_meta( $postId, static::META_AVERAGE, glsr( Rating::class )->getAverage( $ratingCounts ));
234		update_post_meta( $postId, static::META_RANKING, glsr( Rating::class )->getRanking( $ratingCounts ));
235		}
236
237		/**
238		* @param int $termId
239		* @return void
240		*/
241		public function setTermCounts( $termId, array $reviewCounts )
242		{
243		if( !term_exists( $termId ))return;
244		$ratingCounts = glsr( CountsManager::class )->flatten( $reviewCounts );
245		update_term_meta( $termId, static::META_COUNT, $reviewCounts );
246		update_term_meta( $termId, static::META_AVERAGE, glsr( Rating::class )->getAverage( $ratingCounts ));
247		update_term_meta( $termId, static::META_RANKING, glsr( Rating::class )->getRanking( $ratingCounts ));
248		}
249
250		/**
251		* @param int $limit
252		* @return array
253		*/
254	1	protected function build( $limit, array $args = [] )
255		{
256	1	$counts = [];
257	1	$lastPostId = 0;
258	1	while( $reviews = $this->queryReviews( $args, $lastPostId, $limit )) {
259	1	$types = array_keys( array_flip( array_column( $reviews, 'type' )));
260	1	foreach( $types as $type ) {
261	1	if( isset( $counts[$type] ))continue;
262	1	$counts[$type] = array_fill_keys( range( 0, Rating::MAX_RATING ), 0 );
263		}
264	1	foreach( $reviews as $review ) {
265	1	$counts[$review->type][$review->rating]++;
266		}
267	1	$lastPostId = end( $reviews )->ID;
268		}
269	1	return $counts;
270		}
271
272		/**
273		* @param string $type
274		* @param int $rating
275		* @return array
276		*/
277		protected function decreaseRating( array $reviewCounts, $type, $rating )
278		{
279		if( isset( $reviewCounts[$type][$rating] )) {
280		$reviewCounts[$type][$rating] = max( 0, $reviewCounts[$type][$rating] - 1 );
281		}
282		return $reviewCounts;
283		}
284
285		/**
286		* @param string $type
287		* @param int $rating
288		* @return array
289		*/
290	1	protected function increaseRating( array $reviewCounts, $type, $rating )
291		{
292	1	if( !array_key_exists( $type, glsr()->reviewTypes )) {
293		return $reviewCounts;
294		}
295	1	if( !array_key_exists( $type, $reviewCounts )) {
296		$reviewCounts[$type] = [];
297		}
298	1	$reviewCounts = $this->normalize( $reviewCounts );
299	1	$reviewCounts[$type][$rating] = intval( $reviewCounts[$type][$rating] ) + 1;
300	1	return $reviewCounts;
301		}
302
303		/**
304		* @return array
305		*/
306	1	protected function normalize( array $reviewCounts )
307		{
308	1	foreach( $reviewCounts as &$counts ) {
309	1	foreach( range( 0, Rating::MAX_RATING ) as $index ) {
310	1	if( isset( $counts[$index] ))continue;
311		$counts[$index] = 0;
312		}
313	1	ksort( $counts );
314		}
315	1	return $reviewCounts;
316		}
317
318		/**
319		* @param int $lastPostId
320		* @param int $limit
321		* @return void\|array
322		*/
323	1	protected function queryReviews( array $args = [], $lastPostId, $limit )
324		{
325	1	$args = wp_parse_args( $args, array_fill_keys( ['post_id', 'term_id'], '' ));
326	1	if( empty( array_filter( $args ))) {
327	1	return glsr( SqlQueries::class )->getReviewCounts( $lastPostId, $limit );
328		}
329		if( !empty( $args['post_id'] )) {
330		return glsr( SqlQueries::class )->getReviewPostCounts( $args['post_id'], $lastPostId, $limit );
331		}
332		if( !empty( $args['term_id'] )) {
333		return glsr( SqlQueries::class )->getReviewTermCounts( $args['term_id'], $lastPostId, $limit );
334		}
335		}
336		}
337

pryley / site-reviews

Push — master ( cec1ed...b70895 )

CountsManager::increasePostCounts() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like