RelatedPosts::loadRelatedPosts() - Code Metrics - Inspection of "Prepare for release." - GinoPane/oc-blogtaxonomy-plugin - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a30fc0...84b57d )

by Gino

created 2018-08-09 19:27 UTC

RelatedPosts::loadRelatedPosts() B

↳ Parent: RelatedPosts

Complexity

Conditions	7
Paths	9

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	52
rs	8.1138
c	0
b	0
f	0
cc	7
nc	9
nop	0

How to fix Long Method

<?php

namespace GinoPane\BlogTaxonomy\Components;

use DB;
use Cms\Classes\Page;
use GinoPane\BlogTaxonomy\Models\Tag;
use October\Rain\Database\Collection;
use RainLab\Blog\Models\Post;
use GinoPane\BlogTaxonomy\Plugin;

/**
 * Class RelatedPosts
 *
 * @package GinoPane\BlogTaxonomy\Components
 */
class RelatedPosts extends ComponentAbstract
{
    const NAME = 'relatedPosts';

    use TranslateArrayTrait;

    /**
     * @var Collection | array
     */
    public $posts = [];

    /**
     * Reference to the page name for linking to posts
     *
     * @var string
     */
    public $postPage;

    /**
     * If the post list should be ordered by another attribute
     *
     * @var string
     */
    public $orderBy;

    /**
     * Limits the number of records to display
     *
     * @var int
     */
    public $limit;

    /**
     * Component Registration
     *
     * @return  array

     */
    public function componentDetails()
    {
        return [
            'name'        => Plugin::LOCALIZATION_KEY . 'components.related_posts.name',
            'description' => Plugin::LOCALIZATION_KEY . 'components.related_posts.description'
        ];
    }

    /**
     * Component Properties
     *
     * @return  array

     */
    public function defineProperties()
    {
        return [
            'slug' => [
                'title'             => Plugin::LOCALIZATION_KEY . 'components.related_posts.post_slug_title',
                'description'       => Plugin::LOCALIZATION_KEY . 'components.related_posts.post_slug_description',
                'default'           => '{{ :slug }}',
                'type'              => 'string'
            ],

            'limit' => [
                'title'             => Plugin::LOCALIZATION_KEY . 'components.tag_list.limit_title',
                'description'       => Plugin::LOCALIZATION_KEY . 'components.tag_list.limit_description',
                'type'              => 'string',
                'default'           => '0',
                'validationPattern' => '^[0-9]+$',
                'validationMessage' => Plugin::LOCALIZATION_KEY . 'components.tag_list.validation_message',
                'showExternalParam' => false
            ],

            'orderBy' => [
                'title'       => 'rainlab.blog::lang.settings.posts_order',
                'description' => 'rainlab.blog::lang.settings.posts_order_description',
                'type'        => 'dropdown',
                'default'     => 'published_at asc',
                'showExternalParam' => false
            ],

            'postPage' => [
                'group'       => Plugin::LOCALIZATION_KEY . 'components.related_posts.links_group',
                'title'       => 'rainlab.blog::lang.settings.posts_post',
                'description' => 'rainlab.blog::lang.settings.posts_description',
                'type'        => 'dropdown',
                'default'     => 'blog/post',
            ],
        ];
    }

    /**
     * @see PostListAbstract::$postAllowedSortingOptions
     *
     * @return mixed
     */
    public function getOrderByOptions()
    {
        $order = $this->translate(
            array_merge(
                [
                    'relevance asc' => Plugin::LOCALIZATION_KEY . 'order_options.relevance_asc',
                    'relevance desc' => Plugin::LOCALIZATION_KEY . 'order_options.relevance_desc'
                ],
                PostListAbstract::$postAllowedSortingOptions
            )
        );

        asort($order);

        return $order;
    }

    private function prepareVars()
    {
        $this->orderBy = $this->page['orderBy'] = $this->property('orderBy');

        // Page links
        $this->postPage = $this->page['postPage' ] = $this->property('postPage');
    }

    public function getPostPageOptions()

    {
        return Page::sortBy('baseFileName')->lists('baseFileName', 'baseFileName');
    }

    /**
     * Load post and start building query for related posts
     */
    public function onRun()
    {
        //Prepare vars
        $this->prepareVars();

        $this->posts = $this->loadRelatedPosts();
    }

    /**
     *
     * @return mixed
     */
    private function loadRelatedPosts()
    {
        $post = Post::where('slug', $this->property('slug'))
            ->with('tags')
            ->first();

        if (!$post || (!$tagIds = $post->tags->lists('id'))) {
            return null;
        }

        $query = Post::isPublished()
            ->where('id', '<>', $post->id)
            ->whereHas('tags', function ($tag) use ($tagIds) {
                $tag->whereIn('id', $tagIds);
            })
            ->with('tags');

        if (in_array($this->orderBy, array_keys($this->getOrderByOptions()))) {
            if ($this->orderBy == 'random') {
                $query->inRandomOrder();
            } else {
                list($sortField, $sortDirection) = explode(' ', $this->orderBy);

                if ($sortField == 'relevance') {
                    $sortField = DB::raw(
                        sprintf(
                            '(
                                select count(*)
                                from `%1$s`
                                where `%1$s`.`post_id` = `rainlab_blog_posts`.`id`
                                and `%1$s`.`tag_id` in (%2$s)
                            )',
                            Tag::CROSS_REFERENCE_TABLE_NAME,
                            DB::getPdo()->quote(implode(', ', $tagIds))
                        )
                    );
                }

                $query->orderBy($sortField, $sortDirection);
            }
        }

        if ($take = intval($this->property('limit'))) {
            $query->take($take);
        }

        $posts = $query->get();

        $this->setPostUrls($posts);

        return $posts;
    }
}


1			<?php
2
3			namespace GinoPane\BlogTaxonomy\Components;
4
5			use DB;
6			use Cms\Classes\Page;
7			use GinoPane\BlogTaxonomy\Models\Tag;
8			use October\Rain\Database\Collection;
9			use RainLab\Blog\Models\Post;
10			use GinoPane\BlogTaxonomy\Plugin;
11
12			/**
13			* Class RelatedPosts
14			*
15			* @package GinoPane\BlogTaxonomy\Components
16			*/
17			class RelatedPosts extends ComponentAbstract
18			{
19			const NAME = 'relatedPosts';
20
21			use TranslateArrayTrait;
22
23			/**
24			* @var Collection \| array
25			*/
26			public $posts = [];
27
28			/**
29			* Reference to the page name for linking to posts
30			*
31			* @var string
32			*/
33			public $postPage;
34
35			/**
36			* If the post list should be ordered by another attribute
37			*
38			* @var string
39			*/
40			public $orderBy;
41
42			/**
43			* Limits the number of records to display
44			*
45			* @var int
46			*/
47			public $limit;
48
49			/**
50			* Component Registration
51			*
52			* @return array
			0 ignored issues – show Documentation introduced 2018-05-31 18:18 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `array<string,string>`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
53			*/
54			public function componentDetails()
55			{
56			return [
57			'name' => Plugin::LOCALIZATION_KEY . 'components.related_posts.name',
58			'description' => Plugin::LOCALIZATION_KEY . 'components.related_posts.description'
59			];
60			}
61
62			/**
63			* Component Properties
64			*
65			* @return array
			0 ignored issues – show Documentation introduced 2018-06-20 19:46 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `array<string,array<string,string\|false>>`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
66			*/
67			public function defineProperties()
68			{
69			return [
70			'slug' => [
71			'title' => Plugin::LOCALIZATION_KEY . 'components.related_posts.post_slug_title',
72			'description' => Plugin::LOCALIZATION_KEY . 'components.related_posts.post_slug_description',
73			'default' => '{{ :slug }}',
74			'type' => 'string'
75			],
76
77			'limit' => [
78			'title' => Plugin::LOCALIZATION_KEY . 'components.tag_list.limit_title',
79			'description' => Plugin::LOCALIZATION_KEY . 'components.tag_list.limit_description',
80			'type' => 'string',
81			'default' => '0',
82			'validationPattern' => '^[0-9]+$',
83			'validationMessage' => Plugin::LOCALIZATION_KEY . 'components.tag_list.validation_message',
84			'showExternalParam' => false
85			],
86
87			'orderBy' => [
88			'title' => 'rainlab.blog::lang.settings.posts_order',
89			'description' => 'rainlab.blog::lang.settings.posts_order_description',
90			'type' => 'dropdown',
91			'default' => 'published_at asc',
92			'showExternalParam' => false
93			],
94
95			'postPage' => [
96			'group' => Plugin::LOCALIZATION_KEY . 'components.related_posts.links_group',
97			'title' => 'rainlab.blog::lang.settings.posts_post',
98			'description' => 'rainlab.blog::lang.settings.posts_description',
99			'type' => 'dropdown',
100			'default' => 'blog/post',
101			],
102			];
103			}
104
105			/**
106			* @see PostListAbstract::$postAllowedSortingOptions
107			*
108			* @return mixed
109			*/
110			public function getOrderByOptions()
111			{
112			$order = $this->translate(
113			array_merge(
114			[
115			'relevance asc' => Plugin::LOCALIZATION_KEY . 'order_options.relevance_asc',
116			'relevance desc' => Plugin::LOCALIZATION_KEY . 'order_options.relevance_desc'
117			],
118			PostListAbstract::$postAllowedSortingOptions
119			)
120			);
121
122			asort($order);
123
124			return $order;
125			}
126
127			private function prepareVars()
128			{
129			$this->orderBy = $this->page['orderBy'] = $this->property('orderBy');
130
131			// Page links
132			$this->postPage = $this->page['postPage' ] = $this->property('postPage');
133			}
134
135			public function getPostPageOptions()
			0 ignored issues – show Documentation introduced 2018-05-31 18:18 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
136			{
137			return Page::sortBy('baseFileName')->lists('baseFileName', 'baseFileName');
138			}
139
140			/**
141			* Load post and start building query for related posts
142			*/
143			public function onRun()
144			{
145			//Prepare vars
146			$this->prepareVars();
147
148			$this->posts = $this->loadRelatedPosts();
149			}
150
151			/**
152			*
153			* @return mixed
154			*/
155			private function loadRelatedPosts()
156			{
157			$post = Post::where('slug', $this->property('slug'))
158			->with('tags')
159			->first();
160
161			if (!$post \|\| (!$tagIds = $post->tags->lists('id'))) {
162			return null;
163			}
164
165			$query = Post::isPublished()
166			->where('id', '<>', $post->id)
167			->whereHas('tags', function ($tag) use ($tagIds) {
168			$tag->whereIn('id', $tagIds);
169			})
170			->with('tags');
171
172			if (in_array($this->orderBy, array_keys($this->getOrderByOptions()))) {
173			if ($this->orderBy == 'random') {
174			$query->inRandomOrder();
175			} else {
176			list($sortField, $sortDirection) = explode(' ', $this->orderBy);
177
178			if ($sortField == 'relevance') {
179			$sortField = DB::raw(
180			sprintf(
181			'(
182			select count(*)
183			from `%1$s`
184			where `%1$s`.`post_id` = `rainlab_blog_posts`.`id`
185			and `%1$s`.`tag_id` in (%2$s)
186			)',
187			Tag::CROSS_REFERENCE_TABLE_NAME,
188			DB::getPdo()->quote(implode(', ', $tagIds))
189			)
190			);
191			}
192
193			$query->orderBy($sortField, $sortDirection);
194			}
195			}
196
197			if ($take = intval($this->property('limit'))) {
198			$query->take($take);
199			}
200
201			$posts = $query->get();
202
203			$this->setPostUrls($posts);
204
205			return $posts;
206			}
207			}
208

GinoPane / oc-blogtaxonomy-plugin

Push — master ( a30fc0...84b57d )

RelatedPosts::loadRelatedPosts() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like