table_setter

Complexity

Total Complexity

65

Size/Duplication

Total Lines	243
Duplicated Lines	0 %

Importance

Changes	10
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	err()	0	7	3
B	attributes()	0	15	7
B	pagingJumps()	0	30	9
A	requestOrderCol()	0	8	3
A	requestExport()	0	4	2
B	filterValues()	0	14	7
A	view()	0	6	1
B	requestFilter()	0	24	9
A	requestOrderDir()	0	6	4
A	assets()	0	4	1
A	requestPage()	0	5	3
A	paging()	0	22	5
B	config()	0	42	11

<?php

class table_setter
{
    /** @param array Columns (config) */
    public static $cols;
    /** @param bool Export flag (for current request) */
    public static $export;
    /** @param array Collector (values for current table call) */
    protected static $t = ['page' => 1, 'tables' => []];
    /** @param array Re-settable values for current table call */
    protected static $config;
    /** @param array Errors collector */
    protected static $errors = [];

    static function assets($path = "/public/table")
    {
        return "<script src=\"{$path}/table.js\"></script>\n\t" .
                "<link href=\"{$path}/table.css\" rel=\"stylesheet\">\n";
    }

    /** Set/Get config value
     * @param mixed $c (string) Get if exists, (array) Set if valid
     * @return mixed */
    public static function config($c)
    {
        self::$config = self::$config ?: [
            'DB_COLLATION_CI' => 'utf8mb4_general_ci', //UTF8_GENERAL_CI
            'EMPTY_TABLE_MSG' => 'No results found.',
            'EXPORT_FILE_NAME' => ':app - :items export (:datetime)',
            'FILTER_CASE_SENSITIVE' => false,
            'SAVES' => ['CSV', 'Excel'],
            'UTF8_ASC_SYMBOL' => '&#9650;',
            'UTF8_DESC_SYMBOL' => '&#9660;',
            'UTF8_LEFT_SYMBOL' => '&lsaquo;',
            'UTF8_RIGHT_SYMBOL' => '&rsaquo;'
        ];

        $getValid = function($k, $v = null) {
            if (!array_key_exists($k, self::$config)) {
                throw new Exception('Request to undefined value: ' . $k);
            }

            if ($v !== null) {
                if (empty($v) || gettype($v) !== gettype(self::$config[$k])) {
                    throw new Exception("Setting invalid value: $v (:$k)");
                }
            }

            return $v === null ? self::$config[$k] : $v;
        };

        try {
            switch (gettype($c)) {
                case 'array';
                    foreach ($c as $k => $v) {
                        self::$config[$k] = $getValid((string) $k, $v);
                    }
                    break;
                case 'string':
                    return $getValid($c);
                default:
                    throw new Exception("Invalid value type.");
            }
        } catch (Exception $e) {
            self::err('ERROR: ' . $e->getMessage());
        }
    }

    protected static function err($message = null)
    {
        if (isset($message)) {
            self::$errors[] = $message;
        } else {
            return empty(self::$errors) ? null :
            '<p class="tbl-err">' . implode('</br>', self::$errors) . '</p>';
        }
    }

    /** Converts array to space separated key value list
     * @param array $attributes
     * @return string */
    protected static function attributes(array $attributes)
    {
        $list = [];
        foreach ($attributes as $key => $value) {
            if (is_bool($value)) {
                if ((bool) $value) {
                    $list[] = $key;
                }
            } else if (empty($value) && !is_int($value)) {
                $list[] = $key;
            } else {
                $list[] = $key . '="' . $value . '"';
            }
        }
        return (count($list) > 0 ? ' ' : '') . join(' ', $list);
    }

    /** Parses view to string
     * @param string $template
     * @param array $vars
     * @return string */
    protected static function view($template, $vars = [])
    {
        extract($vars);
        ob_start();
        require $template;
        return (string) ob_get_clean();
    }

    protected static function paging(&$v)
    {
        if (self::$t['pages'] > 1) {
            $v['pages'] = self::$t['pages'];
            $v['page'] = self::$t['page'];
            $v['jumpL'] = self::pagingJumps();
            $v['jumpR'] = self::pagingJumps();
            $v['arrowL'] = self::config('UTF8_LEFT_SYMBOL');
            $v['arrowR'] = self::config('UTF8_RIGHT_SYMBOL');

            $limit = 10;

            $v['start'] = $v['page'] > ($limit / 2) ?
                    ($v['page'] - $limit / 2) :
                    1;

            if ($v['page'] > ($v['pages'] - ($limit / 2))) {
                $v['final'] = $v['pages'];
            } else if ($v['page'] > ($limit / 2)) {
                $v['final'] = $v['start'] + $limit;
            } else {
                $v['final'] = $limit;
            }
        }
    }

    /** Jump links -1M|-100K|-10K|-1K|100|{paging}|100|+1K|+10K|+100K|+1M
     * @param string $html Code to show
     * @param null|int $m multiplier
     * @return string */
    protected static function pagingJumps($html = '', $m = null)
    {
        static $direction;

        if (is_null($m)) { //on self::createPaginationLinks() calls only
            $direction = !isset($direction) ? '-' : '+';
            $m = 100;
        }
        $jump2show = function($m) use ($direction) {
            if ($m >= 1000000) {
                return ($direction . ($m / 1000000) . "M");
            } else if ($m >= 1000) {
                return ($direction . ($m / 1000) . "K");
            } else {
                return ($direction . $m);
            }
        };
        $add = '<li class="jump"><a>' . $jump2show($m) . '</a></li>';

        if ($direction === '-') {
            $jump_exists = (self::$t['page'] - $m) > 0;
        } else {
            $jump_exists = (self::$t['page'] + $m) <= self::$t['pages'];
        }

        if ($jump_exists) {
            $html = $direction === '-' ? $add . $html : $html . $add;
        }

        return $jump_exists ? self::pagingJumps($html, ($m * 10)) : $html;
    }

    protected static function filterValues(&$f, &$opts = [])
    {
        $f = filter_input(INPUT_GET, 'filter', FILTER_SANITIZE_STRING) ?: null;

        $by = filter_input(INPUT_GET, 'filter-by', FILTER_VALIDATE_INT);
        foreach (self::$cols as $k => $v) {
            if (isset($v[2]['sort']) && $v[2]['sort'] === false) {
                continue;
            }
            if (empty($v)) {
                $v = [null];
            } // fix for column requested as []
            $selected = $by === $k ? ' selected' : null;
            $opts[] = "<option value=\"{$k}\"{$selected}>{$v[0]}</option>";
        }
    }

    protected static function requestFilter()
    {
        $filter = filter_input(INPUT_GET, 'filter') ?: false;
        if ($filter) {
            $by = filter_input(INPUT_GET, 'filter-by', FILTER_VALIDATE_INT);
            if ($by === false || is_null($by)) {
                $by = [];
                foreach (self::$cols as $v) {
                    if (isset($v[2]['sort']) && $v[2]['sort'] === false) {
                        continue;
                    }
                    $by[] = 'IFNULL(' . $v[1] . ', "")';
                }
                $by = 'CONCAT(' . implode(',', $by) . ')';
            } else {
                $by = self::$cols[$by][1];
            }
            $by = 'CONCAT(" ",' . $by . ', " ")';
            if (self::config('FILTER_CASE_SENSITIVE') !== true) {
                $by .= ' COLLATE ' . self::config('DB_COLLATION_CI');
            }
            $filter = $by . ' LIKE ' . '"%' . $filter . '%"';
        }
        return $filter;
    }

    protected static function requestOrderCol()
    {
        if (($col = filter_input(INPUT_GET, 'col', FILTER_VALIDATE_INT))) {
            return isset(self::$cols[$col][2]['sort']) ?
                    self::$cols[$col][2]['sort'] :
                    self::$cols[$col][1];
        }
        return self::$t['order']['col'];
    }

    protected static function requestOrderDir()
    {
        $reset = filter_has_var(INPUT_GET, 'col') ? 'asc' : null;
        return in_array(filter_input(INPUT_GET, 'ord'), ['asc', 'desc']) ?
                filter_input(INPUT_GET, 'ord') :
                ($reset ?: self::$t['order']['dir']);
    }

    protected static function requestExport()
    {
        $exp = filter_input(INPUT_GET, 'export', FILTER_SANITIZE_STRING);
        return in_array($exp, self::config('SAVES')) ? $exp : false;

It seems like self::config('SAVES') can also be of type null; however, parameter $haystack of in_array() does only seem to accept array, maybe add an additional type check?

    }

    protected static function requestPage()
    {
        return filter_has_var(INPUT_GET, 'pg') && self::$export == false ?
                (int) filter_input(INPUT_GET, 'pg', FILTER_SANITIZE_NUMBER_INT) :
                self::$t['page'];
    }
}