XoopsLocalAbstract

Complexity

Total Complexity

68

Size/Duplication

Total Lines	291
Duplicated Lines	0 %

Importance

Changes	4
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	substr()	0	12	6
A	number_format()	0	3	1
A	getTimeFormatDesc()	0	3	1
C	convert_encoding()	0	46	13
A	__call()	0	6	2
F	formatTimestamp()	0	91	31
A	utf8_encode()	0	16	6
A	utf8_decode()	0	15	6
A	money_format()	0	3	1
A	trim()	0	5	1

<?php
/**
 * XOOPS localization abstract
 *
 * You may not change or alter any portion of this comment or credits
 * of supporting developers from this source code or any supporting source code
 * which is considered copyrighted (c) material of the original comment or credit authors.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * @copyright       (c) 2000-2016 XOOPS Project (www.xoops.org)
 * @license             GNU GPL 2 (https://www.gnu.org/licenses/gpl-2.0.html)
 * @package             kernel
 * @since               2.3.0
 * @author              Taiwen Jiang <phppp@users.sourceforge.net>
 */

defined('XOOPS_ROOT_PATH') || exit('Restricted access');

/**
 * Class XoopsLocalAbstract
 */
class XoopsLocalAbstract
{
    /**
     * XoopsLocalAbstract::substr()
     *
     * @param mixed  $str
     * @param mixed  $start
     * @param mixed  $length
     * @param string $trimmarker
     *
     * @return mixed|string
     */
    public static function substr($str, $start, $length, $trimmarker = '...')
    {
        if (!XOOPS_USE_MULTIBYTES) {
            return (strlen($str) - $start <= $length) ? substr($str, $start, $length) : substr($str, $start, $length - strlen($trimmarker)) . $trimmarker;
        }
        if (function_exists('mb_internal_encoding') && @mb_internal_encoding(_CHARSET)) {
            $str2 = mb_strcut($str, $start, $length - strlen($trimmarker));

            return $str2 . (mb_strlen($str) != mb_strlen($str2) ? $trimmarker : '');
        }

        return $str;
    }

    // Each local language should define its own equivalent utf8_encode
    /**
     * XoopsLocalAbstract::utf8_encode()
     *
     * @param  mixed $text
     * @return string
     */
    public static function utf8_encode($text)
    {
        if (defined('XOOPS_USE_MULTIBYTES') && 1 === (int)XOOPS_USE_MULTIBYTES) {
            if (function_exists('mb_convert_encoding')) {
                $converted_text = mb_convert_encoding($text, 'UTF-8', 'auto');
                if ($converted_text !== false && !is_array($converted_text)) {
                    return $converted_text;
                } else {
                    // Handle the failure case, maybe log an error or return the original text
                    return $text;
                }

            }
        }

        return utf8_encode($text);
    }

    // Each local language should define its own equivalent utf8_decode
    /**
     * XoopsLocalAbstract::utf8_decode()
     *
     * @param  mixed $text
     * @return string
     */
    public static function utf8_decode($text)
    {
        if (defined('XOOPS_USE_MULTIBYTES') && 1 === (int)XOOPS_USE_MULTIBYTES) {
            if (function_exists('mb_convert_encoding')) {
                $converted_text = mb_convert_encoding($text, 'ISO-8859-1', 'auto');
                if ($converted_text !== false && !is_array($converted_text)) {
                    return $converted_text;
                } else {
                    // Handle the failure case, maybe log an error or return the original text
                    return $text;
                }
            }
        }

        return utf8_decode($text);
    }

    /**
     * XoopsLocalAbstract::convert_encoding()
     *
     * @param  mixed  $text
     * @param  string $to
     * @param  string $from
     * @return mixed|string
     */
    public static function convert_encoding($text, $to = 'utf-8', $from = '')
    {
        // Early exit if the text is empty
        if (empty($text)) {
            return $text;
        }

        // Set default $from encoding if not provided
        if (empty($from)) {
            $from = empty($GLOBALS['xlanguage']['charset_base']) ? _CHARSET : $GLOBALS['xlanguage']['charset_base'];
        }

        // If $to and $from are the same, no conversion is needed
        if (empty($to) || !strcasecmp($to, $from)) {
            return $text;
        }

        // Initialize a variable to store the converted text
        $convertedText = '';

        // Try to use mb_convert_encoding if available
        if (XOOPS_USE_MULTIBYTES && function_exists('mb_convert_encoding')) {
            $convertedText = mb_convert_encoding($text, $to, $from);
            if (false !== $convertedText) {
                return $convertedText;
            }
        }

        // Try to use iconv if available
        if (function_exists('iconv')) {
            $convertedText = iconv($from, $to . '//TRANSLIT', $text);
            if (false !== $convertedText) {
                return $convertedText;
            }
        }

        // Try to use utf8_encode if target encoding is 'utf-8'
        if ('utf-8' === $to) {
            $convertedText = utf8_encode($text);
            if (false !== $convertedText) {
                return $convertedText;
            }
        }

        // If all conversions fail, return the original text
        return $text;
        
    }

    /**
     * XoopsLocalAbstract::trim()
     *
     * @param  mixed $text
     * @return string
     */
    public static function trim($text)
    {
        $ret = trim($text);

        return $ret;
    }

    /**
     * Get description for setting time format
     */
    public static function getTimeFormatDesc()
    {
        return _TIMEFORMAT_DESC;
    }

    /**
     * Function to display formatted times in user timezone
     *
     * Setting $timeoffset to null (by default) will skip timezone calculation for user, using default timezone instead, which is a MUST for cached contents
     * @param        $time
     * @param string $format
     * @param null|string   $timeoffset
     * @return string
     */
    public static function formatTimestamp($time, $format = 'l', $timeoffset = null)
    {
        global $xoopsConfig, $xoopsUser;

        $format_copy = $format;
        $format      = strtolower($format);

        if ($format === 'rss' || $format === 'r') {
            $TIME_ZONE = '';
            if (isset($GLOBALS['xoopsConfig']['server_TZ'])) {
                $server_TZ = abs((int)($GLOBALS['xoopsConfig']['server_TZ'] * 3600.0));
                $prefix    = ($GLOBALS['xoopsConfig']['server_TZ'] < 0) ? ' -' : ' +';
                $TIME_ZONE = $prefix . date('Hi', $server_TZ);

It seems like $server_TZ can also be of type double; however, parameter $timestamp of date() does only seem to accept integer|null, maybe add an additional type check?

            }
            $date = gmdate('D, d M Y H:i:s', (int)$time) . $TIME_ZONE;

            return $date;
        }

        if (($format === 'elapse' || $format === 'e') && $time < time()) {
            $elapse = time() - $time;
            if ($days = floor($elapse / (24 * 3600))) {
                $num = $days > 1 ? sprintf(_DAYS, $days) : _DAY;
            } elseif ($hours = floor(($elapse % (24 * 3600)) / 3600)) {
                $num = $hours > 1 ? sprintf(_HOURS, $hours) : _HOUR;
            } elseif ($minutes = floor(($elapse % 3600) / 60)) {
                $num = $minutes > 1 ? sprintf(_MINUTES, $minutes) : _MINUTE;
            } else {
                $seconds = $elapse % 60;
                $num     = $seconds > 1 ? sprintf(_SECONDS, $seconds) : _SECOND;
            }
            $ret = sprintf(_ELAPSE, $num);

            return $ret;
        }
        // disable user timezone calculation and use default timezone,
        // for cache consideration
        if ($timeoffset === null) {
            $timeoffset = ($xoopsConfig['default_TZ'] == '') ? '0.0' : $xoopsConfig['default_TZ'];
        }
        $usertimestamp = xoops_getUserTimestamp($time, $timeoffset);
        switch ($format) {
            case 's':
                $datestring = _SHORTDATESTRING;
                break;

            case 'm':
                $datestring = _MEDIUMDATESTRING;
                break;

            case 'mysql':
                $datestring = 'Y-m-d H:i:s';
                break;

            case 'l':
                $datestring = _DATESTRING;
                break;

            case 'c':
            case 'custom':
                static $current_timestamp, $today_timestamp, $monthy_timestamp;
                if (!isset($current_timestamp)) {
                    $current_timestamp = xoops_getUserTimestamp(time(), $timeoffset);
                }
                if (!isset($today_timestamp)) {
                    $today_timestamp = mktime(0, 0, 0, date('m', $current_timestamp), date('d', $current_timestamp), date('Y', $current_timestamp));

date('m', $current_timestamp) of type string is incompatible with the type integer expected by parameter $month of mktime().

date('d', $current_timestamp) of type string is incompatible with the type integer expected by parameter $day of mktime().

date('Y', $current_timestamp) of type string is incompatible with the type integer expected by parameter $year of mktime().

                }

                if (abs($elapse_today = $usertimestamp - $today_timestamp) < 24 * 60 * 60) {
                    $datestring = ($elapse_today > 0) ? _TODAY : _YESTERDAY;
                } else {
                    if (!isset($monthy_timestamp)) {
                        $monthy_timestamp[0] = mktime(0, 0, 0, 0, 0, date('Y', $current_timestamp));
                        $monthy_timestamp[1] = mktime(0, 0, 0, 0, 0, date('Y', $current_timestamp) + 1);
                    }
                    $datestring = _YEARMONTHDAY;
                    if ($usertimestamp >= $monthy_timestamp[0] && $usertimestamp < $monthy_timestamp[1]) {
                        $datestring = _MONTHDAY;
                    }
                }
                break;

            default:
                $datestring = _DATESTRING;
                if ($format != '') {
                    $datestring = $format_copy;
                }
                break;
        }

        return ucfirst(date($datestring, $usertimestamp));
    }

    /**
     * XoopsLocalAbstract::number_format()
     *
     * @param  mixed $number
     * @return mixed
     */
    public function number_format($number)
    {
        return $number;
    }

    /**
     * XoopsLocalAbstract::money_format()
     *
     * @param  mixed $format
     * @param  mixed $number
     * @return mixed
     */
    public function money_format($format, $number)
    {
        return $number;
    }

    /**
     * XoopsLocalAbstract::__call()
     *
     * @param  mixed $name
     * @param  mixed $args
     * @return mixed
     */
    public function __call($name, $args)
    {
        if (function_exists($name)) {
            return call_user_func_array($name, $args);
        }
        return null;
    }
}