ProductCombination::__construct() - Code Metrics - Inspection of "Classes from the Recruitement, Resource, Salaries,..." - alxarafe/alixar - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — EXTRACT_CLASSES ( a2ff75...ae6b5c )

by Rafael
created 2024-08-24 07:42 UTC
ProductCombination::__construct() A

↳ Parent: ProductCombination
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	3
nc	1
nop	1
dl	0
loc	6
rs	10
c	0
b	0
f	0
<?php

/* Copyright (C) 2016       Marcos García               <[email protected]>
 * Copyright (C) 2018		Juanjo Menent			    <[email protected]>
 * Copyright (C) 2022   	Open-Dsi				    <[email protected]>
 * Copyright (C) 2024		MDW						    <[email protected]>
 * Copyright (C) 2024       Frédéric France             <[email protected]>
 * Copyright (C) 2024       Rafael San José             <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */

namespace Dolibarr\Code\Variants\Classes;

use DoliDB;

/**
 *  \file       htdocs/variants/class/ProductCombination.class.php
 *  \ingroup    variants
 *  \brief      File of the ProductCombination class
 */

/**
 * Class ProductCombination
 * Used to represent the relation between a product and one of its variants.
 *
 * Example: a product "shirt" has two variants "shirt XL white" and "shirt XL grey".
 * This is represented with two ProductCombination objects:
 * - One for "shirt XL white":
 *     * $object->fk_product_parent     ID of the Product object "shirt"
 *     * $object->fk_product_child      ID of the Product object "shirt XL white"
 * - Another for "shirt XL grey":
 *     * $object->fk_product_parent     ID of the Product object "shirt"
 *     * $object->fk_product_child      ID of the Product object "shirt XL grey"
 */
class ProductCombination
{
    /**
     * Database handler
     * @var DoliDB
     */
    public $db;

    /**
     * Rowid of this ProductCombination
     * @var int
     */
    public $id;

    /**
     * Rowid of the parent Product
     * @var int
     */
    public $fk_product_parent;

    /**
     * Rowid of the variant Product
     * @var int
     */
    public $fk_product_child;

    /**
     * Price variation
     * @var float
     */
    public $variation_price;

    /**
     * Is the price variation a relative variation?
     * Can be an array if multiprice feature per level is enabled.
     * @var bool|array
     */
    public $variation_price_percentage = false;

    /**
     * Weight variation
     * @var float
     */
    public $variation_weight;

    /**
     * Combination entity
     * @var int
     */
    public $entity;

    /**
     * Combination price level
     * @var ProductCombinationLevel[]
     */
    public $combination_price_levels;

    /**
     * External ref
     * @var string
     */
    public $variation_ref_ext = '';

    /**
     * Error message
     * @var string
     */
    public $error;

    /**
     * Array of error messages
     * @var string[]
     */
    public $errors = array();

    /**
     * Constructor
     *
     * @param   DoliDB $db     Database handler
     */
    public function __construct(DoliDB $db)
    {
        global $conf;

        $this->db = $db;
        $this->entity = $conf->entity;
    }

    /**
     * Retrieves a ProductCombination by its rowid
     *
     * @param   int     $rowid      ID of the ProductCombination
     * @return  -1|1                -1 if KO, 1 if OK

     */
    public function fetch($rowid)
    {
        global $conf;

        $sql = "SELECT rowid, fk_product_parent, fk_product_child, variation_price, variation_price_percentage, variation_weight, variation_ref_ext FROM " . MAIN_DB_PREFIX . "product_attribute_combination WHERE rowid = " . ((int) $rowid) . " AND entity IN (" . getEntity('product') . ")";

        $query = $this->db->query($sql);

        if (!$query) {
            return -1;
        }

        if (!$this->db->num_rows($query)) {
            return -1;
        }

        $obj = $this->db->fetch_object($query);

        $this->id = $obj->rowid;
        $this->fk_product_parent = $obj->fk_product_parent;
        $this->fk_product_child = $obj->fk_product_child;
        $this->variation_price = $obj->variation_price;
        $this->variation_price_percentage = $obj->variation_price_percentage;
        $this->variation_weight = $obj->variation_weight;
        $this->variation_ref_ext = $obj->variation_ref_ext;

        if (getDolGlobalString('PRODUIT_MULTIPRICES')) {
            $this->fetchCombinationPriceLevels();
        }

        return 1;
    }


    /**
     * Retrieves combination price levels
     *
     * @param   int     $fk_price_level The price level to fetch, use 0 for all
     * @param   bool    $useCache       To use cache or not
     * @return  -1|1                    -1 if KO, 1 if OK

     */
    public function fetchCombinationPriceLevels($fk_price_level = 0, $useCache = true)
    {
        global $conf;

        // Check cache
        if (!empty($this->combination_price_levels) && $useCache) {
            if ((!empty($fk_price_level) && isset($this->combination_price_levels[$fk_price_level])) || empty($fk_price_level)) {
                return 1;
            }
        }

        if (
            !is_array($this->combination_price_levels)
            || empty($fk_price_level) // if fetch an unique level don't erase all already fetched
        ) {
            $this->combination_price_levels = array();
        }

        $staticProductCombinationLevel = new ProductCombinationLevel($this->db);
        $combination_price_levels = $staticProductCombinationLevel->fetchAll($this->id, $fk_price_level);

        if (!is_array($combination_price_levels)) {
            return -1;
        }

        if (empty($combination_price_levels)) {
            /**
             * for auto retrocompatibility with last behavior
             */
            if ($fk_price_level > 0) {
                $combination_price_levels[$fk_price_level] = ProductCombinationLevel::createFromParent($this->db, $this, $fk_price_level);
            } else {
                $produit_multiprices_limit = getDolGlobalString('PRODUIT_MULTIPRICES_LIMIT');
                for ($i = 1; $i <= $produit_multiprices_limit; $i++) {
                    $combination_price_levels[$i] = ProductCombinationLevel::createFromParent($this->db, $this, $i);
                }
            }
        }

        $this->combination_price_levels = $combination_price_levels;
class Id
{
    public $id;

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

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        return 1;
    }

    /**
     * Retrieves combination price levels
     *
     * @param   int     $clean      Levels of PRODUIT_MULTIPRICES_LIMIT
     * @return  int                 Return integer <0 KO, >0 OK
     */
    public function saveCombinationPriceLevels($clean = 1)
    {
        global $conf;

        $error = 0;

        $staticProductCombinationLevel = new ProductCombinationLevel($this->db);

        // Delete all
        if (empty($this->combination_price_levels)) {
            return $staticProductCombinationLevel->deleteAllForCombination($this->id);
        }

        // Clean not needed price levels (level higher than number max defined into setup)
        if ($clean) {
            $res = $staticProductCombinationLevel->clean($this->id);
            if ($res < 0) {
                $this->errors[] = 'Fail to clean not needed price levels';
                return -1;
            }
        }

        foreach ($this->combination_price_levels as $fk_price_level => $combination_price_level) {
            $res = $combination_price_level->save();
            if ($res < 1) {
                $this->error = 'Error saving combination price level ' . $fk_price_level . ' : ' . $combination_price_level->error;
                $this->errors[] = $this->error;
                $error++;
                break;
            }
        }

        if ($error) {
            return $error * -1;
        } else {
            return 1;
        }
    }

    /**
     * Retrieves information of a variant product and ID of its parent product.
     *
     * @param   int     $productid              Product ID of variant
     * @param   int     $donotloadpricelevel    Avoid loading price impact for each level. If PRODUIT_MULTIPRICES is not set, this has no effect.
     * @return  int                             Return integer <0 if KO, 0 if product ID is not ID of a variant product (so parent not found), >0 if OK (ID of parent)
     */
    public function fetchByFkProductChild($productid, $donotloadpricelevel = 0)
    {
        global $conf;

        $sql = "SELECT rowid, fk_product_parent, fk_product_child, variation_price, variation_price_percentage, variation_weight";
        $sql .= " FROM " . MAIN_DB_PREFIX . "product_attribute_combination WHERE fk_product_child = " . ((int) $productid) . " AND entity IN (" . getEntity('product') . ")";

        $query = $this->db->query($sql);

        if (!$query) {
            return -1;
        }

        if (!$this->db->num_rows($query)) {
            return 0;
        }

        $result = $this->db->fetch_object($query);

        $this->id = $result->rowid;
        $this->fk_product_parent = $result->fk_product_parent;
        $this->fk_product_child = $result->fk_product_child;
        $this->variation_price = $result->variation_price;
        $this->variation_price_percentage = $result->variation_price_percentage;
        $this->variation_weight = $result->variation_weight;

        if (empty($donotloadpricelevel) && getDolGlobalString('PRODUIT_MULTIPRICES')) {
            $this->fetchCombinationPriceLevels();
        }

        return (int) $this->fk_product_parent;
    }

    /**
     * Retrieves all product combinations by the product parent row id
     *
     * @param   int                         $fk_product_parent  Rowid of parent product
     * @param   bool                        $sort_by_ref        Sort result by product child reference
     * @return  int|ProductCombination[]                        Return integer <0 KO
     */
    public function fetchAllByFkProductParent($fk_product_parent, $sort_by_ref = false)
    {
        global $conf;

        $sql = "SELECT pac.rowid, pac.fk_product_parent, pac.fk_product_child, pac.variation_price, pac.variation_price_percentage, pac.variation_ref_ext, pac.variation_weight";
        $sql .= " FROM " . MAIN_DB_PREFIX . "product_attribute_combination AS pac";
        if ($sort_by_ref) {
            $sql .= " LEFT JOIN " . MAIN_DB_PREFIX . "product AS p ON p.rowid = pac.fk_product_child";
        }
        $sql .= " WHERE pac.fk_product_parent = " . ((int) $fk_product_parent) . " AND pac.entity IN (" . getEntity('product') . ")";
        if ($sort_by_ref) {
            $sql .= $this->db->order('p.ref', 'ASC');
        }

        $query = $this->db->query($sql);

        if (!$query) {
            return -1;
        }

        $return = array();

        while ($result = $this->db->fetch_object($query)) {
            $tmp = new ProductCombination($this->db);
            $tmp->id = $result->rowid;
            $tmp->fk_product_parent = $result->fk_product_parent;
            $tmp->fk_product_child = $result->fk_product_child;
            $tmp->variation_price = $result->variation_price;
            $tmp->variation_price_percentage = $result->variation_price_percentage;
            $tmp->variation_weight = $result->variation_weight;
            $tmp->variation_ref_ext = $result->variation_ref_ext;

            if (getDolGlobalString('PRODUIT_MULTIPRICES')) {
                $tmp->fetchCombinationPriceLevels();
            }

            $return[] = $tmp;
        }

        return $return;
    }

    /**
     * Retrieves all product combinations by the product parent row id
     *
     * @param  int     $fk_product_parent  Id of parent product
     * @return int                         Nb of record
     */
    public function countNbOfCombinationForFkProductParent($fk_product_parent)
    {
        $nb = 0;
        $sql = "SELECT count(rowid) as nb FROM " . MAIN_DB_PREFIX . "product_attribute_combination WHERE fk_product_parent = " . ((int) $fk_product_parent) . " AND entity IN (" . getEntity('product') . ")";

        $resql = $this->db->query($sql);
        if ($resql) {
            $obj = $this->db->fetch_object($resql);
            if ($obj) {
                $nb = $obj->nb;
            }
        }

        return $nb;
    }

    /**
     * Creates a product attribute combination
     *
     * @param   User    $user   Object user
     * @return  int             Return integer <0 if KO, >0 if OK
     */
    public function create($user)
    {
        global $conf;

        /* $this->fk_product_child may be empty and will be filled later after subproduct has been created */

        $sql = "INSERT INTO " . MAIN_DB_PREFIX . "product_attribute_combination";
        $sql .= " (fk_product_parent, fk_product_child, variation_price, variation_price_percentage, variation_weight, variation_ref_ext, entity)";
        $sql .= " VALUES (" . ((int) $this->fk_product_parent) . ", " . ((int) $this->fk_product_child) . ",";
        $sql .= (float) $this->variation_price . ", " . (int) $this->variation_price_percentage . ",";
        $sql .= (float) $this->variation_weight . ", '" . $this->db->escape($this->variation_ref_ext) . "', " . (int) $this->entity . ")";

        $resql = $this->db->query($sql);
        if ($resql) {
            $this->id = $this->db->last_insert_id(MAIN_DB_PREFIX . 'product_attribute_combination');
        } else {
            $this->error = $this->db->lasterror();
            return -1;
        }

        if (getDolGlobalString('PRODUIT_MULTIPRICES')) {
            $res = $this->saveCombinationPriceLevels();
            if ($res < 0) {
                return -2;
            }
        }

        return 1;
    }

    /**
     * Updates a product combination
     *
     * @param   User    $user       Object user
     * @return                      int Return integer <0 KO, >0 OK
     */
    public function update(User $user)
    {
        global $conf;

        $sql = "UPDATE " . MAIN_DB_PREFIX . "product_attribute_combination";
        $sql .= " SET fk_product_parent = " . (int) $this->fk_product_parent . ", fk_product_child = " . (int) $this->fk_product_child . ",";
        $sql .= " variation_price = " . (float) $this->variation_price . ", variation_price_percentage = " . (int) $this->variation_price_percentage . ",";
        $sql .= " variation_ref_ext = '" . $this->db->escape($this->variation_ref_ext) . "',";
        $sql .= " variation_weight = " . (float) $this->variation_weight . " WHERE rowid = " . ((int) $this->id);

        $resql = $this->db->query($sql);
        if (!$resql) {
            return -1;
        }

        if (getDolGlobalString('PRODUIT_MULTIPRICES')) {
            $res = $this->saveCombinationPriceLevels();
            if ($res < 0) {
                return -2;
            }
        }

        $parent = new Product($this->db);
        $parent->fetch($this->fk_product_parent);

        $this->updateProperties($parent, $user);

        return 1;
    }

    /**
     * Deletes a product combination
     *
     * @param   User    $user   Object user
     * @return  int             Return integer <0 if KO, >0 if OK
     */
    public function delete(User $user)
    {
        $this->db->begin();

        $comb2val = new ProductCombination2ValuePair($this->db);
        $comb2val->deleteByFkCombination($this->id);

        // remove combination price levels
        if (!$this->db->query("DELETE FROM " . MAIN_DB_PREFIX . "product_attribute_combination_price_level WHERE fk_product_attribute_combination = " . (int) $this->id)) {
            $this->db->rollback();
            return -1;
        }

        $sql = "DELETE FROM " . MAIN_DB_PREFIX . "product_attribute_combination WHERE rowid = " . (int) $this->id;

        if ($this->db->query($sql)) {
            $this->db->commit();
            return 1;
        }

        $this->db->rollback();
        return -1;
    }

    /**
     * Deletes all product combinations of a parent product
     *
     * @param User      $user Object user
     * @param int       $fk_product_parent Rowid of parent product
     * @return int Return integer <0 KO >0 OK
     */
    public function deleteByFkProductParent($user, $fk_product_parent)
    {
        $this->db->begin();

        foreach ($this->fetchAllByFkProductParent($fk_product_parent) as $prodcomb) {
            $prodstatic = new Product($this->db);

            $res = $prodstatic->fetch($prodcomb->fk_product_child);

            if ($res > 0) {
                $res = $prodcomb->delete($user);
            }

            if ($res > 0 && !$prodstatic->isObjectUsed($prodstatic->id)) {
                $res = $prodstatic->delete($user);
            }

            if ($res < 0) {
                $this->db->rollback();
                return -1;
            }
        }

        $this->db->commit();
        return 1;
    }

    /**
     * Updates the weight of the child product. The price must be updated using Product::updatePrices.
     * This method is called by the update() of a product.
     *
     * @param   Product $parent     Parent product
     * @param   User    $user       Object user
     * @return  int                 >0 if OK, <0 if KO
     */
    public function updateProperties(Product $parent, User $user)
    {
        global $conf;

        $this->db->begin();

        $child = new Product($this->db);
        $child->fetch($this->fk_product_child);

        $child->price_autogen = $parent->price_autogen;
        $child->weight = $parent->weight;
        // Only when Parent Status are updated
        if (is_object($parent->oldcopy) && !$parent->oldcopy->isEmpty() && ($parent->status != $parent->oldcopy->status)) {
            $child->status = $parent->status;
        }
        if (is_object($parent->oldcopy) && !$parent->oldcopy->isEmpty() && ($parent->status_buy != $parent->oldcopy->status_buy)) {
            $child->status_buy = $parent->status_buy;
        }

        if ($this->variation_weight) {  // If we must add a delta on weight
            $child->weight = ($child->weight ? $child->weight : 0) + $this->variation_weight;
        }
        $child->weight_units = $parent->weight_units;

        // Don't update the child label if the user has already modified it.
        if ($child->label == $parent->label) {
            // This will trigger only at variant creation time
            $varlabel               = $this->getCombinationLabel($this->fk_product_child);
            $child->label           = $parent->label . $varlabel;
        }


        if ($child->update($child->id, $user) > 0) {
            $new_vat = $parent->tva_tx;
            $new_npr = $parent->tva_npr;

            // MultiPrix
            if (getDolGlobalString('PRODUIT_MULTIPRICES')) {
                $produit_multiprices_limit = getDolGlobalString('PRODUIT_MULTIPRICES_LIMIT');
                for ($i = 1; $i <= $produit_multiprices_limit; $i++) {
                    if ($parent->multiprices[$i] != '' || isset($this->combination_price_levels[$i]->variation_price)) {
                        $new_type = empty($parent->multiprices_base_type[$i]) ? 'HT' : $parent->multiprices_base_type[$i];
                        $new_min_price = $parent->multiprices_min[$i];
                        $variation_price = (float) (!isset($this->combination_price_levels[$i]->variation_price) ? $this->variation_price : $this->combination_price_levels[$i]->variation_price);
                        $variation_price_percentage = (float) (!isset($this->combination_price_levels[$i]->variation_price_percentage) ? $this->variation_price_percentage : $this->combination_price_levels[$i]->variation_price_percentage);

                        if ($parent->prices_by_qty_list[$i]) {
                            $new_psq = 1;
                        } else {
                            $new_psq = 0;
                        }

                        if ($new_type == 'TTC') {
                            $new_price = $parent->multiprices_ttc[$i];
                        } else {
                            $new_price = $parent->multiprices[$i];
                        }

                        if ($variation_price_percentage) {
                            if ($new_price != 0) {
                                $new_price *= 1 + ($variation_price / 100);
                            }
                        } else {
                            $new_price += $variation_price;
                        }

                        $ret = $child->updatePrice($new_price, $new_type, $user, $new_vat, $new_min_price, $i, $new_npr, $new_psq, 0, array(), $parent->default_vat_code);

                        if ($ret < 0) {
                            $this->db->rollback();
                            $this->error = $child->error;
                            $this->errors = $child->errors;
                            return $ret;
                        }
                    }
                }
            } else {
                $new_type = $parent->price_base_type;
                $new_min_price = $parent->price_min;
                $new_psq = $parent->price_by_qty;

                if ($new_type == 'TTC') {
                    $new_price = $parent->price_ttc;
                } else {
                    $new_price = $parent->price;
                }

                if ($this->variation_price_percentage) {
                    if ($new_price != 0) {
                        $new_price *= 1 + ($this->variation_price / 100);
                    }
                } else {
                    $new_price += $this->variation_price;
                }

                $ret = $child->updatePrice($new_price, $new_type, $user, $new_vat, $new_min_price, 1, $new_npr, $new_psq);

                if ($ret < 0) {
                    $this->db->rollback();
                    $this->error = $child->error;
                    $this->errors = $child->errors;
                    return $ret;
                }
            }

            $this->db->commit();

            return 1;
        }

        $this->db->rollback();
        $this->error = $child->error;
        $this->errors = $child->errors;
        return -1;
    }

    /**
     * Retrieves the combination that matches the given features.
     *
     * @param   int                         $prodid     Id of parent product
     * @param   array<string,string>        $features   Format: [$attr] => $attr_val
     * @return  false|ProductCombination                False if not found
     */
    public function fetchByProductCombination2ValuePairs($prodid, array $features)
    {
        require_once constant('DOL_DOCUMENT_ROOT') . '/variants/class/ProductCombination2ValuePair.class.php';

        $actual_comp = array();

        $prodcomb2val = new ProductCombination2ValuePair($this->db);
        $prodcomb = new ProductCombination($this->db);

        $features = array_filter(
            $features,
            /**
             * @param mixed $v Feature information of a product.
             * @return bool
             */
            static function ($v) {
                return !empty($v);
            }
        );

        foreach ($features as $attr => $attr_val) {
            $actual_comp[$attr] = $attr_val;
        }

        foreach ($prodcomb->fetchAllByFkProductParent($prodid) as $prc) {
            $values = array();

            foreach ($prodcomb2val->fetchByFkCombination($prc->id) as $value) {
                $values[$value->fk_prod_attr] = $value->fk_prod_attr_val;
            }

            $check1 = count(array_diff_assoc($values, $actual_comp));
            $check2 = count(array_diff_assoc($actual_comp, $values));

            if (!$check1 && !$check2) {
                return $prc;
            }
        }

        return false;
    }

    /**
     * Retrieves all unique attributes for a parent product
     * (filtered on its 'to sell' variants)
     *
     * @param   int $productid          Parent Product rowid
     * @return  array<object{id:int,ref:string,label:string,values:ProductAttributeValue[]}>        Array of attributes

     */
    public function getUniqueAttributesAndValuesByFkProductParent($productid)
    {
        require_once constant('DOL_DOCUMENT_ROOT') . '/variants/class/ProductAttribute.class.php';
        require_once constant('DOL_DOCUMENT_ROOT') . '/variants/class/ProductAttributeValue.class.php';

        // Attributes
        // Select all unique attributes of the variants (which are to sell) of a given parent product.
        $sql = "SELECT DISTINCT c2v.fk_prod_attr, a.position";
        $sql .= " FROM " . MAIN_DB_PREFIX . "product_attribute_combination2val c2v";
        $sql .= " LEFT JOIN " . MAIN_DB_PREFIX . "product_attribute_combination c";
        $sql .= "   ON c2v.fk_prod_combination = c.rowid";
        $sql .= " LEFT JOIN " . MAIN_DB_PREFIX . "product p";
        $sql .= "   ON p.rowid = c.fk_product_child";
        $sql .= " LEFT JOIN " . MAIN_DB_PREFIX . "product_attribute a";
        $sql .= "   ON a.rowid = fk_prod_attr";
        $sql .= " WHERE c.fk_product_parent = " . ((int) $productid);
        $sql .= " AND p.tosell = 1";
        $sql .= $this->db->order('a.position', 'asc');

        $resql = $this->db->query($sql);

        // Values
        $variants = array();
        while ($obj = $this->db->fetch_object($resql)) {
            $attr = new ProductAttribute($this->db);
            $attr->fetch($obj->fk_prod_attr);

            $tmp = new stdClass();

            $tmp->id = $attr->id;
            $tmp->ref = $attr->ref;
            $tmp->label = $attr->label;
            $tmp->values = array();

            $attrval = new ProductAttributeValue($this->db);
            // fetch only the used values of this attribute
            foreach ($attrval->fetchAllByProductAttribute($attr->id, true) as $val) {
                '@phan-var-force ProductAttributeValue $val';
                $tmp->values[] = $val;
            }

            $variants[] = $tmp;
        }

        return $variants;
    }

    /**
     * Creates a product combination. Check usages to find more about its use
     * Format of $combinations array:
     * array(
     *  0 => array(
     *      attr => value,
     *      attr2 => value
     *      [...]
     *      ),
     * [...]
     * )
     *
     * @param User                      $user                   User
     * @param Product                   $product                Parent Product
     * @param array<int,int>            $combinations           Attribute and value combinations.
     * @param array<int,array<int,array{weight:string|float,price:string|float}>> $variations   Price and weight variations (example: $variations[fk_product_attribute][fk_product_attribute_value]['weight'])
     * @param bool|bool[]               $price_var_percent      Is the price variation value a relative variation (in %)? (it is an array if global constant "PRODUIT_MULTIPRICES" is on)
     * @param false|float|float[]       $forced_pricevar        Value of the price variation if it is forced ; in currency or percent. (it is an array if global constant "PRODUIT_MULTIPRICES" is on)
     * @param false|float               $forced_weightvar       Value of the weight variation if it is forced
     * @param false|string              $forced_refvar          Value of the reference if it is forced
     * @param string                    $ref_ext                External reference
     * @return int<-1,1>                                        Return integer <0 KO, >0 OK
     */
    public function createProductCombination(User $user, Product $product, array $combinations, array $variations, $price_var_percent = false, $forced_pricevar = false, $forced_weightvar = false, $forced_refvar = false, $ref_ext = '')
    {
        global $conf;

        require_once constant('DOL_DOCUMENT_ROOT') . '/variants/class/ProductAttribute.class.php';
        require_once constant('DOL_DOCUMENT_ROOT') . '/variants/class/ProductAttributeValue.class.php';

        $this->db->begin();

        $price_impact = array(1 => 0); // init level price impact

        $forced_refvar = trim((string) $forced_refvar);

        if (!empty($forced_refvar) && $forced_refvar != $product->ref) {
            $existingProduct = new Product($this->db);
            $result = $existingProduct->fetch(0, $forced_refvar);
            if ($result > 0) {
                $newproduct = $existingProduct;
            } else {
                $existingProduct = false;
                $newproduct = clone $product;
                $newproduct->ref = $forced_refvar;
            }
        } else {
            $forced_refvar = false;
            $existingProduct = false;
            $newproduct = clone $product;
        }

        //Final weight impact
        $weight_impact = (float) $forced_weightvar; // If false, return 0

        //Final price impact
        if (!is_array($forced_pricevar)) {
            $price_impact[1] = (float) $forced_pricevar; // If false, return 0
        } else {
            $price_impact = $forced_pricevar;
        }

        if (!array($price_var_percent)) {
            $price_var_percent[1] = (float) $price_var_percent;
        }

        $newcomb = new ProductCombination($this->db);
        $existingCombination = $newcomb->fetchByProductCombination2ValuePairs($product->id, $combinations);

        if ($existingCombination) {
            $newcomb = $existingCombination;
        } else {
            $newcomb->fk_product_parent = $product->id;

            // Create 1 entry into product_attribute_combination (1 entry for each combinations). This init also $newcomb->id
            $result = $newcomb->create($user);
            if ($result < 0) {
                $this->error = $newcomb->error;
                $this->errors = $newcomb->errors;
                $this->db->rollback();
                return -1;
            }
        }

        $prodattr = new ProductAttribute($this->db);
        $prodattrval = new ProductAttributeValue($this->db);

        // $combination contains list of attributes pairs key->value. Example: array('id Color'=>id Blue, 'id Size'=>id Small, 'id Option'=>id val a, ...)
        foreach ($combinations as $currcombattr => $currcombval) {
            //This was checked earlier, so no need to double check
            $prodattr->fetch($currcombattr);
            $prodattrval->fetch($currcombval);

            //If there is an existing combination, there is no need to duplicate the valuepair
            if (!$existingCombination) {
                $tmp = new ProductCombination2ValuePair($this->db);
                $tmp->fk_prod_attr = $currcombattr;
                $tmp->fk_prod_attr_val = $currcombval;
                $tmp->fk_prod_combination = $newcomb->id;

                if ($tmp->create($user) < 0) {      // Create 1 entry into product_attribute_combination2val
                    $this->error = $tmp->error;
                    $this->errors = $tmp->errors;
                    $this->db->rollback();
                    return -1;
                }
            }
            if ($forced_weightvar === false) {
                $weight_impact += (float) price2num($variations[$currcombattr][$currcombval]['weight']);
            }
            if ($forced_pricevar === false) {
                $price_impact[1] += (float) price2num($variations[$currcombattr][$currcombval]['price']);

                // Manage Price levels
                if (getDolGlobalString('PRODUIT_MULTIPRICES')) {
                    $produit_multiprices_limit = getDolGlobalString('PRODUIT_MULTIPRICES_LIMIT');
                    for ($i = 2; $i <= $produit_multiprices_limit; $i++) {
                        $price_impact[$i] += (float) price2num($variations[$currcombattr][$currcombval]['price']);
                    }
                }
            }

            if ($forced_refvar === false) {
                if (isset($conf->global->PRODUIT_ATTRIBUTES_SEPARATOR)) {
                    $newproduct->ref .= getDolGlobalString('PRODUIT_ATTRIBUTES_SEPARATOR') . $prodattrval->ref;
                } else {
                    $newproduct->ref .= '_' . $prodattrval->ref;
                }
            }

            //The first one should not contain a linebreak
            if ($newproduct->description) {
                $newproduct->description .= '<br>';
            }
            $newproduct->description .= '<strong>' . $prodattr->label . ':</strong> ' . $prodattrval->value;
        }

        $newcomb->variation_price_percentage = $price_var_percent[1];
        $newcomb->variation_price = $price_impact[1];
        $newcomb->variation_weight = $weight_impact;
        $newcomb->variation_ref_ext = $this->db->escape($ref_ext);

        // Init price level
        if (getDolGlobalString('PRODUIT_MULTIPRICES')) {
            $produit_multiprices_limit = getDolGlobalString('PRODUIT_MULTIPRICES_LIMIT');
            for ($i = 1; $i <= $produit_multiprices_limit; $i++) {
                $productCombinationLevel = new ProductCombinationLevel($this->db);
                $productCombinationLevel->fk_product_attribute_combination = $newcomb->id;
                $productCombinationLevel->fk_price_level = $i;
                $productCombinationLevel->variation_price = $price_impact[$i];

                if (is_array($price_var_percent)) {
                    $productCombinationLevel->variation_price_percentage = (empty($price_var_percent[$i]) ? false : $price_var_percent[$i]);
                } else {
                    $productCombinationLevel->variation_price_percentage = $price_var_percent;
                }

                $newcomb->combination_price_levels[$i] = $productCombinationLevel;
            }
        }
        //var_dump($newcomb->combination_price_levels);

        $newproduct->weight += $weight_impact;

        // Now create the product
        //print 'Create prod '.$newproduct->ref.'<br>'."\n";
        if ($existingProduct === false) {
            //To avoid wrong information in price history log
            $newproduct->price = 0;
            $newproduct->price_ttc = 0;
            $newproduct->price_min = 0;
            $newproduct->price_min_ttc = 0;

            // A new variant must use a new barcode (not same product)
            $newproduct->barcode = -1;
            $result = $newproduct->create($user);

            if ($result < 0) {
                //In case the error is not related with an already existing product
                if ($newproduct->error != 'ErrorProductAlreadyExists') {
                    $this->error = $newproduct->error;
                    $this->errors = $newproduct->errors;
                    $this->db->rollback();
                    return -1;
                }

                /**
                 * If there is an existing combination, then we update the prices and weight
                 * Otherwise, we try adding a random number to the ref
                 */

                if ($newcomb->fk_product_child) {
                    $res = $newproduct->fetch($existingCombination->fk_product_child);
                } else {
                    $orig_prod_ref = $newproduct->ref;
                    $i = 1;

                    do {
                        $newproduct->ref = $orig_prod_ref . $i;
                        $res = $newproduct->create($user);

                        if ($newproduct->error != 'ErrorProductAlreadyExists') {
                            $this->errors[] = $newproduct->error;
                            break;
                        }

                        $i++;
                    } while ($res < 0);
                }

                if ($res < 0) {
                    $this->db->rollback();
                    return -1;
                }
            }
        } else {
            $result = $newproduct->update($newproduct->id, $user);
            if ($result < 0) {
                $this->db->rollback();
                return -1;
            }
        }

        $newcomb->fk_product_child = $newproduct->id;

        if ($newcomb->update($user) < 0) {
            $this->error = $newcomb->error;
            $this->errors = $newcomb->errors;
            $this->db->rollback();
            return -1;
        }

        $this->db->commit();
        return $newproduct->id;
    }

    /**
     * Copies all product combinations from the origin product to the destination product
     *
     * @param   User    $user   Object user
     * @param   int     $origProductId  Origin product id
     * @param   Product $destProduct    Destination product
     * @return  int                     >0 OK <0 KO
     */
    public function copyAll(User $user, $origProductId, Product $destProduct)
    {
        require_once constant('DOL_DOCUMENT_ROOT') . '/variants/class/ProductCombination2ValuePair.class.php';

        //To prevent a loop
        if ($origProductId == $destProduct->id) {
            return -1;
        }

        $prodcomb2val = new ProductCombination2ValuePair($this->db);

        //Retrieve all product combinations
        $combinations = $this->fetchAllByFkProductParent($origProductId);

        foreach ($combinations as $combination) {
            $variations = array();

            foreach ($prodcomb2val->fetchByFkCombination($combination->id) as $tmp_pc2v) {
                $variations[$tmp_pc2v->fk_prod_attr] = $tmp_pc2v->fk_prod_attr_val;
            }

            if (
                $this->createProductCombination(
                $user,
                $destProduct,
                $variations,
                array(),
                $combination->variation_price_percentage,
                $combination->variation_price,
                $combination->variation_weight
                ) < 0
            ) {
                return -1;
            }
        }

        return 1;
    }

    /**
     * Return label for combinations
     * @param   int     $prod_child     id of child
     * @return  string                  combination label
     */
    public function getCombinationLabel($prod_child)
    {
        $label = '';
        $sql = 'SELECT pav.value AS label';
        $sql .= ' FROM ' . MAIN_DB_PREFIX . 'product_attribute_combination pac';
        $sql .= ' INNER JOIN ' . MAIN_DB_PREFIX . 'product_attribute_combination2val pac2v ON pac2v.fk_prod_combination=pac.rowid';
        $sql .= ' INNER JOIN ' . MAIN_DB_PREFIX . 'product_attribute_value pav ON pav.rowid=pac2v.fk_prod_attr_val';
        $sql .= ' WHERE pac.fk_product_child=' . ((int) $prod_child);

        $resql = $this->db->query($sql);
        if ($resql) {
            $num = $this->db->num_rows($resql);

            $i = 0;

            while ($i < $num) {
                $obj = $this->db->fetch_object($resql);

                if ($obj->label) {
                    $label .= ' ' . $obj->label;
                }
                $i++;
            }
        }
        return $label;
    }
}

alxarafe / alixar

Push — EXTRACT_CLASSES ( a2ff75...ae6b5c )

ProductCombination::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
