XoopstubeXoopstube

Complexity

Total Complexity

22

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	2
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getInstance()	0	11	2
A	getModule()	0	8	2
A	getConfig()	0	19	4
A	setConfig()	0	10	2
A	getHandler()	0	9	2
A	initModule()	0	11	4
A	initConfig()	0	6	1
A	initHandler()	0	5	1
A	addLog()	0	8	3

<?php
/*
 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.
 */
/**
 *  Xoopstube class
 *
 * @copyright       The XUUPS Project http://sourceforge.net/projects/xuups/
 * @license         http://www.fsf.org/copyleft/gpl.html GNU public license
 * @package         Xoopstube
 * @subpackage      Utils
 * @since           1.0
 * @author          trabis <lusopoemas@gmail.com>
 */
// defined('XOOPS_ROOT_PATH') || die('XOOPS Root Path not defined');

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

/**
 * Class XoopstubeXoopstube
 */
class XoopstubeXoopstube

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

{
    var $dirname;

The visibility should be declared for property $dirname.

    var $module;

The visibility should be declared for property $module.

    var $handler;

The visibility should be declared for property $handler.

    var $config;

The visibility should be declared for property $config.

    var $debug;

The visibility should be declared for property $debug.

    var $debugArray = array();

The visibility should be declared for property $debugArray.

    /**
     * @param $debug
     */
    protected function __construct($debug)
    {
        $this->debug   = $debug;
        $this->dirname = basename(dirname(__DIR__));
    }

    /**
     * @param bool $debug
     *
     * @return XoopstubeXoopstube
     */
    static function &getInstance($debug = false)
    {
        static $instance = false;
        if (!$instance) {
            $instance = new self($debug);
        }
//error_log("istance: [" . print_r($istance,true) . "]");

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

//phpinfo();
//debug_print_backtrace ();
        return $instance;
    }

    function &getModule()

The return type could not be reliably inferred; please add a @return annotation.

    {
        if ($this->module == null) {
            $this->initModule();
        }

        return $this->module;
    }

    /**
     * @param null $name
     *
     * @return null
     */
    function getConfig($name = null)

It is generally recommended to explicitly declare the visibility for methods.

    {
        if ($this->config == null) {
            $this->initConfig();
        }
        if (!$name) {
            $this->addLog("Getting all config");

            return $this->config;
        }
        if (!isset($this->config[$name])) {
            $this->addLog("ERROR :: CONFIG '{$name}' does not exist");

            return null;
        }
        $this->addLog("Getting config '{$name}' : " . print_r($this->config[$name], true));

        return $this->config[$name];
    }

    /**
     * @param null $name
     * @param null $value
     *
     * @return mixed
     */
    function setConfig($name = null, $value = null)

It is generally recommended to explicitly declare the visibility for methods.

    {
        if ($this->config == null) {
            $this->initConfig();
        }
        $this->config[$name] = $value;
        $this->addLog("Setting config '{$name}' : " . $this->config[$name]);

        return $this->config[$name];
    }

    /**
     * @param $name
     *
     * @return mixed
     */
    function &getHandler($name)
    {
        if (!isset($this->handler[$name . '_handler'])) {
            $this->initHandler($name);
        }
        $this->addLog("Getting handler '{$name}'");

        return $this->handler[$name . '_handler'];
    }

    function initModule()

It is generally recommended to explicitly declare the visibility for methods.

    {
        global $xoopsModule;

Use of global functionality is not recommended; it makes your code harder to test, and less reusable.

        if (isset($xoopsModule) && is_object($xoopsModule) && $xoopsModule->getVar('dirname') == $this->dirname) {
            $this->module = $xoopsModule;
        } else {
            $hModule      = xoops_gethandler('module');
            $this->module = $hModule->getByDirname($this->dirname);
        }
        $this->addLog('INIT MODULE');
    }

    function initConfig()

It is generally recommended to explicitly declare the visibility for methods.

    {
        $this->addLog('INIT CONFIG');
        $hModConfig   = xoops_gethandler('config');
        $this->config = $hModConfig->getConfigsByCat(0, $this->getModule()->getVar('mid'));
    }

    /**
     * @param $name
     */
    function initHandler($name)

It is generally recommended to explicitly declare the visibility for methods.

    {
        $this->addLog('INIT ' . $name . ' HANDLER');
        $this->handler[$name . '_handler'] = xoops_getModuleHandler($name, $this->dirname);
    }

    /**
     * @param $log
     */
    function addLog($log)

It is generally recommended to explicitly declare the visibility for methods.

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

    {
        if ($this->debug) {
            if (is_object($GLOBALS['xoopsLogger'])) {
                $GLOBALS['xoopsLogger']->addExtra($this->module->name(), $log);
            }
        }
    }
}

/**
 * Class WfdownloadsDownloadHandler
 */
class XoopstubeXoopstubeHandler 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.

{
    /**
     * @var WfdownloadsWfdownloads
     * @access public
     */
    public $xoopstube = null;

    /**
     * @param null|object $db
     */
    public function __construct(&$db)
    {
        parent::__construct($db, 'xoopstube_videos', 'XoopstubeXoopstube', 'lid', 'title');
        $this->xoopstube = XoopstubeXoopstube::getInstance();

It seems like \XoopstubeXoopstube::getInstance() of type object<XoopstubeXoopstube> is incompatible with the declared type object<WfdownloadsWfdownloads> of property $xoopstube.

    }

    /**
     * Get criteria for active videos
     *
     * @return CriteriaElement

Should the return type not be CriteriaCompo?

     */
    public function getActiveCriteria()
    {
        global $xoopsUser;

Use of global functionality is not recommended; it makes your code harder to test, and less reusable.

        $gperm_handler = xoops_gethandler('groupperm');

        $criteria = new CriteriaCompo(new Criteria('offline', false));
        $criteria->add(new Criteria('published', 0, '>'));
        $criteria->add(new Criteria('published', time(), '<='));
        $expiredCriteria = new CriteriaCompo(new Criteria('expired', 0));
        $expiredCriteria->add(new Criteria('expired', time(), '>='), 'OR');
        $criteria->add($expiredCriteria);
        // add criteria for categories that the user has permissions for
        $groups                   = is_object($xoopsUser) ? $xoopsUser->getGroups() : array(0 => XOOPS_GROUP_ANONYMOUS);
        $allowedDownCategoriesIds = $gperm_handler->getItemIds('XTubeCatPerm', $groups, $this->xoopstube->getModule()->mid());
        $criteria->add(new Criteria('cid', '(' . implode(',', $allowedDownCategoriesIds) . ')', 'IN'));

        return $criteria;
    }
}