OledrionOledrion_catHandler

Complexity

Total Complexity

19

Size/Duplication

Total Lines	178
Duplicated Lines	5.62 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getAllCategories()	0	19	1
B	_makeLi()	0	15	5
A	getUlMenu()	0	15	2
A	deleteCategory()	0	8	1
A	getCategoryProductsCount()	0	21	4
A	getCategoriesFromIds()	10	10	3
A	getMotherCategories()	0	9	1
A	getCategoriesCount()	0	6	1

<?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 29 and the first side effect is on line 24.

/*
 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.
*/

/**
 * oledrion
 *
 * @copyright   {@link http://xoops.org/ XOOPS Project}
 * @license     {@link http://www.fsf.org/copyleft/gpl.html GNU public license}
 * @author      Hervé Thouzard (http://www.herve-thouzard.com/)
 */

/**
 * Gestion des catégories de produits
 */

require __DIR__ . '/classheader.php';

/**
 * Class Oledrion_cat
 */
class Oledrion_cat extends Oledrion_Object

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

{
    /**
     * constructor
     *
     * normally, this is called from child classes only
     *
     * @access public
     */
    public function __construct()
    {
        $this->initVar('cat_cid', XOBJ_DTYPE_INT, null, false);
        $this->initVar('cat_pid', XOBJ_DTYPE_INT, null, false);
        $this->initVar('cat_title', XOBJ_DTYPE_TXTBOX, null, false);
        $this->initVar('cat_imgurl', XOBJ_DTYPE_TXTBOX, null, false);
        $this->initVar('cat_description', XOBJ_DTYPE_TXTAREA, null, false);
        $this->initVar('cat_advertisement', XOBJ_DTYPE_TXTAREA, null, false);
        $this->initVar('cat_metakeywords', XOBJ_DTYPE_TXTBOX, null, false);
        $this->initVar('cat_metadescription', XOBJ_DTYPE_TXTBOX, null, false);
        $this->initVar('cat_metatitle', XOBJ_DTYPE_TXTBOX, null, false);
        $this->initVar('cat_footer', XOBJ_DTYPE_TXTAREA, null, false);
        // Pour autoriser le html
        $this->initVar('dohtml', XOBJ_DTYPE_INT, 1, false);
    }

    /**
     * Retourne l'URL de l'image de la catégorie courante
     * @return string L'URL
     */
    public function getPictureUrl()
    {
        return OLEDRION_PICTURES_URL . '/' . $this->getVar('cat_imgurl');
    }

    /**
     * Retourne le chemin de l'image de la catégorie courante
     * @return string Le chemin
     */
    public function getPicturePath()
    {
        return OLEDRION_PICTURES_PATH . '/' . $this->getVar('cat_imgurl');
    }

    /**
     * Indique si l'image de la catégorie existe
     *
     * @return boolean Vrai si l'image existe sinon faux
     */
    public function pictureExists()

This method seems to be duplicated in your project.

    {
        $return = false;
        if (xoops_trim($this->getVar('cat_imgurl')) != ''
            && file_exists(OLEDRION_PICTURES_PATH . '/' . $this->getVar('cat_imgurl'))
        ) {
            $return = true;
        }

        return $return;
    }

    /**
     * Supprime l'image associée à une catégorie
     * @return void
     */
    public function deletePicture()

This method seems to be duplicated in your project.

    {
        if ($this->pictureExists()) {
            @unlink(OLEDRION_PICTURES_PATH . '/' . $this->getVar('cat_imgurl'));

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

        }
        $this->setVar('cat_imgurl', '');
    }

    /**
     * Retourne l'url à utiliser pour accéder à la catégorie en tenant compte des préférences du module
     *
     * @return string L'url à utiliser
     */
    public function getLink()

This method seems to be duplicated in your project.

    {
        include_once XOOPS_ROOT_PATH . '/modules/oledrion/include/common.php';
        $url = '';

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

        if (Oledrion_utils::getModuleOption('urlrewriting') == 1) { // On utilise l'url rewriting
            $url = OLEDRION_URL . 'category-' . $this->getVar('cat_cid') . Oledrion_utils::makeSeoUrl($this->getVar('cat_title', 'n')) . '.html';
        } else { // Pas d'utilisation de l'url rewriting
            $url = OLEDRION_URL . 'category.php?cat_cid=' . $this->getVar('cat_cid');
        }

        return $url;
    }

    /**
     * Rentourne la chaine à envoyer dans une balise <a> pour l'attribut href
     *
     * @return string
     */
    public function getHrefTitle()
    {
        return Oledrion_utils::makeHrefTitle($this->getVar('cat_title'));
    }

    /**
     * Retourne les éléments du produits formatés pour affichage
     *
     * @param  string $format
     * @return array
     */
    public function toArray($format = 's')
    {
        $ret                     = array();

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

        $ret                     = parent::toArray($format);
        $ret['cat_full_imgurl']  = $this->getPictureUrl();
        $ret['cat_href_title']   = $this->getHrefTitle();
        $ret['cat_url_rewrited'] = $this->getLink();

        return $ret;
    }
}

/**
 * Class OledrionOledrion_catHandler
 */
class OledrionOledrion_catHandler extends Oledrion_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.

{
    /**
     * OledrionOledrion_catHandler constructor.
     * @param XoopsDatabase|null $db
     */
    public function __construct(XoopsDatabase $db)
    { //                        Table               Classe       Id       Libellé
        parent::__construct($db, 'oledrion_cat', 'oledrion_cat', 'cat_cid', 'cat_title');
    }

    /**
     * Renvoie (sous forme d'objets) la liste de toutes les catégories
     *
     * @param  Oledrion_parameters $parameters
     * @return array               Taleau d'objets (catégories)
     * @internal param int $start Indice de début de recherche
     * @internal param int $limit Nombre maximum d'enregsitrements à renvoyer
     * @internal param string $sort Champ à utiliser pour le tri
     * @internal param string $order Ordre du tire (asc ou desc)
     * @internal param bool $idaskey Indique s'il faut renvoyer un tableau dont la clé est l'identifiant de l'enregistrement
     */
    public function getAllCategories(Oledrion_parameters $parameters)
    {
        $parameters = $parameters->extend(new Oledrion_parameters(array(

new \Oledrion_parameters(array('start' => 0, 'limit' => 0, 'sort' => 'cat_title', 'order' => 'ASC', 'idaskey' => true)) is of type object<Oledrion_parameters>, but the function expects a object<self>.

                                                                      'start'   => 0,
                                                                      'limit'   => 0,
                                                                      'sort'    => 'cat_title',
                                                                      'order'   => 'ASC',
                                                                      'idaskey' => true
                                                                  )));
        $critere    = new Criteria('cat_cid', 0, '<>');
        $critere->setLimit($parameters['limit']);
        $critere->setStart($parameters['start']);
        $critere->setSort($parameters['sort']);
        $critere->setOrder($parameters['order']);
        $categories = array();

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

        $categories = $this->getObjects($critere, $parameters['idaskey']);

        return $categories;
    }

    /**
     * Fonction interne pour faire une vue développée des catégories
     *
     * @param  string $fieldName
     * @param  string $key
     * @param  string $ret
     * @param  object $tree
     * @return string

Should the return type not be string|null?

     */
    private function _makeLi($fieldName, $key, &$ret, $tree)
    {
        if ($key > 0) {
            $ret .= '<li><a href="';
            $ret .= $tree[$key]['obj']->getLink() . '">' . $tree[$key]['obj']->getVar('cat_title') . '</a>';
        }
        if (isset($tree[$key]['child']) && !empty($tree[$key]['child'])) {
            $ret .= "\n<ul>\n";
            foreach ($tree[$key]['child'] as $childkey) {
                $this->_makeLi($fieldName, $childkey, $ret, $tree);
            }
            $ret .= "</ul>\n";
        }
        $ret .= "</li>\n";
    }

    /**
     * Make a menu from the categories list
     *
     * @param  string  $fieldName Name of the member variable from the node objects that should be used as the title for the options.
     * @param  integer $key       ID of the object to display as the root of select options
     * @return string  HTML select box
     */
    public function getUlMenu($fieldName, $key = 0)
    {
        include_once XOOPS_ROOT_PATH . '/class/tree.php';
        $items      = $this->getAllCategories(new Oledrion_parameters());
        $treeObject = new XoopsObjectTree($items, 'cat_cid', 'cat_pid');
        $tree       =& $treeObject->getTree();

        $ret = '';
        $this->_makeLi($fieldName, $key, $ret, $tree);
        if (xoops_trim($ret) != '') {
            $ret = substr($ret, 0, -6);
        }

        return $ret;
    }

    /**
     * Supprime une catégorie (et tout ce qui lui est relatif)
     *
     * @param  Oledrion_cat $category
     * @return boolean      Le résultat de la suppression
     */
    public function deleteCategory(Oledrion_cat $category)
    {
        global $xoopsModule;

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

        $category->deletePicture();
        xoops_notification_deletebyitem($xoopsModule->getVar('mid'), 'new_category', $category->getVar('cat_cid'));

        return $this->delete($category, true);
    }

    /**
     * Retourne le nombre de produits d'une ou de plusieurs catégories
     *
     * @param  integer $cat_cid    L'identifiant de la catégorie dont on veut récupérer le nombre de produits
     * @param  boolean $withNested Faut il inclure les sous-catégories ?
     * @return integer Le nombre de produits
     */
    public function getCategoryProductsCount($cat_cid, $withNested = true)
    {
        global $h_oledrion_products;

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

        $childsIDs   = array();
        $childsIDs[] = $cat_cid;

        if ($withNested) { // Recherche des sous catégories de cette catégorie
            $items = $childs = array();

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

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

            include_once XOOPS_ROOT_PATH . '/class/tree.php';
            $items  = $this->getAllCategories(new Oledrion_parameters());
            $mytree = new XoopsObjectTree($items, 'cat_cid', 'cat_pid');
            $childs = $mytree->getAllChild($cat_cid);
            if (count($childs) > 0) {
                foreach ($childs as $onechild) {
                    $childsIDs[] = $onechild->getVar('cat_cid');
                }
            }
        }

        return $h_oledrion_products->getCategoryProductsCount($childsIDs);
    }

    /**
     * Retourne des catégories selon leur ID
     *
     * @param  array $ids Les ID des catégories à retrouver
     * @return array Objets de type Oledrion_cat
     */
    public function getCategoriesFromIds($ids)

This method seems to be duplicated in your project.

    {
        $ret = array();
        if (is_array($ids) && count($ids) > 0) {
            $criteria = new Criteria('cat_cid', '(' . implode(',', $ids) . ')', 'IN');
            $ret      = $this->getObjects($criteria, true, true, '*', false);
        }

        return $ret;
    }

    /**
     * Retourne la liste des catégories mères (sous forme d'un tableau d'objets)
     *
     * @return array Objets de type Oledrion_cat
     */
    public function getMotherCategories()
    {
        $ret      = array();

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

        $criteria = new Criteria('cat_pid', 0, '=');
        $criteria->setSort('cat_title');
        $ret = $this->getObjects($criteria);

        return $ret;
    }

    /**
     * Get category count
     *
     * @return int number of category
     */
    public function getCategoriesCount()
    {
        $criteria = new CriteriaCompo();

        return $this->getCount($criteria);
    }
}