org_openpsa_qbpager::execute_unchecked() - Code Metrics - Inspection of "Remove unnecessary redirection" - flack/openpsa - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 0083f3...057072 )

by Andreas
created 2021-05-08 08:50 UTC
org_openpsa_qbpager::execute_unchecked() A

↳ Parent: org_openpsa_qbpager
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
cc	1
eloc	2
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	4
ccs	0
cts	3
cp	0
crap	2
rs	10
<?php
/**
 * @package org.openpsa.qbpager
 */

/**
 * Pages QB resultsets
 *
 * @package org.openpsa.qbpager
 */
class org_openpsa_qbpager
{
    use midcom_baseclasses_components_base;


    public $results_per_page = 25;
    public $display_pages = 10;
    public $string_next = 'next';
    public $string_previous = 'previous';
    protected $_midcom_qb;
    protected $_midcom_qb_count;
    protected $_pager_id;
    protected $_prefix = '';
    private $_offset = 0;
    protected  $count;
    private $_current_page = 1;

    public function __construct(string $classname, string $pager_id)
    {
        $this->_component = 'org.openpsa.qbpager';
        if (empty($pager_id)) {
            throw new midcom_error('pager_id is not set (needed for distinguishing different instances on same request)');
        }

        $this->_pager_id = $pager_id;
        $this->_prefix = 'org_openpsa_qbpager_' . $pager_id . '_';
        $this->_prepare_qbs($classname);
    }

    protected function _prepare_qbs(string $classname)
    {
        $this->_midcom_qb = midcom::get()->dbfactory->new_query_builder($classname);
        // Make another QB for counting, we need to do this to avoid trouble with core internal references system
        $this->_midcom_qb_count = midcom::get()->dbfactory->new_query_builder($classname);
    }

    /**
     * Get the current page number
     */
    public function get_current_page() : int
    {
        return $this->_current_page;
    }

    /**
     * Fetch all $_GET variables
     */
    private function _get_query_string(string $page_var, int $page_number) : string
    {
        $query = [$page_var => $page_number];

        foreach ($_GET as $key => $value) {
            if (!in_array($key, [$page_var, ''])) {
                $query[$key] = $value;
            }
        }

        return '?' . http_build_query($query);
    }

    /**
     * Displays previous/next selector
     */
    function show_previousnext()

    {
        $page_count = $this->count_pages();
        //Skip the header in case we only have one page
        if ($page_count <= 1) {
            return;
        }
        //@todo Move to style element
        //TODO: "showing results (offset)-(offset+limit)
        $page_var = $this->_prefix . 'page';
        echo '<div class="org_openpsa_qbpager_previousnext">';

        if ($this->_current_page > 1) {
            $previous = $this->_current_page - 1;
            echo "\n<a class=\"previous_page\" href=\"" . $this->_get_query_string($page_var, $previous) . "\" rel=\"prev\">" . $this->_l10n->get($this->string_previous) . "</a>";
        }

        if ($this->_current_page < $page_count) {
            $next = $this->_current_page + 1;
            echo "\n<a class=\"next_page\" href=\"" . $this->_get_query_string($page_var, $next) . "\" rel=\"next\">" . $this->_l10n->get($this->string_next) . "</a>";
        }

        echo "\n</div>\n";
    }

    public function get_pages() : array
    {
        $pages = [];
        $page_count = $this->count_pages();

        if ($page_count < 1) {
            return $pages;
        }

        $page_var = $this->_prefix . 'page';
        $display_start = max(($this->_current_page - ceil($this->display_pages / 2)), 1);
        $display_end = min(($this->_current_page + ceil($this->display_pages / 2)), $page_count);

        if ($this->_current_page > 1) {
            $previous = $this->_current_page - 1;
            if ($previous > 1) {
                $pages[] = [
                    'class' => 'first',
                    'href' => $this->_get_query_string($page_var, 1),
                    'rel' => 'prev',
                    'label' => $this->_l10n->get('first'),
                    'number' => 1
                ];
            }
            $pages[] = [
                'class' => 'previous',
                'href' => $this->_get_query_string($page_var, $previous),
                'rel' => 'prev',
                'label' => $this->_l10n->get($this->string_previous),
                'number' => $previous
            ];
        }
        $page = $display_start - 1;
        while ($page++ < $display_end) {
            $href = false;
            if ($page != $this->_current_page) {
                $href = $this->_get_query_string($page_var, $page);
            }
            $pages[] = [
                'class' => 'current',
                'href' => $href,
                'rel' => false,
                'label' => $page,
                'number' => $page
            ];
        }

        if ($this->_current_page < $page_count) {
            $next = $this->_current_page + 1;
            $pages[] = [
                'class' => 'next',
                'href' => $this->_get_query_string($page_var, $next),
                'rel' => 'next',
                'label' => $this->_l10n->get($this->string_next),
                'number' => $next
            ];

            if ($next < $page_count) {
                $pages[] = [
                    'class' => 'last',
                    'href' => $this->_get_query_string($page_var, $page_count),
                    'href' => $this->_get_query_string($page_var, /** @scrutinizer ignore-type */ $page_count),
                    'rel' => 'next',
                    'label' => $this->_l10n->get('last'),
                    'number' => $page_count
                ];
            }
        }

        return $pages;
    }

    private function show(string $name, array $data)
    {
        $context = midcom_core_context::enter();
        $context->set_custom_key('request_data', $data);
        midcom::get()->style->prepend_component_styledir($this->_component);
        midcom::get()->style->enter_context($context);
        midcom_show_style('show_' . $name);
        midcom::get()->style->leave_context();
        midcom_core_context::leave();
    }

    /**
     * Displays page selector
     */
    public function show_pages()
    {
        $this->show('pages', ['pages' => $this->get_pages()]);
    }

    /**
     * Displays page selector as list
     */
    function show_pages_as_list()

    {
        $this->show('pages_as_list', ['pages' => $this->get_pages()]);
    }

    /**
     * Check $_REQUEST for variables and sets LIMIT and OFFSET for requested page
     */
    protected function _qb_limits($qb)
    {
        $page_var = $this->_prefix . 'page';
        if (!empty($_REQUEST[$page_var])) {
            debug_add("{$page_var} has value: {$_REQUEST[$page_var]}");
            $this->_current_page = max(1, (int) $_REQUEST[$page_var]);
        }
        if ($this->_current_page == 'all') {
            debug_add("displaying all results");
            return;
        }
        $results_var = $this->_prefix . 'results';
        if (!empty($_REQUEST[$results_var])) {
            debug_add("{$results_var} has value: {$_REQUEST[$results_var]}");
            $this->results_per_page = max(1, (int) $_REQUEST[$results_var]);
        }
        if ($this->results_per_page < 1) {
            throw new LogicException('results_per_page is set to ' . $this->results_per_page);
        }
        $this->_offset = ($this->_current_page - 1) * $this->results_per_page;
        $qb->set_limit($this->results_per_page);
        $qb->set_offset($this->_offset);
        debug_add("set offset to {$this->_offset} and limit to {$this->results_per_page}");
    }

    public function execute() : array
    {
        $this->_qb_limits($this->_midcom_qb);
        return $this->_midcom_qb->execute();
    }

    /**
     * Returns number of total pages for query
     *
     * By default returns a number of pages without any ACL checks
     */
    public function count_pages()
    {
        return ceil($this->count_unchecked() / $this->results_per_page);
    }

    //Rest of supported methods wrapped with extra sanity check
    public function add_constraint(string $param, string $op, $val) : bool
    {
        $this->_midcom_qb_count->add_constraint($param, $op, $val);
        return $this->_midcom_qb->add_constraint($param, $op, $val);
    }

    public function add_order(string $param, string $sort = 'ASC') : bool
    {
        return $this->_midcom_qb->add_order($param, $sort);
    }

    public function begin_group(string $type)
    {
        $this->_midcom_qb_count->begin_group($type);
        $this->_midcom_qb->begin_group($type);
    }

    public function end_group()
    {
        $this->_midcom_qb_count->end_group();
        $this->_midcom_qb->end_group();
    }

    public function include_deleted()
    {
        $this->_midcom_qb_count->include_deleted();
        $this->_midcom_qb->include_deleted();
    }

    public function count_unchecked() : int
    {
        if (!$this->count) {
            $this->count = $this->_midcom_qb_count->count_unchecked();
        }
        return $this->count;
    }
}

flack / openpsa

Push — master ( 0083f3...057072 )

org_openpsa_qbpager::execute_unchecked() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
