XoopsModules25x / userlog

class/setting.php

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 31 and the first side effect is on line 22.

/*
 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.
*/
/**
 *  userlog module
 *
 * @copyright       XOOPS Project (https://xoops.org)
 * @license         GNU GPL 2 (http://www.gnu.org/licenses/old-licenses/gpl-2.0.html)
 * @package         userlog class
 * @since           1
 * @author          irmtfan (irmtfan@yahoo.com)
 * @author          XOOPS Project <www.xoops.org> <www.xoops.ir>
 */

defined('XOOPS_ROOT_PATH') || exit('Restricted access.');
require_once __DIR__ . '/../include/common.php';

xoops_loadLanguage('admin', USERLOG_DIRNAME);
xoops_load('XoopsFormLoader');

/**
 * Class UserlogSetting
 */
class UserlogSetting extends XoopsObject

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    /**
     * @var string
     */
    public $all_logby = ['uid' => _AM_USERLOG_UID, 'gid' => _AM_USERLOG_SET_GID, 'ip' => _AM_USERLOG_SET_IP];

    public $userlog = null;

    /**
     * constructor
     */
    public function __construct()
    {
        $this->userlog = Userlog::getInstance();
        $this->initVar('set_id', XOBJ_DTYPE_INT, null, false);
        $this->initVar('name', XOBJ_DTYPE_TXTBOX, null, false, 100);
        $this->initVar('logby', XOBJ_DTYPE_TXTBOX, null, true, 10);
        $this->initVar('unique_id', XOBJ_DTYPE_INT, null, false);
        $this->initVar('options', XOBJ_DTYPE_TXTAREA, '', false);
        $this->initVar('scope', XOBJ_DTYPE_TXTAREA, '', false);
    }

    /**
     * @param string $method
     * @param array  $args
     *
     * @return mixed
     */
    public function __call($method, $args)
    {
        $arg = isset($args[0]) ? $args[0] : null;

        return $this->getVar($method, $arg);
    }

    /**
     * @return UserlogSetting
     */
    public static function getInstance()
    {
        static $instance;
        if (null === $instance) {
            $instance = new static();
        }

        return $instance;
    }

    /**
     * @return mixed|string
     */
    public function unique_id()
    {
        if ('ip' === $this->getVar('logby')) {
            return long2ip($this->getVar('unique_id'));
        }

        return $this->getVar('unique_id');
    }

    /**
     * @param bool $force
     *
     * @return bool
     */
    public function storeSet($force = true)
    {
        if ($this->setDb(true)) {
            // use $this->getVar('unique_id') (int ip) instead of $this->unique_id() (string ip)

46% of this comment could be valid code. Did you maybe forget this after debugging?

            if ($this->setFile($this->logby(), $this->getVar('unique_id'), [$this->options(), $this->scope()])) {
                return true;
            }
        }

        return false;
    }

    /**
     * @return array|bool
     */
    public function getSet()
    {
        $options = '';

$options is not used, you could remove the assignment.

        // if uid setting exist in File
        $unique_uid = $this->userlog->getUser() ? $this->userlog->getUser()->getVar('uid') : 0;
        if ($options = $this->getFile('uid', $unique_uid)) {
            return $options;
        }

        // if gid setting exist in File
        $unique_gid = $this->userlog->getUser() ? $this->userlog->getUser()->getGroups() : [XOOPS_GROUP_ANONYMOUS];
        foreach ($unique_gid as $gid) {
            if ($options = $this->getFile('gid', $gid)) {
                return $options;
            }
        }
        // if ip setting exist in File
        $unique_ip = XoopsUserUtility::getIP(); // ip as int
        if ($options = $this->getFile('ip', $unique_ip)) {
            return $options;
        }
        // if all exist in File
        if ($options = $this->getFile('all', 0)) {
            return $options;
        }
        ///////////////////////////////////////////////////////////
        // check probability
        if (!$this->userlog->probCheck($this->userlog->getConfig('probset'))) {
            return false;
        }
        // database get All is better for performance???
        $logsetsObj = $this->userlog->getHandler('setting')->getAll();
        if (empty($logsetsObj)) {
            return false;
        } // if not set in db return false
        $uid_unique_uid = 'uid' . $unique_uid;
        foreach ($unique_gid as $key => $gid) {
            $gid_unique_gid[$key] = 'gid' . $gid;

$gid_unique_gid was never initialized. Although not strictly required by PHP, it is generally a good practice to add $gid_unique_gid = array(); before regardless.

        }
        $ip_unique_ip = 'ip' . $unique_ip;
        foreach ($logsetsObj as $setObj) {
            $sLogby     = $setObj->logby();
            $sUnique_id = $setObj->getVar('unique_id');
            $sLogbyId   = $sLogby . $sUnique_id;
            // if uid setting exist in db return it
            if ($sLogbyId == $uid_unique_uid
                || // if gid setting exist in db return it
                in_array($sLogbyId, $gid_unique_gid)

The variable $gid_unique_gid does not seem to be defined for all execution paths leading up to this point.

                || // if ip setting exist in db return it
                $sLogbyId == $ip_unique_ip
            ) {
                $sets = [$setObj->options(), $setObj->scope()];
                $this->setFile($sLogby, $sUnique_id, $sets); // build cache

                return $sets;
            }
            // if all exist in db
            if (0 == $sUnique_id) {
                $sets = [$setObj->options(), $setObj->scope()];
                $this->setFile('all', 0, $sets); // build cache

                return $sets;
            }
        }

        return false;
    }

    /**
     * @param bool $force
     *
     * @return mixed
     */
    public function setDb($force = true)
    {
        $ret = $this->userlog->getHandler('setting')->insert($this, $force);
        $this->unsetNew();

        return $ret;
    }

    public function getDb()
    {
    }

    /**
     * @param string $logby
     * @param        $unique_id
     * @param        $options
     *
     * @return bool
     */
    public function setFile($logby = 'uid', $unique_id, $options)
    {
        return $this->_createCacheFile($options, "setting_{$logby}_{$unique_id}");
    }

    /**
     * @param string $logby
     * @param        $unique_id
     *
     * @return bool|mixed
     */
    public function getFile($logby = 'uid', $unique_id)
    {
        return $this->_loadCacheFile("setting_{$logby}_{$unique_id}");
    }

    /**
     * @param string $logby
     * @param        $unique_id
     *
     * @return bool
     */
    public function deleteFile($logby = 'uid', $unique_id)
    {
        return $this->_deleteCacheFile("setting_{$logby}_{$unique_id}");
    }

    /**
     * @param        $data
     * @param null   $name
     * @param string $root_path
     *
     * @return bool
     */
    private function _createCacheFile($data, $name = null, $root_path = XOOPS_CACHE_PATH)
    {
        $name = $name ?: (string)time();
        $key  = USERLOG_DIRNAME . "_{$name}";

        //$cacheHandler = XoopsCache::config($key, array('path' => XOOPS_VAR_PATH . '/caches/xoops_cache/userlog'));

52% of this comment could be valid code. Did you maybe forget this after debugging?

        return XoopsCache::write($key, $data);
    }

    /**
     * @param null   $name
     * @param string $root_path
     *
     * @return bool|mixed
     */
    private function _loadCacheFile($name = null, $root_path = XOOPS_CACHE_PATH)

This method seems to be duplicated in your project.

    {
        if (empty($name)) {
            return false;
        }
        $key = USERLOG_DIRNAME . "_{$name}";

        return XoopsCache::read($key);
    }

    /**
     * @param null   $name
     * @param string $root_path
     *
     * @return bool
     */
    private function _deleteCacheFile($name = null, $root_path = XOOPS_CACHE_PATH)

This method seems to be duplicated in your project.

    {
        if (empty($name)) {
            return false;
        }
        $key = USERLOG_DIRNAME . "_{$name}";

        return XoopsCache::delete($key);
    }

    /**
     * @param null   $option
     * @param string $V
     *
     * @return array
     */
    public function getOptions($option = null, $V = 'value')

getOptions uses the super-global variable $_SERVER which is generally not recommended.

getOptions uses the super-global variable $GLOBALS which is generally not recommended.

getOptions uses the super-global variable $_GET which is generally not recommended.

getOptions uses the super-global variable $_POST which is generally not recommended.

getOptions uses the super-global variable $_REQUEST which is generally not recommended.

getOptions uses the super-global variable $_FILES which is generally not recommended.

getOptions uses the super-global variable $_ENV which is generally not recommended.

getOptions uses the super-global variable $_SESSION which is generally not recommended.

getOptions uses the super-global variable $_COOKIE which is generally not recommended.

    {
        $V = strtolower($V);

        if ($this->userlog->getUser()) {
            $uid        = $this->userlog->getUser()->getVar('uid');
            $uname      = $this->userlog->getUser()->getVar('uname');
            $last_login = $this->userlog->getUser()->getVar('last_login');
            $admin      = $this->userlog->getUser()->isAdmin();
            $groups     = 'g' . implode('g', array_unique($this->userlog->getUser()->getGroups())); // g1g2
        } else {
            $uid        = 0;
            $uname      = '';
            $last_login = 0;
            $admin      = 0;
            $groups     = 'g' . XOOPS_GROUP_ANONYMOUS; // g3
        }
        $tempUserLog = explode('/', $_SERVER['PHP_SELF']);
        $options = [
            'log_id'         => [
                'type'  => 'int',
                'title' => _AM_USERLOG_LOG_ID,
                'value' => null // null for now
            ],
            'log_time'       => [
                'type'  => 'int',
                'title' => _AM_USERLOG_LOG_TIME,
                'value' => time()
            ],
            'uid'            => [
                'type'  => 'int',
                'title' => _AM_USERLOG_UID,
                'value' => $uid
            ],
            'uname'          => [
                'type'  => 'text',
                'title' => _AM_USERLOG_UNAME,
                'value' => $uname
            ],
            'admin'          => [
                'type'  => 'bool',
                'title' => _AM_USERLOG_ADMIN,
                'value' => $admin
            ],
            'groups'         => [
                'type'  => 'text',
                'title' => _AM_USERLOG_GROUPS,
                'value' => $groups
            ],
            'last_login'     => [
                'type'  => 'int',
                'title' => _AM_USERLOG_LAST_LOGIN,
                'value' => $last_login
            ],
            'user_ip'        => [
                'type'  => 'text',
                'title' => _AM_USERLOG_USER_IP,
                'value' => $_SERVER['REMOTE_ADDR']
            ],
            'user_agent'     => [
                'type'  => 'text',
                'title' => _AM_USERLOG_USER_AGENT,
                'value' => $_SERVER['HTTP_USER_AGENT']
            ],
            'url'            => [
                'type'  => 'text',
                'title' => _AM_USERLOG_URL,
                'value' => $_SERVER['REQUEST_URI']
            ],
            'script'         => [
                'type'  => 'text',
                'title' => _AM_USERLOG_SCRIPT,
                'value' => end($tempUserLog)
            ],
            'referer'        => [
                'type'  => 'text',
                'title' => _AM_USERLOG_REFERER,
                'value' => !empty($_SERVER['HTTP_REFERER']) ? $_SERVER['HTTP_REFERER'] : ''
            ],
            'pagetitle'      => [
                'type'  => 'text',
                'title' => _AM_USERLOG_PAGETITLE,
                'value' => isset($GLOBALS['xoopsTpl']) ? $GLOBALS['xoopsTpl']->get_template_vars('xoops_pagetitle') : ''
            ],
            'pageadmin'      => [
                'type'  => 'bool',
                'title' => _AM_USERLOG_PAGEADMIN,
                'value' => (isset($GLOBALS['xoopsOption']['pagetype'])
                            && 'admin' === $GLOBALS['xoopsOption']['pagetype']) ? 1 : 0
            ],
            'module'         => [
                'type'  => 'text',
                'title' => _AM_USERLOG_MODULE,
                'value' => $this->userlog->getLogModule()->getVar('dirname')
            ],
            'module_name'    => [
                'type'  => 'text',
                'title' => _AM_USERLOG_MODULE_NAME,
                'value' => $this->userlog->getLogModule()->getVar('name')
            ],
            'item_name'      => [
                'type'  => 'text',
                'title' => _AM_USERLOG_ITEM_NAME,
                'value' => null
            ],
            'item_id'        => [
                'type'  => 'int',
                'title' => _AM_USERLOG_ITEM_ID,
                'value' => null
            ],
            // user data input method
            'request_method' => [
                'type'  => 'text',
                'title' => _AM_USERLOG_REQUEST_METHOD,
                'value' => $_SERVER['REQUEST_METHOD']
            ],
            'zget'           => [
                'type'  => 'text',
                'title' => _AM_USERLOG_GET,
                'value' => $_GET
            ],
            'post'           => [
                'type'  => 'text',
                'title' => _AM_USERLOG_POST,
                'value' => $_POST
            ],
            'request'        => [
                'type'  => 'text',
                'title' => _AM_USERLOG_REQUEST,
                'value' => $_REQUEST
            ],
            'files'          => [
                'type'  => 'text',
                'title' => _AM_USERLOG_FILES,
                'value' => $_FILES
            ],
            'env'            => [
                'type'  => 'text',
                'title' => _AM_USERLOG_ENV,
                'value' => $_ENV
            ],
            'session'        => [
                'type'  => 'text',
                'title' => _AM_USERLOG_SESSION,
                'value' => $_SESSION
            ],
            'cookie'         => [
                'type'  => 'text',
                'title' => _AM_USERLOG_COOKIE,
                'value' => $_COOKIE
            ],
            'header'         => [
                'type'  => 'text',
                'title' => _AM_USERLOG_HEADER,
                'value' => headers_list()
            ],
            'logger'         => [
                'type'  => 'text',
                'title' => _AM_USERLOG_LOGGER,
                'value' => $GLOBALS['xoopsLogger']->errors
            ],
            // settings will not be logged
            'active'         => [
                'type'  => 'int',
                'title' => _AM_USERLOG_SET_ACTIVE,
                'value' => 1
            ],
            'inside'         => [
                'type'  => 'int',
                'title' => _AM_USERLOG_INSIDE,
                'value' => 1
            ],
            'outside'        => [
                'type'  => 'int',
                'title' => _AM_USERLOG_OUTSIDE,
                'value' => 1
            ],
            'unset_pass'     => [
                'type'  => 'int',
                'title' => _AM_USERLOG_UNSET_PASS,
                'value' => 1
            ],
            'store_file'     => [
                'type'  => 'int',
                'title' => _AM_USERLOG_STORE_FILE,
                'value' => 1
            ],
            'store_db'       => [
                'type'  => 'int',
                'title' => _AM_USERLOG_STORE_DB,
                'value' => 1
            ],
            'views'          => [
                'type'  => 'int',
                'title' => _AM_USERLOG_VIEWS,
                'value' => 1 // for item_name and item_id
            ]
        ];
        $ret     = $this->userlog->getFromKeys($options, $option);
        // patch Login/Register History
        if (isset($ret['post']['value'])) {
            $ret['post']['value'] = $this->userlog->patchLoginHistory($ret['post']['value'], $uid, !empty($ret['unset_pass']['value']));

Are you sure the assignment to $ret['post']['value'] is correct as $this->userlog->patchLoginHistory($ret['post']['value'], $uid, !empty($ret['unset_pass']['value'])) (which targets Userlog::patchLoginHistory()) seems to always return null.

        }
        if (empty($V)) {
            return $ret;
        }
        if ('key' === $V) {
            return array_keys($ret);
        }
        $ret2     = [];
        $emptyAll = 'value' === $V; // check if all values are empty
        foreach ($ret as $option => $val) {
            $ret2[$option] = $val[$V];
            // if there is a value || exceptions continue
            if (!$emptyAll
                || in_array($option, [
                    'log_id',
                    'log_time',
                    'active',
                    'inside',
                    'outside',
                    'unset_pass',
                    'store_file',
                    'store_db',
                    'views'
                ])
            ) {
                continue;
            }
            // check values
            if (!empty($val[$V])) {
                $emptyAll = false;
            }
        }

        return $emptyAll ? [] : $ret2;
    }

    /**
     * @param null $options
     *
     * @return array
     */
    public function logForm($options = null)
    {
        $form    = new XoopsThemeForm(_AM_USERLOG_LOGFORM, 'logs', 'logs.php', 'get');
        $headers = $this->getOptions('', 'title');
        unset($headers['active'], $headers['inside'], $headers['outside'], $headers['unset_pass'], $headers['store_db'], $headers['store_file'], $headers['views']);
        $el          = [];
        $query_types = ['=' => '', '>' => 'GT', '<' => 'LT'];
        foreach ($headers as $ele => $def) {
            switch ($ele) {
                case 'pageadmin':
                case 'admin':
                    $defEl    = '_AM_USERLOG_' . strtoupper($ele); // if constant is defined in translation - it is good for now
                    $el[$ele] = new XoopsFormRadio(constant($defEl), "options[{$ele}]", isset($options[$ele]) ? $options[$ele] : '');
                    $el[$ele]->addOption(1, _YES);
                    $el[$ele]->addOption(0, _NO);
                    $el[$ele]->addOption('', _ALL);
                    $el[$ele]->setDescription(constant($defEl . '_FORM'));
                    $form->addElement($el[$ele]);
                    break;
                default:
                    foreach ($query_types as $type) {
                        $defEl = '_AM_USERLOG_' . strtoupper($ele . $type); // if constant is defined in translation - it is good for now
                        if (defined($defEl . '_FORM')) {
                            $el[$ele . $type] = new XoopsFormText(constant($defEl), "options[{$ele}{$type}]", 10, 255, !empty($options[$ele . $type]) ? $options[$ele . $type] : null);
                            $defEle           = '_AM_USERLOG_' . strtoupper($ele);
                            $el[$ele . $type]->setDescription(sprintf(constant($defEl . '_FORM'), constant($defEle), constant($defEle)));
                            $form->addElement($el[$ele . $type]);
                        }
                    }
                    break;
            }
        }
        // http://stackoverflow.com/questions/8029532/how-to-prevent-submitting-the-html-forms-input-field-value-if-it-empty
        // http://stackoverflow.com/questions/2617480/how-to-get-all-elements-which-name-starts-with-some-string
        $el['log_id']->customValidationCode[] = "preventSubmitEmptyInput('options[');"; // check all input tags

        return [$form, $el, $headers];
    }

    /**
     * @return int
     */
    public function cleanCache()
    {
        $files = glob(XOOPS_VAR_PATH . '/caches/xoops_cache/*' . USERLOG_DIRNAME . '*.*');
        foreach ($files as $filename) {
            unlink($filename);
        }

        return count($files);
    }
}

/**
 * Class UserlogSettingHandler
 */
class UserlogSettingHandler extends XoopsPersistableObjectHandler

PSR1 recommends that each class should be in its own file to aid autoloaders.

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    public $userlog = null;

    /**
     * @param null|XoopsDatabase $db
     */
    public function __construct(XoopsDatabase $db)
    {
        $this->userlog = Userlog::getInstance();
        parent::__construct($db, USERLOG_DIRNAME . '_set', 'UserlogSetting', 'set_id', 'logby');
    }

    /**
     * @param int    $limit
     * @param int    $start
     * @param null   $otherCriteria
     * @param string $sort
     * @param string $order
     * @param null   $fields
     * @param bool   $asObject
     * @param bool   $id_as_key
     *
     * @return mixed
     */
    public function getSets(

This method seems to be duplicated in your project.

        $limit = 0,
        $start = 0,
        $otherCriteria = null,
        $sort = 'set_id',
        $order = 'DESC',
        $fields = null,
        $asObject = true,
        $id_as_key = true
    ) {
        $criteria = new CriteriaCompo();
        if (!empty($otherCriteria)) {
            $criteria->add($otherCriteria);
        }
        $criteria->setLimit($limit);
        $criteria->setStart($start);
        $criteria->setSort($sort);
        $criteria->setOrder($order);
        $ret = $this->getAll($criteria, $fields, $asObject, $id_as_key);

        return $ret;
    }
}