tecdefaultcombination.php

<?php
/**
 * 2009-2026 Tecnoacquisti.com
 *
 * For support feel free to contact us on our website at http://www.tecnoacquisti.com
 *
 * @author    Arte e Informatica <helpdesk@tecnoacquisti.com>
 * @copyright 2009-2026 Arte e Informatica
 * @license   https://opensource.org/licenses/MIT MIT License
 * @version   1.0.0
 */
if (!defined('_PS_VERSION_')) {
    exit;
}

class TecDefaultCombination extends Module
{
    public function __construct()
    {
        $this->name = 'tecdefaultcombination';
        $this->tab = 'administration';
        $this->version = '1.0.2';
        $this->author = 'Tecnoacquisti.com';
        $this->need_instance = 0;
        $this->bootstrap = true;

        parent::__construct();

        $this->displayName = $this->l('Default Combination by Price');
        $this->description = $this->l('Set default product combination based on lowest price via Cron URL.');
        $this->ps_versions_compliancy = ['min' => '1.7', 'max' => _PS_VERSION_];
    }

    public function install()
    {
        $res = parent::install();
        if ($res) {
            // Ensure a persistent secure key is stored at install time if not already present
            if (class_exists('Configuration')) {
                $cfg = Configuration::get('TECDEFAULTCOMBINATION_SECURE_KEY');
                if (empty($cfg)) {
                    $key = $this->computeModuleSecureKey();
                    Configuration::updateValue('TECDEFAULTCOMBINATION_SECURE_KEY', $key);
                }
                // Ensure debug flag exists (default disabled)
                if (Configuration::get('TECDEFAULTCOMBINATION_DEBUG') === false) {
                    Configuration::updateValue('TECDEFAULTCOMBINATION_DEBUG', 0);
                }
            }
        }

        return $res;
    }

    public function uninstall()
    {
        // Optionally: do not remove the secure key to allow re-installation preserving the key
        return parent::uninstall();
    }

    /**
     * Compute the default combination id (lowest price) for a given product instance.
     * Returns integer id_product_attribute or null if none.
     *
     * @param Product $product
     * @return int|null
     */
    protected function computeDefaultCombinationId(Product $product)
    {
        // Get attribute combinations for the current context language
        $combinations = $product->getAttributeCombinations($this->context->language->id, true);
        if (empty($combinations)) {
            return null;
        }

        // Use Product::getPriceStatic to compute the real effective price for each combination
        // This accounts for combination price impact, specific prices and reductions and is more robust
        $combinationPrices = [];
        foreach ($combinations as $combination) {
            $id_product_attribute = (int)$combination['id_product_attribute'];
            // Use getPriceStatic to obtain the price for this specific combination
            // parameters: id_product, use_tax (true), id_product_attribute
            try {
                $effectivePrice = (float)Product::getPriceStatic((int)$product->id, true, $id_product_attribute);
            } catch (Throwable $e) {
                // Fallback to simple sum if getPriceStatic is unavailable
                $effectivePrice = (float)$product->price + (float)($combination['price'] ?? 0);
            }

            if (!isset($combinationPrices[$id_product_attribute]) || $effectivePrice < $combinationPrices[$id_product_attribute]) {
                $combinationPrices[$id_product_attribute] = $effectivePrice;
            }
        }

        $lowestPrice = min($combinationPrices);
        $defaultCombinationIds = array_keys($combinationPrices, $lowestPrice);
        return (int)$defaultCombinationIds[0];
    }

    /**
     * Imposta la combinazione di default in base al prezzo più basso per un dato prodotto.
     *
     * @param int $id_product L'ID del prodotto
     *
     * @return bool True se l'operazione ha avuto successo, false altrimenti
     */
    public function setDefaultCombinationByLowestPrice($id_product)
    {
        // Istanzia il prodotto per utilizzare il metodo non statico
        $product = new Product($id_product);
        $defaultCombinationId = $this->computeDefaultCombinationId($product);
        if (empty($defaultCombinationId)) {
            return false;
        }

        // Check if current default already matches
        $currentDefault = (int)Db::getInstance()->getValue('SELECT id_product_attribute FROM ' . _DB_PREFIX_ . 'product_attribute WHERE id_product = ' . (int)$id_product . ' AND default_on = 1');
        if ($currentDefault === $defaultCombinationId) {
            return true;
        }

        // Update product_shop and product cache_default_attribute
        Db::getInstance()->execute('UPDATE ' . _DB_PREFIX_ . 'product_shop SET cache_default_attribute = ' . $defaultCombinationId . ' WHERE id_product = ' . (int)$id_product);
        Db::getInstance()->execute('UPDATE ' . _DB_PREFIX_ . 'product SET cache_default_attribute = ' . $defaultCombinationId . ' WHERE id_product = ' . (int)$id_product);

        // Reset default_on flags
        Db::getInstance()->execute('UPDATE ' . _DB_PREFIX_ . 'product_attribute SET default_on = NULL WHERE id_product = ' . (int)$id_product);
        Db::getInstance()->execute('UPDATE ' . _DB_PREFIX_ . 'product_attribute_shop SET default_on = NULL WHERE id_product = ' . (int)$id_product);

        // Set chosen default
        Db::getInstance()->execute('UPDATE ' . _DB_PREFIX_ . 'product_attribute 
        SET default_on = 1 
        WHERE id_product_attribute = ' . (int)$defaultCombinationId
        );
        Db::getInstance()->execute('UPDATE ' . _DB_PREFIX_ . 'product_attribute_shop 
        SET default_on = 1 
        WHERE id_product_attribute = ' . (int)$defaultCombinationId
        );

        // The product cache_default_attribute and product_attribute flags have been updated directly via SQL above.
        // Avoid setting undefined properties on Product and avoid calling save() to prevent issues with
        // static analysis and different PrestaShop versions. The DB is already in the correct state.
        return true;
    }

    /**
     * Funzione Cron per ciclare sui prodotti e impostare la combinazione di default.
     *
     * @return int Numero di prodotti aggiornati
     */
    public function runCron($dryRun = false, $batchSize = 0, $start = 0)
    {
        $lang = isset($this->context->language->id) ? $this->context->language->id : Configuration::get('PS_LANG_DEFAULT');
        $limit = ($batchSize > 0) ? (int)$batchSize : 0;
        $start = max(0, (int)$start);

        // If limit is 0, Product::getProducts expects 0,0 to mean no limit
        $products = Product::getProducts($lang, $start, $limit, 'id_product', 'ASC');
        $updated = 0;
        foreach ($products as $prod) {
            $id_product = (int)$prod['id_product'];
            if ($dryRun) {
                // Compute what the default would be and compare
                $product = new Product($id_product);
                $computedId = $this->computeDefaultCombinationId($product);
                if (!$computedId) {
                    continue;
                }
                $currentDefault = (int)Db::getInstance()->getValue('SELECT id_product_attribute FROM ' . _DB_PREFIX_ . 'product_attribute WHERE id_product = ' . $id_product . ' AND default_on = 1');
                if ($currentDefault !== $computedId) {
                    $updated++;
                }
            } else {
                if ($this->setDefaultCombinationByLowestPrice($id_product)) {
                    $updated++;
                }
            }
        }

        return $updated;
    }

    /**
     * Pagina di configurazione del modulo: mostra l'URL del Cron con il token di sicurezza.
     *
     * @return string HTML
     */
    public function getContent()
    {
        $output = '';
        $useSsl = (bool)Configuration::get('PS_SSL_ENABLED_EVERYWHERE') || (bool)Configuration::get('PS_SSL_ENABLED');
        $shop_base_url = $this->context->link->getBaseLink((int)$this->context->shop->id, $useSsl);

        $errors = [];
        $confirmations = [];

        // Handle form submission
        if (Tools::isSubmit('submit' . $this->name)) {
            $newKey = trim((string)Tools::getValue('TECDEFAULTCOMBINATION_SECURE_KEY'));
            $newDebug = Tools::getValue('TECDEFAULTCOMBINATION_DEBUG', 0);

            // Validate and save secure key if user provided a non-empty valid value
            if ($newKey !== '') {
                if (strtoupper($newKey) === 'NOKEY') {
                    $errors[] = $this->l('Secure key is not valid. Please provide a valid key.');
                } else {
                    Configuration::updateValue('TECDEFAULTCOMBINATION_SECURE_KEY', $newKey);
                    $confirmations[] = $this->l('Secure key updated.');
                }
            }

            // Always save debug flag (even if key invalid)
            $debugInt = ((int)$newDebug === 1) ? 1 : 0;
            Configuration::updateValue('TECDEFAULTCOMBINATION_DEBUG', $debugInt);
            $confirmations[] = $this->l('Debug setting saved.');
        }

        // Show errors and confirmations neatly
        foreach ($errors as $err) {
            $output .= $this->displayError($err);
        }
        if (!empty($confirmations)) {
            $output .= $this->displayConfirmation(implode(' ', $confirmations));
        }

        // Build the helper form
        $defaultLang = (int)Configuration::get('PS_LANG_DEFAULT');
        $fieldsForm[0]['form'] = [
            'legend' => [
                'title' => $this->l('Secure key settings'),
            ],
            'input' => [
                [
                    'type' => 'text',
                    'label' => $this->l('Module secure key'),
                    'name' => 'TECDEFAULTCOMBINATION_SECURE_KEY',
                    'size' => 64,
                    'required' => false,
                    'desc' => $this->l('Set a custom secure key for cron URL. Keep it secret.'),
                ],
                [
                    'type' => 'switch',
                    'label' => $this->l('Enable debug logging'),
                    'name' => 'TECDEFAULTCOMBINATION_DEBUG',
                    'is_bool' => true,
                    'values' => [
                        [
                            'id' => 'debug_on',
                            'value' => 1,
                            'label' => $this->l('Yes'),
                        ],
                        [
                            'id' => 'debug_off',
                            'value' => 0,
                            'label' => $this->l('No'),
                        ],
                    ],
                    'desc' => $this->l('If enabled, cron runs will write logs into modules/tecdefaultcombination/logs/cron.log'),
                ],
            ],
            'submit' => [
                'title' => $this->l('Save'),
            ],
        ];

        $helper = new HelperForm();
        $helper->show_cancel_button = false;
        $helper->module = $this;
        $helper->name_controller = $this->name;
        $helper->token = Tools::getAdminTokenLite('AdminModules');
        $helper->currentIndex = AdminController::$currentIndex . '&configure=' . $this->name;
        $helper->default_form_language = $defaultLang;
        $helper->allow_employee_form_lang = $defaultLang;
        $helper->title = $this->displayName;
        $helper->submit_action = 'submit' . $this->name;
        $helper->tpl_vars = [
            'fields_value' => [
                'TECDEFAULTCOMBINATION_SECURE_KEY' => Tools::getValue('TECDEFAULTCOMBINATION_SECURE_KEY', Configuration::get('TECDEFAULTCOMBINATION_SECURE_KEY')),
                'TECDEFAULTCOMBINATION_DEBUG' => Tools::getValue('TECDEFAULTCOMBINATION_DEBUG', Configuration::get('TECDEFAULTCOMBINATION_DEBUG')),
            ],
            'languages' => $this->context->controller->getLanguages(),
            'id_language' => $this->context->language->id,
        ];

        $output .= $helper->generateForm($fieldsForm);

        // Also show the Cron URL (full key)
        $secure_full = $this->computeModuleSecureKey();
        $secure_key = $secure_full;
        if (property_exists($this, 'context') && isset($this->context->link) && method_exists($this->context->link, 'getModuleLink')) {
            $cron_url = $this->context->link->getModuleLink($this->name, 'cron', ['secure_key' => $secure_key], true);
        } else {
            $cron_url = (defined('__PS_BASE_URI__') ? Tools::getShopDomainSsl(true) . __PS_BASE_URI__ : '')
                . 'index.php?fc=module&module=tecdefaultcombination&controller=cron&secure_key=' . $secure_key;
        }

        $this->context->smarty->assign(['cron_url' => $cron_url]);
        $this->context->smarty->assign(array(
            'shop_base_url' => $shop_base_url,
        ));

        $output .= $this->context->smarty->fetch($this->local_path . 'views/templates/admin/configure.tpl');
        $output .= $this->context->smarty->fetch($this->local_path . 'views/templates/admin/copyright.tpl');

        return $output;
    }

    /**
     * Compute a deterministic secure key for module cron usage.
     * Priority:
     * 1) configuration value TECDEFAULTCOMBINATION_SECURE_KEY (if user sets it in BO)
     * 2) md5(_COOKIE_KEY_ . moduleName) when _COOKIE_KEY_ is defined (PrestaShop standard)
     * 3) fallback to md5(moduleName) to remain deterministic across environments
     *
     * This avoids calling deprecated Tools::encrypt() and works on PS 1.7..9.
     *
     * @return string
     */
    public function computeModuleSecureKey()
    {
        // If admin explicitly set a secure key in configuration, use it
        if (class_exists('Configuration')) {
            $cfg = Configuration::get('TECDEFAULTCOMBINATION_SECURE_KEY');
            if (!empty($cfg)) {
                return (string)$cfg;
            }
        }

        // Use PrestaShop cookie key when available to keep parity with other modules
        if (defined('_COOKIE_KEY_')) {
            return md5(_COOKIE_KEY_ . $this->name);
        }

        // Deterministic fallback
        return md5($this->name);
    }
}