/**
* Final operations after upgrade has been completed
*
* @return void
*/
protected function finalizeUpgrade()
{
if ($this->isForce()) {
if ($this->isNextStepAvailable()) {
$target = 'installed';
$entries = \XLite\Upgrade\Cell::getInstance()->getEntries();
$this->showInfo(null, 1 < count($entries) ? static::t('Modules have been successfully installed') : static::t('Module has been successfully installed'));
if ($this->isOnlySkins()) {
$target = 'layout';
} elseif ($this->getPaymentMethodToInstall()) {
$target = 'payment_settings';
} else {
$target = 'addons_list_installed';
}
} else {
$target = 'addons_list_marketplace';
$this->showError(__FUNCTION__);
}
$this->setReturnURL($this->buildURL('upgrade', '', $this->getActionParamsCommon() + array('redirect' => $target)));
}
// Set cell status
\XLite\Upgrade\Cell::getInstance()->clear(true, false, false);
\XLite\Upgrade\Cell::getInstance()->setUpgraded(true);
// Rebuild cache
if (!($this->isForce() && $this->isOnlySkins())) {
\XLite::setCleanUpCacheFlag(true);
}
}
/**
* Switch module
*
* @return void
*/
protected function doActionSwitch()
{
$changed = false;
$data = (array) \XLite\Core\Request::getInstance()->switch;
$modules = array();
foreach ($this->getModules('switch') as $module) {
$old = !empty($data[$module->getModuleId()]['old']);
$new = !empty($data[$module->getModuleId()]['new']);
if ($old !== $new) {
$module->setEnabled(!$old);
$modules[] = $module;
$changed = true;
}
}
// Flag to rebuild cache
if ($changed) {
\XLite\Core\Database::getRepo('\\XLite\\Model\\Module')->updateInBatch($modules);
\XLite::setCleanUpCacheFlag(true);
}
}
/**
* We send the free license activation key
*
* @return void
*/
protected function doActivateFreeLicense()
{
$info = \XLite\Core\Marketplace::getInstance()->activateFreeLicense(\XLite\Core\Request::getInstance()->email);
if (\XLite\Core\Marketplace::getInstance()->getError()) {
// Marketplace returned an error
$message = \XLite\Core\Marketplace::getInstance()->getError();
if (\XLite\Core\Marketplace::ERROR_CODE_FREE_LICENSE_REGISTERED == \XLite\Core\Marketplace::getInstance()->getLastErrorCode()) {
// Free license is already registered: prepare specific error message
$message = static::t('Free license key for this email is already registered', array('email' => \XLite\Core\Request::getInstance()->email, 'url' => $this->buildURL('activate_free_license', 'resend_key', array('email' => \XLite\Core\Request::getInstance()->email))));
}
\XLite\Core\TopMessage::addError($message);
} elseif ($info && isset($info[\XLite\Core\Marketplace::XC_FREE_LICENSE_KEY])) {
// License key is successfully activated: register the key in database
$key = $info[\XLite\Core\Marketplace::XC_FREE_LICENSE_KEY][0];
// Get key value from the response field 'key' or (if empty) use default value
$keyValue = !empty($key[\XLite\Core\Marketplace::FIELD_KEY]) ? $key[\XLite\Core\Marketplace::FIELD_KEY] : \XLite\Core\Marketplace::XC_FREE_LICENSE_KEY;
\XLite\Core\Database::getRepo('\\XLite\\Model\\ModuleKey')->insert($key + array('keyValue' => $keyValue));
// Clear cache for proper installation
\XLite\Core\Marketplace::getInstance()->clearActionCache(\XLite\Core\Marketplace::ACTION_GET_ADDONS_LIST);
// Search for modules from non-free edition
$nonFreeModules = \XLite\Core\Database::getRepo('XLite\\Model\\Module')->getNonFreeEditionModulesList(false);
if ($nonFreeModules) {
// Try to uninstall these modules...
foreach ($nonFreeModules as $module) {
$messages = array();
$res = \XLite\Core\Database::getRepo('XLite\\Model\\Module')->uninstallModule($module, $messages);
if ($messages) {
foreach ($messages as $message) {
$method = $res ? 'Info' : 'Error';
\XLite\Upgrade\Logger::getInstance()->{'log' . $method}($message, array(), false);
}
}
}
// Initialize rebuild cache routine as a next step
\XLite::setCleanUpCacheFlag(true);
}
\XLite\Core\TopMessage::addInfo('Free license is activated successfully');
$this->setReturnURL($this->buildURL());
} else {
\XLite\Core\TopMessage::addError('Can\'t connect to the marketplace server');
}
}
/**
* Common restore database method used by actions
*
* @param mixed $sqlFile File with SQL data for loading into database
*
* @return boolean
*/
protected function restoreDatabase($sqlFile)
{
$result = false;
// File to create temporary backup to be able rollback database
$backupSQLFile = LC_DIR_BACKUP . sprintf('sqldump.backup.%d.sql', \XLite\Core\Converter::time());
// Make the process of restoring database verbose
$verbose = true;
// Start
$this->startDump();
// Making the temporary backup file
\Includes\Utils\Operator::flush(static::t('Making backup of the current database state ... '), true);
$result = \XLite\Core\Database::getInstance()->exportSQLToFile($backupSQLFile, $verbose);
\Includes\Utils\Operator::flush(static::t('done') . LC_EOL . LC_EOL, true);
// Loading specified SQL-file to the database
\Includes\Utils\Operator::flush(static::t('Loading the database from file .'));
$result = \Includes\Utils\Database::uploadSQLFromFile($sqlFile, $verbose);
$restore = false;
if ($result) {
// If file has been loaded into database successfully
$message = static::t('Database restored successfully!');
// Prepare the cache rebuilding
\XLite::setCleanUpCacheFlag(true);
} else {
// If an error occured while loading file into database
$message = static::t('The database has not been restored because of the errors');
$restore = true;
}
// Display the result message
\Includes\Utils\Operator::flush(' ' . static::t('done') . LC_EOL . LC_EOL . $message . LC_EOL);
if ($restore) {
// Restore database from temporary backup
\Includes\Utils\Operator::flush(LC_EOL . static::t('Restoring database from the backup .'));
\Includes\Utils\Database::uploadSQLFromFile($backupSQLFile, $verbose);
\Includes\Utils\Operator::flush(' ' . static::t('done') . LC_EOL . LC_EOL);
}
// Display Javascript to cancel scrolling page to bottom
func_refresh_end();
// Display the bottom HTML part
$this->displayPageFooter();
// Remove temporary backup file
unlink($backupSQLFile);
return $result;
}
/**
* doActionRebuild
*
* @return void
*/
public function doActionRebuild()
{
\XLite::setCleanUpCacheFlag(true);
// To avoid the infinite loop
$this->setReturnURL($this->buildURL());
}
/**
* Third step: install downloaded upgrades
*
* @return void
*/
protected function doActionInstallUpgrades()
{
$this->setReturnURL($this->buildURL('upgrade'));
if (\XLite\Upgrade\Cell::getInstance()->isUnpacked()) {
\Includes\SafeMode::sendNotification();
$restorePoint = \Includes\Utils\ModulesManager::getEmptyRestorePoint();
//write current state
$current = \XLite\Core\Database::getRepo('\\XLite\\Model\\Module')->findBy(array('enabled' => true));
foreach ($current as $module) {
$restorePoint['current'][$module->getModuleId()] = $module->getActualName();
}
\Includes\Utils\Operator::showMessage('Installing updates, please wait...');
if (\XLite\Core\Request::getInstance()->preUpgradeWarningModules) {
\XLite\Upgrade\Cell::getInstance()->setPreUpgradeWarningModules(array_keys(array_filter(\XLite\Core\Request::getInstance()->preUpgradeWarningModules, function ($value) {
return 0 == $value;
})));
}
// Disable selected modules
$modules = array();
foreach (\XLite\Upgrade\Cell::getInstance()->getIncompatibleModules(true) as $module) {
$module->setEnabled(false);
$modules[] = $module;
$restorePoint['disabled'][$module->getModuleId()] = $module->getActualName();
}
\XLite\Core\Database::getRepo('XLite\\Model\\Module')->updateInBatch($modules);
// Do actions according the admin choice for the disabled modules with hooks
$modulesToEnable = array();
/** @var \XLite\Model\Module $module */
foreach (\XLite\Upgrade\Cell::getInstance()->getDisabledModulesHooks() as $marketplaceId => $module) {
$action = \XLite\Core\Request::getInstance()->disabledModulesHooks[$marketplaceId];
$module = \XLite\Core\Database::getEM()->merge($module);
if (1 == $action) {
// Enable module
$module->setEnabled(true);
$modulesToEnable[] = $module;
$restorePoint['enabled'][$module->getModuleId()] = $module->getActualName();
} elseif (0 == $action) {
// Uninstall module
\XLite\Upgrade\Cell::getInstance()->removeModuleEntry($module);
$this->uninstallModule($module);
$restorePoint['deleted'][] = $module->getActualName();
}
}
\XLite\Core\Database::getRepo('XLite\\Model\\Module')->updateInBatch($modulesToEnable);
if (\XLite\Upgrade\Cell::getInstance()->getEntries()) {
foreach (\XLite\Upgrade\Cell::getInstance()->getEntries() as $module) {
$restorePoint['installed'][] = $module->getActualName();
}
// Perform upgrade
// pre_upgrade / post_upgrade hooks will be proceeded here
$this->runStep('upgrade', array(false, $this->getFilesToOverWrite()));
if ($this->isForce()) {
if ($this->isNextStepAvailable()) {
$target = 'installed';
$this->showInfo(null, 1 < count($modules) ? static::t('Modules have been successfully installed') : static::t('Module has been successfully installed'));
if ($this->isOnlySkins()) {
$target = 'layout';
} elseif ($this->getPaymentMethodToInstall()) {
$target = 'payment_settings';
} else {
$target = 'addons_list_installed';
}
} else {
$target = 'addons_list_marketplace';
$this->showError(__FUNCTION__);
}
$this->setReturnURL($this->buildURL('upgrade', '', $this->getActionParamsCommon() + array('redirect' => $target)));
}
} else {
// All modules for upgrade were set for uninstallation
// There are no upgrade procedures to perform
\XLite\Core\Marketplace::getInstance()->clearActionCache();
$this->setReturnURL($this->buildURL('addons_list_installed'));
}
// Set cell status
\XLite\Upgrade\Cell::getInstance()->clear(true, false, false);
\XLite\Upgrade\Cell::getInstance()->setUpgraded(true);
\Includes\Utils\ModulesManager::updateModuleMigrationLog($restorePoint);
// Rebuild cache
if (!($this->isForce() && $this->isOnlySkins())) {
\XLite::setCleanUpCacheFlag(true);
}
} else {
$this->showWarning(__FUNCTION__, static::t('unable to install: not all archives were unpacked. Please, try again', array('list' => $this->getErrorEntriesHTML())));
}
}
/**
* Action of license key registration
*
* @return void
*/
protected function doActionRegisterKey()
{
$key = \XLite\Core\Request::getInstance()->key;
if ($key) {
$keysInfo = \XLite\Core\Marketplace::getInstance()->checkAddonKey($key);
} else {
$keysInfo = null;
$emptyKey = true;
}
$this->setReturnURL($this->buildURL('addons_list_marketplace'));
if ($keysInfo && $keysInfo[$key]) {
$keysInfo = $keysInfo[$key];
$repo = \XLite\Core\Database::getRepo('\\XLite\\Model\\ModuleKey');
foreach ($keysInfo as $info) {
if (\XLite\Model\ModuleKey::KEY_TYPE_XCN == $info['keyType']) {
$xcnPlan = $info['xcnPlan'];
$keyData = $info['keyData'];
// Unset some fields which is not in database
unset($info['xcnPlan']);
unset($info['keyData']);
unset($info['key']);
$entity = $repo->findOneBy($info);
if (!$entity) {
$entity = new \XLite\Model\ModuleKey();
$entity->map($info);
}
$entity->setKeyValue($key);
$entity->setXcnPlan($xcnPlan);
$entity->setKeyData($keyData);
if (!empty($keyData['wave'])) {
$this->updateUpgradeWaveOption($keyData['wave']);
}
$isValid = true;
if (\XLite::isFreeLicense($entity)) {
if (0 == \XLite\Core\Database::getRepo('XLite\\Model\\Module')->hasMarketplaceModules(true)) {
$isValid = false;
$this->showError(__FUNCTION__, static::t('Cannot gather modules from the marketplace. Please try later.'));
}
}
if ($isValid) {
// Save entity (key) in the database
\XLite\Core\Database::getEM()->persist($entity);
\XLite\Core\Database::getEM()->flush();
if (\XLite::isFreeLicense()) {
// Search for modules from non-free edition
$nonFreeModules = \XLite\Core\Database::getRepo('XLite\\Model\\Module')->getNonFreeEditionModulesList(false);
if ($nonFreeModules) {
// Try to uninstall these modules...
foreach ($nonFreeModules as $module) {
$messages = array();
$res = \XLite\Core\Database::getRepo('XLite\\Model\\Module')->uninstallModule($module, $messages);
if ($messages) {
foreach ($messages as $message) {
$method = $res ? 'Info' : 'Error';
\XLite\Upgrade\Logger::getInstance()->{'log' . $method}($message, array(), false);
}
}
}
}
\XLite::setCleanUpCacheFlag(true);
}
if (empty($keyData['message'])) {
$this->showInfo(__FUNCTION__, static::t('X-Cart license key has been successfully verified'));
} else {
$this->showWarning(__FUNCTION__, static::t('X-Cart license key has been successfully verified and activated. But this key has expired and do not allow upgrade store.'));
}
// Clear cache for proper installation
\XLite\Core\Marketplace::getInstance()->clearActionCache(\XLite\Core\Marketplace::ACTION_GET_ADDONS_LIST);
$this->setHardRedirect();
}
} else {
$keyData = $info['keyData'];
$module = \XLite\Core\Database::getRepo('\\XLite\\Model\\Module')->findOneBy(array('author' => $info['author'], 'name' => $info['name']));
if ($module) {
$entity = $repo->findKey($info['author'], $info['name']);
if ($entity) {
$entity->setKeyValue($key);
$repo->update($entity);
} else {
$entity = $repo->insert($info + array('keyValue' => $key));
}
if (!empty($keyData['wave'])) {
$this->updateUpgradeWaveOption($keyData['wave']);
}
// Clear cache for proper installation
\XLite\Core\Marketplace::getInstance()->clearActionCache(\XLite\Core\Marketplace::ACTION_GET_ADDONS_LIST);
if (empty($keyData['message'])) {
$this->showInfo(__FUNCTION__, static::t('License key has been successfully verified for "{{name}}" module by "{{author}}" author', array('name' => $module->getModuleName(), 'author' => $module->getAuthorName())));
} else {
$this->showWarning(__FUNCTION__, static::t('License key has been successfully verified and activated for "{{name}}" module by "{{author}}" author. But this key has expired and do not allow upgrade store.', array('name' => $module->getModuleName(), 'author' => $module->getAuthorName())));
}
// We install the addon after the successfull key verification
$this->setReturnURL($this->buildURL('upgrade', 'install_addon_force', array('moduleIds[]' => $module->getModuleID(), 'agree' => 'Y')));
} else {
$this->showError(__FUNCTION__, static::t('Key is validated, but the module X was not found', array('module' => implode(',', $info))));
}
}
}
} elseif (!isset($emptyKey)) {
$error = \XLite\Core\Marketplace::getInstance()->getError();
$message = $error ? static::t('Response from marketplace: X', array('response' => $error)) : static::t('Response from marketplace is not received');
$this->showError(__FUNCTION__, $message);
} else {
$this->showError(__FUNCTION__, static::t('Please specify non-empty key'));
}
}
/**
* Switch module
*
* @return void
*/
public function doActionSwitch()
{
$changed = false;
$deleted = false;
$data = (array) \XLite\Core\Request::getInstance()->switch;
$modules = array();
$firstModule = null;
$switchModules = $this->getModules('switch');
$switchModulesKeys = array();
$excludedModules = array();
$excludedEnableModules = array();
$restorePoint = \Includes\Utils\ModulesManager::getEmptyRestorePoint();
$current = \XLite\Core\Database::getRepo('\\XLite\\Model\\Module')->findBy(array('enabled' => true));
foreach ($current as $module) {
$restorePoint['current'][$module->getModuleId()] = $module->getActualName();
}
// Correct modules list
foreach ($switchModules as $key => $module) {
$toDelete = false;
$toDisable = false;
$toEnable = false;
$switchModulesKeys[] = $module->getModuleId();
if (!empty($data[$module->getModuleId()]['delete'])) {
$toDelete = true;
} else {
$old = !empty($data[$module->getModuleId()]['old']);
$new = !empty($data[$module->getModuleId()]['new']);
$toDisable = !$new && $old != $new;
$toEnable = $new && $old != $new;
}
if ($toDelete || $toDisable) {
$dependentModules = $module->getDependentModules();
if ($dependentModules) {
foreach ($dependentModules as $dep) {
$depModule = \XLite\Core\Database::getRepo('XLite\\Model\\Module')->getModuleInstalled($dep);
if ($depModule) {
$depDelete = !empty($data[$depModule->getModuleId()]['delete']);
$depDisable = empty($data[$depModule->getModuleId()]['new']);
if ($toDelete && !$depDelete || $toDisable && !$depDelete && !$depDisable) {
// Remove current module from the actions list if it has active dependent modules
$excludedModules[] = $module->getModuleName();
unset($data[$module->getModuleId()]);
unset($switchModules[$key]);
break;
}
}
}
}
} elseif ($toEnable) {
// Get the list of modules which current module depends on
$list = $this->getAllDisabledModuleDependencies($module);
if ($list) {
foreach ($list as $m) {
if (empty($data[$m->getModuleId()]) || empty($data[$m->getModuleId()]['delete']) && empty($data[$m->getModuleId()]['new'])) {
$data[$m->getModuleId()] = array('old' => 0, 'new' => 1);
$additionalSwitchModules[$m->getModuleId()] = $m;
}
}
} elseif (false === $list) {
// Remove current module from the actions list as it can't be enabled
$excludedEnableModules[] = $module->getModuleName();
unset($data[$module->getModuleId()]);
}
}
}
if ($excludedModules) {
\XLite\Core\TopMessage::addWarning('The following selected modules cannot be disabled or uninstalled as they have dependent modules', array('list' => implode(', ', $excludedModules)));
// Selection has excluded modules - this is a critical case, break an entire operation
return;
}
if ($excludedEnableModules) {
\XLite\Core\TopMessage::addWarning('The following selected modules cannot be enabled as they depend on disabled modules which cannot be enabled', array('list' => implode(', ', $excludedEnableModules)));
// Selection has excluded modules - this is a critical case, break an entire operation
return;
}
if (!empty($additionalSwitchModules)) {
// Extend $switchModules list by additional modules
foreach ($additionalSwitchModules as $k => $am) {
if (!in_array($k, $switchModulesKeys)) {
$switchModules[] = $am;
}
}
}
foreach ($switchModules as $module) {
if (!empty($data[$module->getModuleId()]['delete'])) {
$old = $new = null;
$delete = true;
} else {
$old = !empty($data[$module->getModuleId()]['old']);
$new = !empty($data[$module->getModuleId()]['new']);
$delete = false;
}
if ($delete) {
// Uninstall module
if ($module->getEnabled()) {
$module->setEnabled(false);
$module->callModuleMethod('callDisableEvent');
}
if (!defined('LC_MODULE_CONTROL')) {
define('LC_MODULE_CONTROL', true);
}
if ($this->uninstallModule($module)) {
$deleted = true;
$restorePoint['deleted'][] = $module->getActualName();
}
} elseif ($old !== $new) {
// Change module status
$module->setEnabled($new);
// Call disable event to make some module specific changes
if ($old) {
$module->callModuleMethod('callDisableEvent');
} elseif (is_null($firstModule)) {
$firstModule = $module;
}
if ($new) {
$restorePoint['enabled'][$module->getModuleId()] = $module->getActualName();
} else {
$restorePoint['disabled'][$module->getModuleId()] = $module->getActualName();
}
$modules[] = $module;
$changed = true;
}
}
// Flag to rebuild cache
if ($changed) {
// We redirect the admin to the modules page on the activated module anchor
// The first module in a batch which is available now
\XLite\Core\Session::getInstance()->returnURL = $firstModule ? $this->getModulePageURL($firstModule) : (\XLite\Core\Request::getInstance()->return ?: '');
\XLite\Core\Database::getRepo('\\XLite\\Model\\Module')->updateInBatch($modules);
}
if ($deleted) {
// Refresh marketplace modules cache
\XLite\Core\Marketplace::getInstance()->saveAddonsList(0);
\XLite\Core\Marketplace::getInstance()->clearActionCache(\XLite\Core\Marketplace::ACTION_CHECK_FOR_UPDATES);
}
if ($changed || $deleted) {
// Flag to rebuild classes cache
\XLite::setCleanUpCacheFlag(true);
}
\Includes\Utils\ModulesManager::updateModuleMigrationLog($restorePoint);
}
