Dolibarr\Code\Variants\Classes\ProductCombination::createProductCombination()

Complexity

Conditions	31
Paths	> 20000

Size

Total Lines	211
Code Lines	128

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    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;
    }