Oledrion_reductions - Code Metrics - Inspection of "Merge branch 'master' of https://github.com/XoopsM..." - XoopsModules25x/oledrion - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 9d3fbd...af269e )

by Michael
created 2018-06-08 06:52 UTC
Oledrion_reductions D

↳ Parent: Project
Complexity

Total Complexity
124
Size/Duplication

Total Lines	716
Duplicated Lines	2.93 %
Coupling/Cohesion

Components	1
Dependencies	4
Importance

Changes
Metric	Value
dl	21
loc	716
rs	4.4444
c	0
b	0
f	0
wmc	124
lcom	1
cbo	4
16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	initHandlers()	0	4	1
A	loadAllActiveRules()	0	15	1
A	computePerCategories()	10	18	3
A	addAssociatedManufacturers()	0	6	2
A	addAssociatedAttributes()	0	6	2
A	addAssociatedVendors()	0	6	2
A	addAssociatedCategories()	0	6	2
B	loadAssociatedManufacturers()	0	23	6
A	loadAssociatedVendors()	0	8	2
A	loadAssociatedCategories()	0	8	2
A	loadElementsAssociatedToProducts()	0	6	1
B	loadProductsAssociatedToCart()	8	44	6
A	getDiscountedPrice()	0	4	1
A	initializePrivateData()	0	12	1
F	computeCart()	3	388	91
How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class
Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.
Complex classes like Oledrion_reductions often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use Oledrion_reductions, and based on these observations, apply Extract Interface, too.
<?php
/**
 * ****************************************************************************
 * oledrion - MODULE FOR XOOPS
 * Copyright (c) Hervé Thouzard of Instant Zero (http://www.instant-zero.com)
 *
 * 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       Hervé Thouzard of Instant Zero (http://www.instant-zero.com)
 * @license         http://www.fsf.org/copyleft/gpl.html GNU public license
 * @package         oledrion
 * @author          Hervé Thouzard of Instant Zero (http://www.instant-zero.com)
 *
 * Version :
 * ****************************************************************************
 */

/**
 * Calcul du panier et de ses réductions en fonction des règles de remises
 * Cette classe ne gère pas de fichier (elle sert uniquement aux calculs)
 *
 * Détail des tableaux :
 * categoriesProductsCount => Nombre de produits par catégorie
 * [clé] = Id Catégorie, [valeur] = Nombre de produits
 *
 * categoriesProductsQuantities => Quantités de produits par catégorie
 * [clé] = Id Catégorie, [valeur] = Quantité de produits
 *
 * totalProductsQuantities => Quantité totale de tous les produits
 *
 * associatedManufacturers => Contient la liste des ID uniques de produits
 * [clé] = Id Produit, [valeur] = Id produit
 *
 * associatedVendors => Contient la liste des vendeurs de produits
 * [clé] = Id Vendeur, [valeur] = Id Vendeur
 *
 * associatedAttributesPerProduct => Contient les attributs de chaque produit
 * [clé] = Id Produit, [valeurS] = Tous les attributs du produit sous la forme d'objets de type Attributs
 *
 * associatedCategories => Contient la liste des ID de catégories
 * [clé] = Id Catégorie, [valeur] = Id Catégorie
 *
 * totalAmountBeforeDiscounts => Montant total de la commande avant les réductions
 *
 * associatedManufacturersPerProduct => Contient la liste des ID des fabricants par produit
 * [clé] = Id produit, [valeur] = array(Ids des fabricants)
 *
 * Les 3 tableaux suivants évoluent ensuite comme ceci :
 * associatedManufacturers => Tableau d'objets de type Fabricants
 * [clé] = id Fabricant [valeur] = Fabricant sous la forme d'un objet
 *
 * associatedVendors => Tableau d'ojets de type Vendeurs
 * [clé] = Id Vendeur [valeur] = Vendeur sous la forme d'un objet
 *
 * associatedCategories => Tableau d'objets de type Categories
 * [clé] = Id Catégorie [valeur] = Catéagorie sous la forme d'un objet
 *
 */
class Oledrion_reductions
namespace YourVendor;

class YourClass { }
{
    // Ne contient que la liste des règles actives au moment du calcul
    private $allActiveRules = array();

    // Nombre de produits par catégorie
    private $categoriesProductsCount = array();

    // Quantité de produits par catégorie
    private $categoriesProductsQuantities = array();

    /**
     * le caddy en mémoire
     *  $cart['number'] = Indice du produit
     *  $cart['id'] = Identifiant du produit
     *  $cart['qty'] = Quantité voulue
     *  $cart['product'] = L'objet produit correspondant au panier
     */
    private $cart = array();

    /**
     * Le caddy pour le template. Consulter les détails du caddy dans la métode ComputeCart
     */
    private $cartForTemplate = array();

    /**
     * Les règles à appliquer à la fin, sur l'intégralité du panier
     */
    private $rulesForTheWhole = array();

    // Le total des quantités de produits avant les réductions
    private $totalProductsQuantities = 0;
    // Montant total de la commande avant les réductions
    private $totalAmountBeforeDiscounts = 0;

    // Handlers vers les tables du module
    private $handlers;

    // Les fabricants associés aux produits du panier
    private $associatedManufacturers = array();

    // Les vendeur associés aux produits du panier
    private $associatedVendors = array();

    // Les catégories associées aux produits du panier
    private $associatedCategories = array();

    // Fabricants associés par produit du panier
    private $associatedManufacturersPerProduct = array();

    // Attributs par produit du panier
    private $associatedAttributesPerProduct = array();

    /**
     * Chargement des handlers et des règles actives
     */
    public function __construct()
    {
        $this->initHandlers();
        $this->loadAllActiveRules();
    }

    /**
     * Chargement des handlers
     */
    private function initHandlers()
    {
        $this->handlers = OledrionHandler::getInstance();
    }

    /**
     * Chargement de toutes les règles actives de réductions (sans date définie ou avec une période correspondante à aujourd'hui)
     */
    public function loadAllActiveRules()
    {
        $critere  = new CriteriaCompo();
        $critere1 = new CriteriaCompo();
        $critere1->add(new Criteria('disc_date_from', 0, '='));
        $critere1->add(new Criteria('disc_date_to', 0, '='));
        $critere->add($critere1);

        $critere2 = new CriteriaCompo();
        $critere2->add(new Criteria('disc_date_from', time(), '<='));
        $critere2->add(new Criteria('disc_date_to', time(), '>='));
        $critere->add($critere2, 'OR');

        $this->allActiveRules = $this->handlers->h_oledrion_discounts->getObjects($critere);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
    }

    /**
     * Calcul des quantités de produits par catégorie et du nombre de produits par catégorie
     *
     * @param oledrion_products $product
     * @param integer           $quantity
     */
    public function computePerCategories(Oledrion_products $product, $quantity)
    {
        // Nombre de produits par catégories
        if (isset($this->categoriesProductsCount[$product->product_cid])) {

            ++$this->categoriesProductsCount[$product->product_cid];
        } else {
            $this->categoriesProductsCount[$product->product_cid] = 1;
        }

        // Mise à jour des quantités par catégories
        if (isset($this->categoriesProductsQuantities[$product->product_cid])) {

            $this->categoriesProductsQuantities[$product->product_cid] += $quantity;
        } else {
            $this->categoriesProductsQuantities[$product->product_cid] = $quantity;
        }
        $this->totalProductsQuantities += $quantity;
        // Quantité totale de tous les produits
    }

    /**
     * Ajoute à un tableau interne, le fabricant associé à un produit
     *
     * @param oledrion_products $product
     */
    private function addAssociatedManufacturers(Oledrion_products $product)
    {
        if (!isset($this->associatedManufacturers[$product->product_id])) {
            $this->associatedManufacturers[$product->product_id] = $product->product_id;
        }
    }

    /**
     * Recherche des attributs associés à chaque produit
     *
     * @param oledrion_products $product
     * @param attray            $attributes
     * @since 2.3
     */
    private function addAssociatedAttributes(Oledrion_products $product, $attributes)
    {
        if (!isset($this->associatedAttributesPerProduct[$product->product_id])) {
            $this->associatedAttributesPerProduct[$product->product_id] = $product->getProductsAttributesList($attributes);
        }
    }

    /**
     * Ajoute à un tableau interne, le vendeur associé à un produit
     *
     * @param oledrion_products $product
     */
    private function addAssociatedVendors(Oledrion_products $product)
    {
        if (!isset($this->associatedVendors[$product->product_vendor_id])) {
            $this->associatedVendors[$product->product_vendor_id] = $product->product_vendor_id;
        }
    }

    /**
     * Ajoute à un tableau interne, la catégorie associée à un produit
     *
     * @param oledrion_products $product
     */
    private function addAssociatedCategories(Oledrion_products $product)
    {
        if (!isset($this->associatedCategories[$product->product_cid])) {
            $this->associatedCategories[$product->product_cid] = $product->product_cid;
        }
    }

    /**
     * Charge les fabricants associés aux produits du panier
     */
    private function loadAssociatedManufacturers()
    {
        if (count($this->associatedManufacturers) > 0) {
            sort($this->associatedManufacturers);
            $productsIds                   = $this->associatedManufacturers;
            $this->associatedManufacturers = array();
            // au cas où cela échouerait
            $productsManufacturers = $manufacturersIds = array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $productsManufacturers = $this->handlers->h_oledrion_productsmanu->getFromProductsIds($productsIds);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            if (count($productsManufacturers) > 0) {
                foreach ($productsManufacturers as $productManufacturer) {
                    if (!isset($manufacturersIds[$productManufacturer->pm_manu_id])) {
                        $manufacturersIds[$productManufacturer->pm_manu_id] = $productManufacturer->pm_manu_id;
                    }
                    $this->associatedManufacturersPerProduct[$productManufacturer->pm_product_id][] = $productManufacturer->pm_manu_id;
                }
                if (count($manufacturersIds) > 0) {
                    sort($manufacturersIds);
                    $this->associatedManufacturers = $this->handlers->h_oledrion_manufacturer->getManufacturersFromIds($manufacturersIds);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                }
            }
        }
    }

    /**
     * Charge la liste des vendeurs associés aux produits
     */
    private function loadAssociatedVendors()
    {
        if (count($this->associatedVendors) > 0) {
            sort($this->associatedVendors);
            $ids                     = $this->associatedVendors;
            $this->associatedVendors = $this->handlers->h_oledrion_vendors->getVendorsFromIds($ids);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        }
    }

    /**
     * Charge les catégories associées aux produits du panier
     */
    private function loadAssociatedCategories()
    {
        if (count($this->associatedCategories) > 0) {
            sort($this->associatedCategories);
            $ids                        = $this->associatedCategories;
            $this->associatedCategories = $this->handlers->h_oledrion_cat->getCategoriesFromIds($ids);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        }
    }

    /**
     * Recherche les fabricants, catégories et vendeurs associés à chaque produit
     */
    public function loadElementsAssociatedToProducts()
    {
        $this->loadAssociatedManufacturers();
        $this->loadAssociatedVendors();
        $this->loadAssociatedCategories();
    }

    /**
     * Recherche les (objets) produits associés à chaque produit du panier (et lance le calcul des quantités)
     */
    public function loadProductsAssociatedToCart()
    {
        $newCart = array();
        foreach ($this->cart as $cartProduct) {
            $data               = array();
            $data['id']         = $cartProduct['id'];
            $data['number']     = $cartProduct['number'];
            $data['qty']        = $cartProduct['qty'];
            $data['attributes'] = $cartProduct['attributes'];

            $product = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $product = $this->handlers->h_oledrion_products->get($data['id']);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            if (!is_object($product)) {
                trigger_error(_OLEDRION_ERROR9);
                continue;
                // Pour éviter le cas de la suppression d'un produit (dans l'admin) alors qu'un client l'a toujours dans son panier (et donc en session)
            }
            $data['product'] = $product;
            // Mise à jour des calculs par catégorie
            $this->computePerCategories($product, $data['qty']);
            // Recherche des éléments associés à chaque produit
            $this->addAssociatedManufacturers($product);
            $this->addAssociatedVendors($product);
            $this->addAssociatedAttributes($product, $data['attributes']);
            $this->addAssociatedCategories($product);

            // Calcul du total de la commande avant réductions
            if ((float)$product->getVar('product_discount_price', 'n') > 0) {

                $ht = (float)$product->getVar('product_discount_price', 'n');
            } else {
                $ht = (float)$product->getVar('product_price', 'n');
            }
            // S'il y a des options, on rajoute leur montant
            if (is_array($data['attributes']) && count($data['attributes']) > 0) {

                $ht += $this->handlers->h_oledrion_attributes->getProductOptionsPrice($data['attributes'], $product->getVar('product_vat_id'));
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            }

            $this->totalAmountBeforeDiscounts += ($data['qty'] * $ht);

            $newCart[] = $data;
        }
        $this->loadElementsAssociatedToProducts();
        $this->cart = $newCart;
    }

    /**
     * Calcul du montant HT auquel on applique un pourcentage de réduction
     *
     * @param  float   $price    Le prix auquel appliquer la réduction
     * @param  integer $discount Le pourcentage de réduction
     * @return float   Le montant réduit
     */
    private function getDiscountedPrice($price, $discount)
    {
        return (float)($price - ($price * ($discount / 100)));
    }

    /**
     * Remise à zéro des membres internes
     */
    private function initializePrivateData()
    {
        $this->totalProductsQuantities           = 0;
        $this->totalAmountBeforeDiscounts        = 0;
        $this->rulesForTheWhole                  = array();
        $this->cartForTemplate                   = array();
        $this->associatedManufacturers           = array();
        $this->associatedVendors                 = array();
        $this->associatedCategories              = array();
        $this->associatedManufacturersPerProduct = array();
        $this->associatedAttributesPerProduct    = array();
    }

    /**
     * Calcul de la facture en fonction du panier
     * Contenu du panier en session :
     *
     *  $datas['number'] = Indice du produit dans le panier
     *  $datas['id'] = Identifiant du produit dans la base
     *  $datas['qty'] = Quantité voulue
     *  $datas['attributes'] = Attributs produit array('attr_id' => id attribut, 'values' => array(valueId1, valueId2 ...))
     *
     * En variable privé, le panier (dans $cart) contient la même chose + un objet 'oledrion_products' dans la clé 'product'
     *
     * @param array   $cartForTemplate      Contenu du caddy à passer au template (en fait la liste des produits)
     * @param         boolean               emptyCart Indique si le panier est vide ou pas
     * @param float   $shippingAmount       Montant des frais de port
     * @param float   $commandAmount        Montant HT de la commande
     * @param float   $vatAmount            Montant de la TVA
     * @param string  $goOn                 Adresse vers laquelle renvoyer le visiteur après qu'il ait ajouté un produit dans son panier (cela correspond en fait à la catégorie du dernier produit ajouté dans le panier)
     * @param float   $commandAmountTTC     Montant TTC de la commande
     * @param array   $discountsDescription Descriptions des remises GLOBALES appliquées (et pas les remises par produit !)
     * @param integer $discountsCount       Le nombre TOTAL de réductions appliquées (individuellement ou sur la globalité du panier)
     *                                      B.R. @param array $checkoutAttributes
     * TODO: Passer les paramètres sous forme d'objet
     * @return bool
     */

    // B.R. Added: $checkoutAttributes
    public function computeCart(
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
        &$cartForTemplate,
        &$emptyCart,
        &$shippingAmount,
        &$commandAmount,
        &$vatAmount,
        &$goOn,
        &$commandAmountTTC,
        &$discountsDescription,
        &$discountsCount,
        &$checkoutAttributes)
    {
        $emptyCart      = false;
        $goOn           = '';
        $vats           = array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $cpt            = 0;
        $discountsCount = 0;
        $this->cart     = isset($_SESSION[OledrionOledrion_caddyHandler::CADDY_NAME]) ? $_SESSION[OledrionOledrion_caddyHandler::CADDY_NAME] : array();
        $cartCount      = count($this->cart);
        if ($cartCount == 0) {
            $emptyCart = true;

            return true;
        }

        // Réinitialisation des données privées
        $this->initializePrivateData();
        // Chargement des objets produits associés aux produits du panier et calcul des quantités par catégorie
        $this->loadProductsAssociatedToCart();
        // Chargement des TVA
        if (!isset($_POST['cmd_country']) || empty($_POST['cmd_country'])) {
            $_POST['cmd_country'] = OLEDRION_DEFAULT_COUNTRY;
        }
        $vats              = $this->handlers->h_oledrion_vat->getCountryVats($_POST['cmd_country']);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $oledrion_Currency = &Oledrion_Currency::getInstance();
        $caddyCount        = count($this->cart);

        // Initialisation des totaux généraux (ht, tva et frais de port)
        $totalHT = $totalVAT = $totalShipping = 0.0;

        // Boucle sur tous les produits et sur chacune des règles pour calculer le prix du produit (et ses frais de port) et voir si on doit y appliquer une réduction
        foreach ($this->cart as $cartProduct) {
            if ((float)$cartProduct['product']->getVar('product_discount_price', 'n') > 0) {
                $ht = (float)$cartProduct['product']->getVar('product_discount_price', 'n');
            } else {
                $ht = (float)$cartProduct['product']->getVar('product_price', 'n');
            }
            // S'il y a des options, on rajoute leur montant
            $productAttributes = array();
            if (is_array($cartProduct['attributes']) && count($cartProduct['attributes']) > 0) {

                $ht += $this->handlers->h_oledrion_attributes->getProductOptionsPrice($cartProduct['attributes'], $cartProduct['product']->getVar('product_vat_id'), $productAttributes);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            }

            $discountedPrice = $ht;
            $quantity        = (int)$cartProduct['qty'];

            if (OledrionUtility::getModuleOption('shipping_quantity')) {
                $discountedShipping = (float)($cartProduct['product']->getVar('product_shipping_price', 'n') * $quantity);
            } else {
                $discountedShipping = (float)$cartProduct['product']->getVar('product_shipping_price', 'n');
            }
            $totalPrice = 0.0;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $reduction  = '';

            // B.R. Start
            // If any product in cart does not skip optional checkout step, need to perform
            if ($cartProduct['product']->getVar('skip_packing', 'n') == 0) {
                $checkoutAttributes['skip_packing'] = 0;
            }
            if ($cartProduct['product']->getVar('skip_location', 'n') == 0) {
                $checkoutAttributes['skip_location'] = 0;
            }
            if ($cartProduct['product']->getVar('skip_delivery', 'n') == 0) {
                $checkoutAttributes['skip_delivery'] = 0;
            }
            // B.R. End

            ++$cpt;
            if ($cpt == $caddyCount) {
                // On arrive sur le dernier produit
                $category = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                $category = $this->handlers->h_oledrion_cat->get($cartProduct['product']->getVar('product_cid'));
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                if (is_object($category)) {
                    $goOn = $category->getLink();
                }
            }

            // Boucle sur les règles
            foreach ($this->allActiveRules as $rule) {
                $applyRule = false;
                if (($rule->disc_group != 0 && OledrionUtility::isMemberOfGroup($rule->disc_group))
                    || $rule->disc_group == 0) {
                    if (($rule->disc_cat_cid != 0
                         && $cartProduct['product']->getVar('product_cid') == $rule->disc_cat_cid)
                        || $rule->disc_cat_cid == 0) {
                        if (($rule->disc_vendor_id != 0
                             && $cartProduct['product']->getVar('disc_vendor_id') == $rule->disc_vendor_id)
                            || $rule->disc_vendor_id == 0) {
                            if (($rule->disc_product_id != 0
                                 && $cartProduct['product']->getVar('product_id') == $rule->disc_product_id)
                                || $rule->disc_product_id == 0) {
                                // Dans quel cas appliquer la réduction ?
                                switch ($rule->disc_price_case) {
                                    case OLEDRION_DISCOUNT_PRICE_CASE_ALL:
                                        // Dans tous les cas
                                        $applyRule = true;
                                        break;
                                    case OLEDRION_DISCOUNT_PRICE_CASE_FIRST_BUY:
                                        // Si c'est le premier achat de l'utilisateur sur le site
                                        if ($this->handlers->h_oledrion_commands->isFirstCommand()) {
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                                            $applyRule = true;
                                        }
                                        break;
                                    case OLEDRION_DISCOUNT_PRICE_CASE_PRODUCT_NEVER:
                                        // Si le produit n'a jamais été acheté par le client
                                        if (!$this->handlers->h_oledrion_commands->productAlreadyBought(0, $cartProduct['product']->getVar('product_id'))) {
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                                            $applyRule = true;
                                        }
                                        break;
                                    case OLEDRION_DISCOUNT_PRICE_CASE_QTY_IS:
                                        // Si la quantité de produit est ... à ...
                                        switch ($rule->disc_price_case_qty_cond) {
                                            case OLEDRION_DISCOUNT_PRICE_QTY_COND1:
                                                // >
                                                if ($cartProduct['qty'] > $rule->disc_price_case_qty_value) {
                                                    $applyRule = true;
                                                }
                                                break;
                                            case OLEDRION_DISCOUNT_PRICE_QTY_COND2:
                                                // >=
                                                if ($cartProduct['qty'] >= $rule->disc_price_case_qty_value) {
                                                    $applyRule = true;
                                                }
                                                break;
                                            case OLEDRION_DISCOUNT_PRICE_QTY_COND3:
                                                // <
                                                if ($cartProduct['qty'] < $rule->disc_price_case_qty_value) {
                                                    $applyRule = true;
                                                }
                                                break;
                                            case OLEDRION_DISCOUNT_PRICE_QTY_COND4:
                                                // <=
                                                if ($cartProduct['qty'] <= $rule->disc_price_case_qty_value) {
                                                    $applyRule = true;
                                                }
                                                break;
                                            case OLEDRION_DISCOUNT_PRICE_QTY_COND5:
                                                // ==
                                                if ($cartProduct['qty'] == $rule->disc_price_case_qty_value) {
                                                    $applyRule = true;
                                                }
                                                break;
                                        }
                                }
                            }
                        }
                    }
                }
                if ($applyRule) {
                    // Il faut appliquer la règle
                    // On calcule le nouveau prix ht du produit
                    switch ($rule->disc_price_type) {
                        case OLEDRION_DISCOUNT_PRICE_TYPE1:
                            // Montant dégressif selon les quantités
                            if ($quantity >= $rule->disc_price_degress_l1qty1
                                && $quantity <= $rule->disc_price_degress_l1qty2) {
                                $discountedPrice = (float)$rule->getVar('disc_price_degress_l1total', 'n');
                            }
                            if ($quantity >= $rule->disc_price_degress_l2qty1
                                && $quantity <= $rule->disc_price_degress_l2qty2) {
                                $discountedPrice = (float)$rule->getVar('disc_price_degress_l2total', 'n');
                            }
                            if ($quantity >= $rule->disc_price_degress_l3qty1
                                && $quantity <= $rule->disc_price_degress_l3qty2) {
                                $discountedPrice = (float)$rule->getVar('disc_price_degress_l3total', 'n');
                            }
                            if ($quantity >= $rule->disc_price_degress_l4qty1
                                && $quantity <= $rule->disc_price_degress_l4qty2) {
                                $discountedPrice = (float)$rule->getVar('disc_price_degress_l4total', 'n');
                            }
                            if ($quantity >= $rule->disc_price_degress_l5qty1
                                && $quantity <= $rule->disc_price_degress_l5qty2) {
                                $discountedPrice = (float)$rule->getVar('disc_price_degress_l5total', 'n');
                            }
                            $reduction = $rule->disc_description;
                            ++$discountsCount;
                            break;

                        case OLEDRION_DISCOUNT_PRICE_TYPE2:
                            // D'un montant ou d'un pourcentage
                            if ($rule->disc_price_amount_on == OLEDRION_DISCOUNT_PRICE_AMOUNT_ON_PRODUCT) {
                                // Réduction sur le produit
                                if ($rule->disc_price_amount_type == OLEDRION_DISCOUNT_PRICE_REDUCE_PERCENT) {
                                    // Réduction en pourcentage
                                    $discountedPrice = $this->getDiscountedPrice($discountedPrice, $rule->getVar('disc_price_amount_amount', 'n'));
                                } elseif ($rule->disc_price_amount_type == OLEDRION_DISCOUNT_PRICE_REDUCE_MONEY) {
                                    // Réduction d'un montant en euros
                                    $discountedPrice -= (float)$rule->getVar('disc_price_amount_amount', 'n');
                                }

                                // Pas de montants négatifs
                                OledrionUtility::doNotAcceptNegativeAmounts($discountedPrice);
                                $reduction = $rule->disc_description;
                                ++$discountsCount;
                            } elseif ($rule->disc_price_amount_on == OLEDRION_DISCOUNT_PRICE_AMOUNT_ON_CART) {
                                // Règle à appliquer sur le panier
                                if (!isset($this->rulesForTheWhole[$rule->disc_id])) {
                                    $this->rulesForTheWhole[$rule->disc_id] = $rule;
                                }
                            }
                            break;
                    }

                    // On passe au montant des frais de port
                    switch ($rule->disc_shipping_type) {
                        case OLEDRION_DISCOUNT_SHIPPING_TYPE1:
                            // A payer dans leur intégralité, rien à faire
                            break;
                        case OLEDRION_DISCOUNT_SHIPPING_TYPE2:
                            // Totalement gratuits si le client commande plus de X euros d'achat
                            if ($this->totalAmountBeforeDiscounts > $rule->disc_shipping_free_morethan) {
                                $discountedShipping = 0.0;
                            }
                            break;
                        case OLEDRION_DISCOUNT_SHIPPING_TYPE3:
                            // Frais de port réduits de X euros si la commande est > x
                            if ($this->totalAmountBeforeDiscounts > $rule->disc_shipping_reduce_cartamount) {
                                $discountedShipping -= (float)$rule->getVar('disc_shipping_reduce_amount', 'n');
                            }
                            // Pas de montants négatifs
                            OledrionUtility::doNotAcceptNegativeAmounts($discountedShipping);
                            break;
                        case OLEDRION_DISCOUNT_SHIPPING_TYPE4:
                            // Frais de port dégressifs
                            if ($quantity >= $rule->disc_shipping_degress_l1qty1
                                && $quantity <= $rule->disc_shipping_degress_l1qty2) {
                                $discountedShipping = (float)$rule->getVar('disc_shipping_degress_l1total', 'n');
                            }
                            if ($quantity >= $rule->disc_shipping_degress_l2qty1
                                && $quantity <= $rule->disc_shipping_degress_l2qty2) {
                                $discountedShipping = (float)$rule->getVar('disc_shipping_degress_l2total', 'n');
                            }
                            if ($quantity >= $rule->disc_shipping_degress_l3qty1
                                && $quantity <= $rule->disc_shipping_degress_l3qty2) {
                                $discountedShipping = (float)$rule->getVar('disc_shipping_degress_l3total', 'n');
                            }
                            if ($quantity >= $rule->disc_shipping_degress_l4qty1
                                && $quantity <= $rule->disc_shipping_degress_l4qty2) {
                                $discountedShipping = (float)$rule->getVar('disc_shipping_degress_l4total', 'n');
                            }
                            if ($quantity >= $rule->disc_shipping_degress_l5qty1
                                && $quantity <= $rule->disc_shipping_degress_l5qty2) {
                                $discountedShipping = (float)$rule->getVar('disc_shipping_degress_l5total', 'n');
                            }
                            break;
                    }    // Sélection du type de réduction sur les frais de port
                }    // Il faut appliquer la règle de réduction
            }// Boucle sur les réductions

            // Calcul de la TVA du produit
            $vatId = $cartProduct['product']->getVar('product_vat_id');
            if (is_array($vats) && isset($vats[$vatId])) {
                $vatRate   = (float)$vats[$vatId]->getVar('vat_rate', 'n');
                $vatAmount = OledrionUtility::getVAT($discountedPrice * $quantity, $vatRate);
            } else {
                $vatRate   = 0.0;
                $vatAmount = 0.0;
            }

            // Calcul du TTC du produit ((ht * qte) + tva + frais de port)
            $totalPrice = (float)(($discountedPrice * $quantity) + $vatAmount + $discountedShipping);

            // Les totaux généraux
            $totalHT       += ($discountedPrice * $quantity);
            $totalVAT      += $vatAmount;
            $totalShipping += $discountedShipping;

            // Recherche des éléments associés au produit
            $associatedVendor      = $associatedCategory = $associatedManufacturers = array();
            $manufacturersJoinList = '';
            // Le vendeur
            if (isset($this->associatedVendors[$cartProduct['product']->product_vendor_id])) {
                $associatedVendor = $this->associatedVendors[$cartProduct['product']->product_vendor_id]->toArray();
            }

            // La catégorie
            if (isset($this->associatedCategories[$cartProduct['product']->product_cid])) {
                $associatedCategory = $this->associatedCategories[$cartProduct['product']->product_cid]->toArray();
            }

            // Les fabricants
            $product_id = $cartProduct['product']->product_id;
            if (isset($this->associatedManufacturersPerProduct[$product_id])) {
                // Recherche de la liste des fabricants associés à ce produit
                $manufacturers     = $this->associatedManufacturersPerProduct[$product_id];
                $manufacturersList = array();
                foreach ($manufacturers as $manufacturer_id) {
                    if (isset($this->associatedManufacturers[$manufacturer_id])) {
                        $associatedManufacturers[] = $this->associatedManufacturers[$manufacturer_id]->toArray();
                    }
                    $manufacturersList[] = $this->associatedManufacturers[$manufacturer_id]->manu_commercialname . ' ' . $this->associatedManufacturers[$manufacturer_id]->manu_name;
                }
                $manufacturersJoinList = implode(OLEDRION_STRING_TO_JOIN_MANUFACTURERS, $manufacturersList);
            }
            $productTemplate                = array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $productTemplate                = $cartProduct['product']->toArray();
            $productTemplate['attributes']  = $productAttributes;
            $productTemplate['number']      = $cartProduct['number'];
            $productTemplate['id']          = $cartProduct['id'];
            $productTemplate['product_qty'] = $cartProduct['qty'];

            $productTemplate['unitBasePrice'] = $ht;
            // Prix unitaire HT SANS réduction
            $productTemplate['discountedPrice'] = $discountedPrice;
            // Prix unitaire HT AVEC réduction
            $productTemplate['discountedPriceWithQuantity'] = $discountedPrice * $quantity;
            // Prix HT AVEC réduction et la quantité
            // Les même prix mais formatés
            $productTemplate['unitBasePriceFormated'] = $oledrion_Currency->amountForDisplay($ht);
            // Prix unitaire HT SANS réduction
            $productTemplate['discountedPriceFormated'] = $oledrion_Currency->amountForDisplay($discountedPrice);
            // Prix unitaire HT AVEC réduction
            $productTemplate['discountedPriceWithQuantityFormated'] = $oledrion_Currency->amountForDisplay($discountedPrice * $quantity);
            // Prix HT AVEC réduction et la quantité

            // Add by voltan
            $productTemplate['discountedPriceFormatedOrg'] = $oledrion_Currency->amountForDisplay($ht - $discountedPrice);
            $productTemplate['discountedPriceOrg']         = $ht - $discountedPrice;

            $productTemplate['vatRate']            = $oledrion_Currency->amountInCurrency($vatRate);
            $productTemplate['vatAmount']          = $vatAmount;
            $productTemplate['normalShipping']     = $cartProduct['product']->getVar('product_shipping_price', 'n');
            $productTemplate['discountedShipping'] = $discountedShipping;
            $productTemplate['totalPrice']         = $totalPrice;
            $productTemplate['reduction']          = $reduction;
            $productTemplate['templateProduct']    = $cartProduct['product']->toArray();

            $productTemplate['vatAmountFormated']          = $oledrion_Currency->amountInCurrency($vatAmount);
            $productTemplate['normalShippingFormated']     = $oledrion_Currency->amountForDisplay($cartProduct['product']->getVar('product_shipping_price', 'n'));
            $productTemplate['discountedShippingFormated'] = $oledrion_Currency->amountForDisplay($discountedShipping);
            $productTemplate['totalPriceFormated']         = $oledrion_Currency->amountInCurrency($totalPrice);
            $productTemplate['templateCategory']           = $associatedCategory;
            $productTemplate['templateVendor']             = $associatedVendor;
            $productTemplate['templateManufacturers']      = $associatedManufacturers;
            $productTemplate['manufacturersJoinList']      = $manufacturersJoinList;
            $this->cartForTemplate[]                       = $productTemplate;
        }// foreach sur les produits du panier

        // Traitement des règles générales s'il y en a
        if (count($this->rulesForTheWhole) > 0) {
            // $discountsDescription
            foreach ($this->rulesForTheWhole as $rule) {
                switch ($rule->disc_price_type) {
                    case OLEDRION_DISCOUNT_PRICE_TYPE2:
                        // D'un montant ou d'un pourcentage
                        if ($rule->disc_price_amount_on == OLEDRION_DISCOUNT_PRICE_AMOUNT_ON_CART) {
                            // Règle à appliquer sur le panier
                            if ($rule->disc_price_amount_type == OLEDRION_DISCOUNT_PRICE_REDUCE_PERCENT) {
                                // Réduction en pourcentage
                                $totalHT  = $this->getDiscountedPrice($totalHT, $rule->getVar('disc_price_amount_amount'));
                                $totalVAT = $this->getDiscountedPrice($totalVAT, $rule->getVar('disc_price_amount_amount'));
                            } elseif ($rule->disc_price_amount_type == OLEDRION_DISCOUNT_PRICE_REDUCE_MONEY) {
                                // Réduction d'un montant en euros
                                $totalHT  -= (float)$rule->getVar('disc_price_amount_amount');
                                $totalVAT -= (float)$rule->getVar('disc_price_amount_amount');
                            }

                            // Pas de montants négatifs
                            OledrionUtility::doNotAcceptNegativeAmounts($totalHT);
                            OledrionUtility::doNotAcceptNegativeAmounts($totalVAT);
                            $discountsDescription[] = $rule->disc_description;
                            ++$discountsCount;
                        }// Règle à appliquer sur le panier
                        break;
                }    // Switch
            }    // Foreach
        }// S'il y a des règles globales
        // Les totaux "renvoyés" à l'appelant
        $shippingAmount = $totalShipping;
        $commandAmount  = $totalHT;

        $vatAmount        = $totalVAT;
        $commandAmountTTC = $totalHT + $totalVAT + $totalShipping;

        $cartForTemplate = $this->cartForTemplate;

        return true;
    }
}

XoopsModules25x / oledrion
