{

/** @var int|null Module ID */

public $id = null;

/** @var string Version */

public $version;

public $database_version;

/** @var array filled with known compliant PS versions */

public $ps_versions_compliancy = [];

/** @var array filled with modules needed for install */

public $dependencies = [];

/** @var string|int|null Unique name */

public $name;

/** @var string Human name */

public $displayName;

/** @var string A little description of the module */

public $description;

/**

public $confirmUninstall = '';

/** @var string author of the module */

public $author;

/** @var string URI author of the module */

public $author_uri = '';

/** @var string Module key provided by addons.prestashop.com */

public $module_key = '';

/**

public $bootstrap = false;

public $description_full;

public $additional_description;

public $compatibility;

public $nb_rates;

public $avg_rate;

public $badges;

/** @var string */

public $message = '';

/** @var string */

public $logo = '';

/** @var array */

public $options;

/** @var int need_instance */

public $need_instance = 1;

/** @var int */

public $is_configurable = 0;

/** @var string Admin tab corresponding to the module */

public $tab = null;

/** @var bool Status */

public $active = false;

/** @var string Fill it if the module is installed but not yet set up */

public $warning;

/**

public $enable_device = 7;

/** @var array to store the limited country */

public $limited_countries = [];

/** @var array names of the controllers */

public $controllers = [];

/** @var bool */

public $installed;

/** @var bool */

public $onclick_option = false;

/** @var string|null */

public $url = null;

/** @var string|null */

public $image = null;

/** @var string|null */

public $price = null;

/** @var string|null Can be addonsPartner|addonsNative */

public $type = null;

/** @var array used by AdminTab to determine which lang file to use (admin.php or module lang file) */

public static $classInModule = [];

/** @var array current language translations */

protected $_lang = [];

/** @var string Module web path (eg. '/shop/modules/modulename/') */

protected $_path = null;

/**

protected $local_path = null;

/** @var array Array filled with module errors */

protected $_errors = [];

/** @var array Array array filled with module success */

protected $_confirmations = [];

/** @var string Main table used for modules installed */

protected $table = 'module';

/** @var string Identifier of the main table */

protected $identifier = 'id_module';

/** @var array|null Array cache filled with modules informations */

protected static $modules_cache;

/** @var array Array cache filled with modules instances */

protected static $_INSTANCE = [];

/** @var bool Config xml generation mode */

protected static $_generate_config_xml_mode = false;

/** @var array Array filled with cache translations */

protected static $l_cache = [];

/** @var array Array filled with cache permissions (modules / employee profiles) */

protected static $cache_permissions = [];

/** @var array Array filled with cache permissions (modules / employee profiles) */

protected static $cache_lgc_access = [];

/** @var Context */

protected $context;

/** @var Smarty_Data|Smarty_Internal_TemplateBase */

protected $smarty;

/** @var Smarty_Internal_Template|null */

protected $current_subtemplate = null;

protected static $update_translations_after_install = true;

protected static $_batch_mode = false;

protected static $_defered_clearCache = [];

protected static $_defered_func_call = [];

/**

protected $tabs = [];

/** @var ContainerInterface */

private $container;

/** @var array|null used to cache module ids */

protected static $cachedModuleNames = null;

/** @var int Defines the multistore compatibility level of the module */

public $multistoreCompatibility = self::MULTISTORE_COMPATIBILITY_UNKNOWN;

public const MULTISTORE_COMPATIBILITY_NO = -20;

public const MULTISTORE_COMPATIBILITY_NOT_CONCERNED = -10;

public const MULTISTORE_COMPATIBILITY_UNKNOWN = 0;

public const MULTISTORE_COMPATIBILITY_PARTIAL = 10;

public const MULTISTORE_COMPATIBILITY_YES = 20;

public static function setContextInstanceForTesting(Context $context)

{

/** @var Module $module */

foreach (static::$_INSTANCE as $module) {

$module->context = $context;

}

}

/**

public static function setBatchMode($value)

{

static::$_batch_mode = (bool) $value;

}

/**

public static function getBatchMode()

{

return static::$_batch_mode;

}

public static function processDeferedFuncCall()

{

static::setBatchMode(false);

foreach (static::$_defered_func_call as $func_call) {

call_user_func_array($func_call[0], $func_call[1]);

}

static::$_defered_func_call = [];

}

/**

public static function processDeferedClearCache()

{

static::setBatchMode(false);

foreach (static::$_defered_clearCache as $clearCache_array) {

static::_deferedClearCache($clearCache_array[0], $clearCache_array[1], $clearCache_array[2]);

}

static::$_defered_clearCache = [];

}

/**

public function __construct($name = null, ?Context $context = null)

{

if ($name !== null) {

Tools::displayParameterAsDeprecated('name');

}

if (!isset($this->ps_versions_compliancy['min'])) {

$this->ps_versions_compliancy['min'] = '1.4.0.0';

}

if (!isset($this->ps_versions_compliancy['max'])) {

$this->ps_versions_compliancy['max'] = _PS_VERSION_;

}

$minParts = explode('.', $this->ps_versions_compliancy['min']);

$maxParts = explode('.', $this->ps_versions_compliancy['max']);

// Since v8, we don't pad versions

if ((int) current($minParts) < 8) {

$this->ps_versions_compliancy['min'] = str_pad($this->ps_versions_compliancy['min'], 7, '.0');

}

if ((int) current($maxParts) < 8) {

$padLength = strlen($this->ps_versions_compliancy['max']) + (4 - count($maxParts)) * 4;

$this->ps_versions_compliancy['max'] = str_pad($this->ps_versions_compliancy['max'], $padLength, '.999');

}

// Load context and smarty

$this->context = $context ? $context : Context::getContext();

if (is_object($this->context->smarty)) {

$this->smarty = $this->context->smarty->createData($this->context->smarty);

}

// If the module has no name we gave him its id as name

if ($this->name === null) {

$this->name = $this->id;

}

// If the module has the name we load the corresponding data from the cache

if ($this->name != null) {

// If cache is not generated, we generate it

if (static::$modules_cache == null && !is_array(static::$modules_cache)) {

$id_shop = (Validate::isLoadedObject($this->context->shop) ? $this->context->shop->id : Configuration::get('PS_SHOP_DEFAULT'));

static::$modules_cache = [];

// Join clause is done to check if the module is activated in current shop context

$result = Db::getInstance()->executeS('

FROM `' . _DB_PREFIX_ . 'module` m

LEFT JOIN `' . _DB_PREFIX_ . 'module_shop` ms

AND ms.`id_shop` = ' . (int) $id_shop);

foreach ($result as $row) {

static::$modules_cache[$row['name']] = $row;

static::$modules_cache[$row['name']]['active'] = ($row['mshop'] > 0) ? 1 : 0;

}

}

// We load configuration from the cache

if (isset(static::$modules_cache[$this->name])) {

if (isset(static::$modules_cache[$this->name]['id_module'])) {

$this->id = static::$modules_cache[$this->name]['id_module'];

}

foreach (static::$modules_cache[$this->name] as $key => $value) {

if (array_key_exists($key, get_object_vars($this))) {

$this->{$key} = $value;

}

}

$this->_path = __PS_BASE_URI__ . 'modules/' . $this->name . '/';

}

if (!$this->context->controller instanceof Controller) {

static::$modules_cache = null;

}

$this->local_path = _PS_MODULE_DIR_ . $this->name . '/';

}

}

/**

public function install()

{

Hook::exec('actionModuleInstallBefore', ['object' => $this]);

// Check module name validation

if (!Validate::isModuleName($this->name)) {

$this->_errors[] = Context::getContext()->getTranslator()->trans('Unable to install the module (Module name is not valid).', [], 'Admin.Modules.Notification');

return false;

}

// Check PS version compliancy

if (!$this->checkCompliancy()) {

$this->_errors[] = Context::getContext()->getTranslator()->trans('The version of your module is not compliant with your PrestaShop version.', [], 'Admin.Modules.Notification');

return false;

}

// Check module dependencies

if (count($this->dependencies) > 0) {

foreach ($this->dependencies as $dependency) {

if (!Db::getInstance()->getRow('SELECT `id_module` FROM `' . _DB_PREFIX_ . 'module` WHERE LOWER(`name`) = \'' . pSQL(Tools::strtolower($dependency)) . '\'')) {

$error = Context::getContext()->getTranslator()->trans('Before installing this module, you have to install this/these module(s) first:', [], 'Admin.Modules.Notification') . '<br />';

foreach ($this->dependencies as $d) {

$error .= '- ' . $d . '<br />';

}

$this->_errors[] = $error;

return false;

}

}

}

// Check if module is installed

$result = (new ModuleDataProvider(new LegacyLogger(), $this->getTranslator()))->isInstalled($this->name);

if ($result) {

$this->_errors[] = Context::getContext()->getTranslator()->trans('This module has already been installed.', [], 'Admin.Modules.Notification');

return false;

}

// Check for override conflicts

$moduleOverrideChecker = $this->get(ModuleOverrideChecker::class);

if (!$moduleOverrideChecker) {

$moduleOverrideChecker = new ModuleOverrideChecker($this->getTranslator(), _PS_OVERRIDE_DIR_);

}

if ($moduleOverrideChecker->hasOverrideConflict($this->getLocalPath() . 'override')) {

$this->_errors = array_merge($moduleOverrideChecker->getErrors(), $this->_errors);

return false;

}

if (!$this->installControllers()) {

$this->_errors[] = Context::getContext()->getTranslator()->trans('Could not install module controllers.', [], 'Admin.Modules.Notification');

$this->uninstallOverrides();

return false;

}

// Install module and retrieve the installation id

$result = Db::getInstance()->insert($this->table, [

'name' => $this->name,

'active' => 1,

'version' => $this->version,

]);

if (!$result) {

$this->_errors[] = Context::getContext()->getTranslator()->trans('Technical error: PrestaShop could not install this module.', [], 'Admin.Modules.Notification');

if (method_exists($this, 'uninstallTabs')) {

$this->uninstallTabs();

}

$this->uninstallOverrides();

return false;

}

$this->id = Db::getInstance()->Insert_ID();

Cache::clean('Module::isInstalled' . $this->name);

Cache::clean('Module::getModuleIdByName_' . pSQL($this->name));

// Enable the module for current shops in context

if (!$this->enable()) {

return false;

}

// Permissions management

foreach (['CREATE', 'READ', 'UPDATE', 'DELETE'] as $action) {

$slug = Permission::PREFIX_MODULE . strtoupper($this->name) . '_' . $action;

Db::getInstance()->execute(

'INSERT INTO `' . _DB_PREFIX_ . 'authorization_role` (`slug`) VALUES ("' . $slug . '")'

);

Db::getInstance()->execute('

INSERT INTO `' . _DB_PREFIX_ . 'module_access` (`id_profile`, `id_authorization_role`) (

SELECT id_profile, "' . Db::getInstance()->Insert_ID() . '"

FROM ' . _DB_PREFIX_ . 'access a

LEFT JOIN `' . _DB_PREFIX_ . 'authorization_role` r

WHERE r.slug = "ROLE_MOD_TAB_ADMINMODULESSF_' . $action . '"

)');

}

// Adding Restrictions for client groups

Group::addRestrictionsForModule($this->id, Shop::getShops(true, null, true));

Hook::exec('actionModuleInstallAfter', ['object' => $this]);

if (Module::$update_translations_after_install) {

$this->updateModuleTranslations();

}

return true;

}

/**

public function postInstall()

{

return true;

}

public function checkCompliancy()

{

if (version_compare(_PS_VERSION_, $this->ps_versions_compliancy['min'], '<') || version_compare(_PS_VERSION_, $this->ps_versions_compliancy['max'], '>')) {

return false;

} else {

return true;

}

}

public static function updateTranslationsAfterInstall($update = true)

{

Module::$update_translations_after_install = (bool) $update;

}

public function updateModuleTranslations()

{

return Language::updateModulesTranslations([$this->name]);

}

/**

protected function setUpgradeMessage($upgrade_detail)

{

// Store information if a module has been upgraded (memory optimization)

if ($upgrade_detail['available_upgrade']) {

$translator = Context::getContext()->getTranslator();

if ($upgrade_detail['success']) {

$this->_confirmations[] = $translator->trans('Current version: %s', [$this->version], 'Admin.Modules.Notification');

$this->_confirmations[] = $translator->trans('%d file update applied', [$upgrade_detail['number_upgraded']], 'Admin.Modules.Notification');

return;

}

if (!$upgrade_detail['number_upgraded']) {

$this->_errors[] = $translator->trans('No update has been applied', [], 'Admin.Modules.Notification');

} else {

$this->_errors[] = $translator->trans('Updated from: %s to %s', [$upgrade_detail['upgraded_from'], $upgrade_detail['upgraded_to']], 'Admin.Modules.Notification');

$this->_errors[] = $translator->trans('%d update left', [$upgrade_detail['number_upgrade_left']], 'Admin.Modules.Notification');

}

if (isset($upgrade_detail['duplicate']) && $upgrade_detail['duplicate']) {

$this->_errors[] = $translator->trans('Module %s cannot be updated this time: please refresh this page to update it.', [$this->name], 'Admin.Modules.Notification');

} else {

$this->_errors[] = $translator->trans('To prevent any problem, this module has been turned off', [], 'Admin.Modules.Notification');

}

}

}

/**

public static function initUpgradeModule($module)

{

if ($module->installed && empty($module->database_version)) {

Module::upgradeModuleVersion($module->name, $module->version);

$module->database_version = $module->version;

}

/*

static::$modules_cache[$module->name]['upgrade'] = [

'success' => false, // bool to know if upgrade succeed or not

'available_upgrade' => 0, // Number of available module before any upgrade

'number_upgraded' => 0, // Number of upgrade done

'number_upgrade_left' => 0,

'upgrade_file_left' => [], // List of the upgrade file left

'version_fail' => 0, // Version of the upgrade failure

'upgraded_from' => 0, // Version number before upgrading anything

'upgraded_to' => 0, // Last upgrade applied

];

// Need Upgrade will check and load upgrade file to the moduleCache upgrade case detail

$ret = $module->installed && Module::needUpgrade($module);

return $ret;

}

/**

public function runUpgradeModule()

{

$upgrade = &static::$modules_cache[$this->name]['upgrade'];

foreach ($upgrade['upgrade_file_left'] as $num => $file_detail) {

foreach ($file_detail['upgrade_function'] as $item) {

if (function_exists($item)) {

$upgrade['success'] = false;

$upgrade['duplicate'] = true;

break 2;

}

}

include $file_detail['file'];

// Call the upgrade function if defined

$upgrade['success'] = false;

foreach ($file_detail['upgrade_function'] as $item) {

if (function_exists($item)) {

$upgrade['success'] = $item($this);

}

}

// Set detail when an upgrade succeed or failed

if ($upgrade['success']) {

++$upgrade['number_upgraded'];

$upgrade['upgraded_to'] = $file_detail['version'];

unset($upgrade['upgrade_file_left'][$num]);

} else {

$upgrade['version_fail'] = $file_detail['version'];

// If any errors, the module is disabled

$this->disable();

break;

}

}

$upgrade['number_upgrade_left'] = count($upgrade['upgrade_file_left']);

// Update module version in DB with the last succeed upgrade

if ($upgrade['upgraded_to']) {

Module::upgradeModuleVersion($this->name, $upgrade['upgraded_to']);

}

$this->setUpgradeMessage($upgrade);

return $upgrade;

}

/**

public static function upgradeModuleVersion($name, $version)

{

return Db::getInstance()->execute('

UPDATE `' . _DB_PREFIX_ . 'module` m

SET m.version = \'' . pSQL($version) . '\'

WHERE m.name = \'' . pSQL($name) . '\'');

}

/**

public static function needUpgrade($module)

{

static::$modules_cache[$module->name]['upgrade']['upgraded_from'] = $module->database_version;

// Check the version of the module with the registered one and look if any upgrade file exist

if (Tools::version_compare($module->version, $module->database_version, '>')) {

/*

$old_version = $module->database_version;

$module = Module::getInstanceByName($module->name);

if ($module instanceof Module) {

return $module->loadUpgradeVersionList($module->name, $module->version, $old_version);

}

}

return null;

}

/**

protected static function loadUpgradeVersionList($module_name, $module_version, $registered_version)

{

/*

static::$modules_cache[$module_name]['upgrade'] = [

'success' => false, // bool to know if upgrade succeed or not

'available_upgrade' => 0, // Number of available module before any upgrade

'number_upgraded' => 0, // Number of upgrade done

'number_upgrade_left' => 0,

'upgrade_file_left' => [], // List of the upgrade file left

'version_fail' => 0, // Version of the upgrade failure

'upgraded_from' => $registered_version, // Version number before upgrading anything

'upgraded_to' => 0, // Last upgrade applied

];

// Prepare list of upgrade files

$list = [];

$upgrade_path = _PS_MODULE_DIR_ . $module_name . '/upgrade/';

// Check if folder exist and it could be read

if (file_exists($upgrade_path) && ($files = scandir($upgrade_path, SCANDIR_SORT_NONE))) {

// Read each file name

foreach ($files as $file) {

if (!in_array($file, ['.', '..', '.svn', 'index.php']) && preg_match('/\.php$/', $file)) {

$tab = explode('-', $file);

if (!isset($tab[1])) {

continue;

}

/*

$file_version = basename($tab[1], '.php');

// Compare version, if minor than actual, we need to upgrade the module

if (count($tab) == 2

&& (Tools::version_compare($file_version, $module_version, '<=')

&& Tools::version_compare($file_version, $registered_version, '>'))) {

$list[] = [

'file' => $upgrade_path . $file,

'version' => $file_version,

'upgrade_function' => [

'upgrade_module_' . str_replace('.', '_', $file_version),

'upgradeModule' . str_replace('.', '', $file_version), ],

];

}

}

}

}

// No files upgrade, then upgrade succeed

if (count($list) == 0) {

static::$modules_cache[$module_name]['upgrade']['success'] = true;

Module::upgradeModuleVersion($module_name, $module_version);

}

usort($list, 'ps_module_version_sort');

static::$modules_cache[$module_name]['upgrade']['upgrade_file_left'] = $list;

static::$modules_cache[$module_name]['upgrade']['available_upgrade'] = count($list);

return (bool) count($list);

}

/**

public static function getUpgradeStatus($module_name)

{

return isset(static::$modules_cache[$module_name])

&& static::$modules_cache[$module_name]['upgrade']['success'];

}

/**

public function uninstall()

{

Hook::exec('actionModuleUninstallBefore', ['object' => $this]);

// Check if module instance is valid

if (!Validate::isUnsignedId($this->id)) {

$this->_errors[] = Context::getContext()->getTranslator()->trans('The module is not installed.', [], 'Admin.Modules.Notification');

return false;

}

// Uninstall all overrides this module may have used

if (!$this->uninstallOverrides()) {

return false;

}

// Retrieve hooks used by the module

$sql = 'SELECT DISTINCT(`id_hook`) FROM `' . _DB_PREFIX_ . 'hook_module` WHERE `id_module` = ' . (int) $this->id;

$result = Db::getInstance()->executeS($sql);

foreach ($result as $row) {

// Unhook this module from each of the hooks

$this->unregisterHook((int) $row['id_hook']);

// Remove all hook conditions that may have been configured - don't confuse it with error exception. :-)

$this->unregisterExceptions((int) $row['id_hook']);

}

// Remove all configured meta data (titles, URLs etc.) for this module's front controllers

foreach ($this->controllers as $controller) {

$page_name = 'module-' . $this->name . '-' . $controller;

$meta = Db::getInstance()->getValue('SELECT id_meta FROM `' . _DB_PREFIX_ . 'meta` WHERE page="' . pSQL($page_name) . '"');

if ((int) $meta > 0) {

Db::getInstance()->execute('DELETE FROM `' . _DB_PREFIX_ . 'meta_lang` WHERE id_meta=' . (int) $meta);

Db::getInstance()->execute('DELETE FROM `' . _DB_PREFIX_ . 'meta` WHERE id_meta=' . (int) $meta);

}

}

// Disable the module for all shops

$this->disable(true);

// Delete permissions module access

$roles = Db::getInstance()->executeS('SELECT `id_authorization_role` FROM `' . _DB_PREFIX_ . 'authorization_role` WHERE `slug` LIKE "' . Permission::PREFIX_MODULE . strtoupper($this->name) . '_%"');

if (!empty($roles)) {

foreach ($roles as $role) {

Db::getInstance()->execute(

'DELETE FROM `' . _DB_PREFIX_ . 'module_access` WHERE `id_authorization_role` = ' . $role['id_authorization_role']

);

Db::getInstance()->execute(

'DELETE FROM `' . _DB_PREFIX_ . 'authorization_role` WHERE `id_authorization_role` = ' . $role['id_authorization_role']

);

}

}

// Remove restrictions for client groups

Group::truncateRestrictionsByModule($this->id);

// Uninstall the module

if (Db::getInstance()->execute('DELETE FROM `' . _DB_PREFIX_ . 'module` WHERE `id_module` = ' . (int) $this->id)) {

Cache::clean('Module::isInstalled' . $this->name);

Cache::clean('Module::getModuleIdByName_' . pSQL($this->name));

Hook::exec('actionModuleUninstallAfter', ['object' => $this]);

return true;

}

return false;

}

/**

public static function enableByName($name)

{

// If $name is not an array, we set it as an array

if (!is_array($name)) {

$name = [$name];

}

$res = true;

// Enable each module

foreach ($name as $n) {

if (Validate::isModuleName($n)) {

$res &= Module::getInstanceByName($n)->enable();

}

}

return $res;

}

/**

public function enable($force_all = false)

{

// Retrieve all shops where the module is enabled

$list = Shop::getContextListShopID();

if (!$this->id || !is_array($list)) {

return false;

}

$sql = 'SELECT `id_shop` FROM `' . _DB_PREFIX_ . 'module_shop`

WHERE `id_module` = ' . (int) $this->id .

((!$force_all) ? ' AND `id_shop` IN(' . implode(', ', $list) . ')' : '');

// Store the results in an array

$items = [];

if ($results = Db::getInstance()->executeS($sql)) {

foreach ($results as $row) {

$items[] = $row['id_shop'];

}

}

$moduleOverrideChecker = $this->get(ModuleOverrideChecker::class);

if (!$moduleOverrideChecker) {

$moduleOverrideChecker = new ModuleOverrideChecker($this->getTranslator(), _PS_OVERRIDE_DIR_);

}

if ($this->getOverrides() != null) {

if (!$moduleOverrideChecker->hasOverrideConflict($this->getLocalPath() . 'override')) {

// Install overrides

try {

$this->installOverrides();

} catch (Exception $e) {

$this->_errors[] = Context::getContext()->getTranslator()->trans('Unable to install override: %s', [$e->getMessage()], 'Admin.Modules.Notification');

$this->uninstallOverrides();

return false;

}

} else {

$this->_errors = array_merge($moduleOverrideChecker->getErrors(), $this->_errors);

return false;

}

}

// Enable module in the shop where it is not enabled yet

$moduleActivated = false;

foreach ($list as $id) {

if (!in_array($id, $items)) {

Db::getInstance()->insert('module_shop', [

'id_module' => $this->id,

'id_shop' => $id,

]);

$moduleActivated = true;

}

}

// set active to 1 in the module table

Db::getInstance()->update('module', ['active' => 1], 'id_module = ' . (int) $this->id);

if ($moduleActivated) {

$this->loadBuiltInTranslations();

}

return true;

}

/**

public function enableDevice($device)

{

@trigger_error(

sprintf(

'%s is deprecated since version 9.0.0. There is no replacement.',

__METHOD__

),

E_USER_DEPRECATED

);

return true;

}

/**

public function disableDevice($device)

{

@trigger_error(

sprintf(

'%s is deprecated since version 9.0.0. There is no replacement.',

__METHOD__

),

E_USER_DEPRECATED

);

return true;

}

/**

public static function disableAllByName($name)

{