2571 lines
85 KiB
PHP
2571 lines
85 KiB
PHP
<?php
|
|
/**
|
|
* 2017-2018 Zemez
|
|
*
|
|
* Sampledatainstall
|
|
*
|
|
* NOTICE OF LICENSE
|
|
*
|
|
* This source file is subject to the General Public License (GPL 2.0)
|
|
* that is bundled with this package in the file LICENSE.txt.
|
|
* It is also available through the world-wide-web at this URL:
|
|
* http://opensource.org/licenses/GPL-2.0
|
|
*
|
|
* DISCLAIMER
|
|
*
|
|
* Do not edit or add to this file if you wish to upgrade the module to newer
|
|
* versions in the future.
|
|
*
|
|
* @author Zemez (Alexander Grosul)
|
|
* @copyright 2017-2018 Zemez
|
|
* @license http://opensource.org/licenses/GPL-2.0 General Public License (GPL 2.0)
|
|
*/
|
|
|
|
@ini_set('max_execution_time', 0);
|
|
|
|
/** No max line limit because the total of lines can be more than 4096. The performance impact is not significant. */
|
|
define('MAX_LINE_SIZE', 0);
|
|
|
|
/** correct Mac error on eof */
|
|
@ini_set('auto_detect_line_endings', '1');
|
|
|
|
class AdminSampleDataInstallImportController extends ModuleAdminController {
|
|
|
|
public $steps;
|
|
public $steps_list = [];
|
|
public $logos = false;
|
|
public $modules = false;
|
|
public $content = false;
|
|
public $commonTop;
|
|
public $commonBottom;
|
|
protected $filesByOperations = array();
|
|
|
|
public function __construct()
|
|
{
|
|
$this->bootstrap = true;
|
|
$this->context = Context::getContext();
|
|
if (!isset($this->context->employee)) {
|
|
$employee = new Employee(1);
|
|
$this->context->employee = $employee;
|
|
}
|
|
parent::__construct();
|
|
if (!$this->module->active) {
|
|
Tools::redirectAdmin($this->context->link->getAdminLink('AdminHome'));
|
|
}
|
|
|
|
require_once(dirname(__FILE__).'/../../helper/fields_list.php');
|
|
require_once(dirname(__FILE__).'/../../helper/modules_config_list.php');
|
|
|
|
$this->commonTop = [
|
|
'clearTemporaryConfigEntries' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Clearing temporary configuration settings')
|
|
],
|
|
'checkUploadedData' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('It seems that you didn\'t upload necessary files yet'),
|
|
'description' => $this->l('Check if uploaded data exists')
|
|
],
|
|
'prepareUploadedFiles' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Prepare uploaded files')
|
|
]
|
|
];
|
|
$this->commonBottom = [
|
|
'clearTemporaryFolder' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Clearing temporary folder')
|
|
],
|
|
'finished' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Generating successfully completed')
|
|
]
|
|
];
|
|
$this->steps = [
|
|
'1' => [
|
|
'clearDb' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Clearing data base')
|
|
],
|
|
'importSQLdata' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import new data base information')
|
|
],
|
|
'importLanguages' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import demo store languages')
|
|
],
|
|
'importCurrencies' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import demo store currencies')
|
|
],
|
|
'importZones' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import demo store Zones')
|
|
],
|
|
'importCountries' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import demo store Countries')
|
|
],
|
|
'importStates' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import demo store States')
|
|
],
|
|
'importTaxRulesGroups' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Tax Rules Groups')
|
|
],
|
|
'importTaxRules' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Tax Rules')
|
|
],
|
|
'importTaxes' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Taxes')
|
|
],
|
|
'importAddresses' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import addresses')
|
|
],
|
|
'importAlias' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Aliases')
|
|
],
|
|
'importAttachments' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Attachments')
|
|
],
|
|
'importAttributeGroups' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Attributes Groups')
|
|
],
|
|
'importAttributes' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Attributes')
|
|
],
|
|
'importFeatures' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Features')
|
|
],
|
|
'importFeatureValues' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Features Values')
|
|
],
|
|
'importCategories' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Categories')
|
|
],
|
|
'importManufacturers' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Manufacturers')
|
|
],
|
|
'importSuppliers' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Suppliers')
|
|
],
|
|
'importProducts' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Products')
|
|
],
|
|
'importProductsAttributes' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Products Attributes')
|
|
],
|
|
'importProductsPacks' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Products Packs')
|
|
],
|
|
'importImages' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Images')
|
|
],
|
|
'importStockAvailable' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Stock Available')
|
|
],
|
|
'importSpecificPrices' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Specific Prices')
|
|
],
|
|
'importSpecificPriceRules' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Specific Prices Rules')
|
|
],
|
|
'importCMSCategories' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import CMS Categories')
|
|
],
|
|
'importCMS' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import CMS Pages')
|
|
],
|
|
'importCarriers' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Carriers')
|
|
],
|
|
'importDeliveries' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Deliveries')
|
|
],
|
|
'importContacts' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Cantacts')
|
|
],
|
|
'importHomeSlides' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Home Page Slides')
|
|
],
|
|
'importInfos' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Info Pages')
|
|
],
|
|
'importConfigurations' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Set configurations')
|
|
]
|
|
],
|
|
'2' => [
|
|
'clearDb' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Clearing data base')
|
|
],
|
|
'importConfigurations' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Set configurations')
|
|
],
|
|
'importSQLdata' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import new data base information')
|
|
]
|
|
],
|
|
'3' => [
|
|
'importConfigurations' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Set configurations')
|
|
]
|
|
],
|
|
'4' => [
|
|
'importConfigurations' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Set configurations')
|
|
],
|
|
'importAlias' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Aliases')
|
|
],
|
|
'importAttachments' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Attachments')
|
|
],
|
|
'importAttributeGroups' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Attributes Groups')
|
|
],
|
|
'importAttributes' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Attributes')
|
|
],
|
|
'importCategories' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Categories')
|
|
],
|
|
'importManufacturers' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Manufacturers')
|
|
],
|
|
'importSuppliers' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Suppliers')
|
|
],
|
|
'importFeatures' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Features')
|
|
],
|
|
'importFeatureValues' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Features Values')
|
|
],
|
|
'importProducts' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Products')
|
|
],
|
|
'importProductsAttributes' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Products Attributes')
|
|
],
|
|
'importProductsPacks' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Products Packs')
|
|
],
|
|
'importImages' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Images')
|
|
],
|
|
'importStockAvailable' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Stock Available')
|
|
],
|
|
'importSpecificPrices' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Specific Prices')
|
|
],
|
|
'importSpecificPriceRules' => [
|
|
'success_message' => $this->l('Success'),
|
|
'error_message' => $this->l('Error'),
|
|
'description' => $this->l('Import Specific Prices Rules')
|
|
]
|
|
]
|
|
];
|
|
}
|
|
|
|
public function initContent()
|
|
{
|
|
//$this->clearTemporaryFolder();
|
|
if ($this->compatibilityBrowser()) {
|
|
$this->context->smarty->assign('actions', array (
|
|
'max_file_size_text' => ini_get('upload_max_filesize'),
|
|
'regenerateDir' => $this->context->link->getAdminLink('AdminImages').'#image_type_form',
|
|
'output' => $this->compabilityServer(),
|
|
'uploaded_data' => $this->checkUploadedData(true)
|
|
));
|
|
$this->content = $this->module->fetch($this->module->module_path.'views/templates/admin/import.tpl');
|
|
} else {
|
|
$this->content = $this->module->fetch($this->module->module_path.'old-browser.tpl');
|
|
}
|
|
parent::initContent();
|
|
}
|
|
|
|
public function setMedia($isNewTheme = false)
|
|
{
|
|
$this->addJquery();
|
|
Media::addJsDef(array(
|
|
'importDir' => $this->context->link->getAdminLink('AdminSampleDataInstallImport'),
|
|
'max_file_size' => $this->convertBytes(ini_get('upload_max_filesize')),
|
|
'confirmationPopup' => $this->module->fetch($this->module->module_path.'views/templates/admin/import_popup.tpl'),
|
|
'SDI_show_message' => 0,
|
|
'import_text' => array(
|
|
'error_upload' => $this->l('Upload Error'),
|
|
'error_size' => $this->l('The file is too big!'),
|
|
'error_type' => $this->l('Wrong file type!'),
|
|
'error_folder' => $this->l('Folders can not be uploaded!'),
|
|
'format_error' => $this->l('Wrong file! Only sample data files can be used!'),
|
|
'error_added' => $this->l('File already added!'),
|
|
'uploading' => $this->l('Uploading'),
|
|
'upload' => $this->l('Upload'),
|
|
'upload_complete' => $this->l('Upload Complete'),
|
|
'item' => $this->l('item'),
|
|
'items' => $this->l('items'),
|
|
'uploaded_status_text' => $this->l('Sample data installing. It can take some time. You can drink some tea and eat a croissant.'),
|
|
'uploaded_status_text_1' => $this->l('Well done! Upload complete. Please click Continue Install button to proceed.'),
|
|
'uploaded_status_text_2' => $this->l('Files are not uploaded.'),
|
|
'uploaded_status_text_3' => $this->l('Not all files are successfully uploaded.'),
|
|
'uploaded_status_text_4' => $this->l('Files successfully uploaded.'),
|
|
'uploaded_status_text_5' => $this->l('Not all files are successfully uploaded. Please click Continue Install button to proceed.'),
|
|
'uploaded_status_text_6' => $this->l('Settings file is not loaded.'),
|
|
'import_complete' => $this->l('Sample data installation complete'),
|
|
'instal_error' => $this->l('Sample data installation failed'),
|
|
'not_supported_status' => $this->l('This sample data is not compatible with your store.'),
|
|
'diferent_ps_version' => $this->l('Your Prestashop and the sample data versions are different.'),
|
|
'diferent_db_version' => $this->l('Your database and the sample data database versions are different. '),
|
|
'current_ps_version' => $this->l(' Your Prestashop version: '),
|
|
'sd_ps_version' => $this->l(' Sample data version: '),
|
|
'current_db_version' => $this->l(' Your database version: '),
|
|
'sd_db_version' => $this->l(' Sample data database version: '),
|
|
'files_missed_text' => $this->l('Some file(s) is(are) missed : '),
|
|
'import_first_step_description' => $this->l('Clearing temporary configuration settings')
|
|
)
|
|
));
|
|
$this->addJS($this->module->module_path.'views/js/admin_import.js');
|
|
$this->addCss($this->module->module_path.'views/css/admin_import.css');
|
|
parent::setMedia();
|
|
}
|
|
|
|
public function postProcess()
|
|
{
|
|
if (Tools::getValue('action') == 'installData') {
|
|
$content = Tools::getValue('content');
|
|
$modules = Tools::getValue('modules');
|
|
$logos = Tools::getValue('logos');
|
|
$all = Tools::getValue('all');
|
|
$method = Tools::getValue('method');
|
|
// define all necessary steps according to the selected installation type and add the configuration settings as well
|
|
if (!count($this->steps_list)) {
|
|
$this->steps_list = $this->commonTop;
|
|
if ($all == 'true') {
|
|
$this->logos = true;
|
|
$this->modules = true;
|
|
$this->content = true;
|
|
$this->steps_list = array_merge($this->steps_list, $this->steps[1]);
|
|
}
|
|
if ($all == 'false' && $modules == 'true') {
|
|
$this->modules = true;
|
|
$this->steps_list = array_merge($this->steps_list, $this->steps[2]);
|
|
}
|
|
if ($all == 'false' && $logos == 'true') {
|
|
$this->logos = true;
|
|
$this->steps_list = array_merge($this->steps_list, $this->steps[3]);
|
|
}
|
|
if ($all == 'false' && $content == 'true') {
|
|
$this->content = true;
|
|
$this->steps_list = array_merge($this->steps_list, $this->steps[4]);
|
|
}
|
|
$this->steps_list = array_merge($this->steps_list, $this->commonBottom);
|
|
}
|
|
|
|
if (method_exists($this, $method)) {
|
|
if ($this->{$method}()) {
|
|
$keys = array_keys($this->steps_list);
|
|
$position = array_search($method, $keys);
|
|
$progress = ($position/(count($this->steps_list) - 2)) * 100; // minus first and last steps to make loading indicator more exact
|
|
$next_key = $keys[array_search($method, $keys) + 1]; // find next step to get all necessary information about it
|
|
die(json_encode(array(
|
|
'status' => true,
|
|
'response' => $this->steps_list[$method]['success_message'],
|
|
'method' => $next_key,
|
|
'progress' => (int)$progress,
|
|
'info' => $this->steps_list[$next_key]['description'],
|
|
)));
|
|
}
|
|
die(json_encode(array('status' => false, 'response' => $this->steps_list[$method]['error_message'])));
|
|
} else {
|
|
die(json_encode(array('status' => false, 'response' => 'The method "'.$method.'" doesn\'t exist but invoked')));
|
|
}
|
|
} else if (Tools::getValue('action') == 'getSettigs') {
|
|
$this->getSettings(true);
|
|
} else if (Tools::getValue('action') == 'getCurrentStatus') {
|
|
//$this->clearTemporaryFolder();
|
|
$this->getCurrentStatusAjax();
|
|
} else {
|
|
$this->filesUpload();
|
|
}
|
|
}
|
|
|
|
public function importLanguages()
|
|
{
|
|
$this->setCurrentStatus('Language import', $step = 1);
|
|
$this->truncateTables(array('lang', 'lang_shop'));
|
|
|
|
$handle = $this->openCsvFile('languages.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
Language::downloadAndInstallLanguagePack($line[2]);
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importCurrencies()
|
|
{
|
|
$this->setCurrentStatus('Currencies import', $step = 1);
|
|
$this->truncateTables(array('currency', 'currency_shop', 'currency_lang'));
|
|
$handle = $this->openCsvFile('currencies.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Currency', $this->currencies_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$currency = new Currency($line[0]);
|
|
$currency->id = $line[0];
|
|
} else {
|
|
$currency = new Currency($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
$currency->$key = $field;
|
|
}
|
|
|
|
$currency->force_id = true;
|
|
if (Tools::version_compare(_PS_VERSION_, '1.7.6', '>=')) {
|
|
Cache::clear();
|
|
$locale = $this->module->get('prestashop.core.localization.cldr.locale_repository');
|
|
$currency->refreshLocalizedCurrencyData(Language::getLanguages(), $locale);
|
|
}
|
|
if (!$res) {
|
|
$res = $currency->add();
|
|
}
|
|
}
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importZones()
|
|
{
|
|
$this->setCurrentStatus('Zones import', $step = 1);
|
|
$this->truncateTables(array('zone', 'zone_shop'));
|
|
|
|
$handle = $this->openCsvFile('zones.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Zone', $this->zones_fields, $line);
|
|
|
|
if (!isset($fields['id_zone'])) {
|
|
$zone = new Zone($line[0]);
|
|
$zone->id = $line[0];
|
|
} else {
|
|
$zone = new Zone($fields['id_zone']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
$zone->$key = $field;
|
|
}
|
|
|
|
$zone->force_id = true;
|
|
if (!$res) {
|
|
$res = $zone->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importCountries()
|
|
{
|
|
$this->setCurrentStatus('Countries import', $step = 1);
|
|
$this->truncateTables(array('country', 'country_lang', 'country_shop'));
|
|
|
|
$handle = $this->openCsvFile('countries.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Country', $this->countries_fields, $line);
|
|
|
|
if (!isset($fields['id_country'])) {
|
|
$country = new Country($line[0]);
|
|
$country->id = $line[0];
|
|
} else {
|
|
$country = new Country($fields['id_country']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'name') {
|
|
$country->$key = $this->multilFild($field);
|
|
} else {
|
|
$country->$key = $field;
|
|
}
|
|
}
|
|
|
|
$country->force_id = true;
|
|
if (!$res) {
|
|
$res = $country->add();
|
|
}
|
|
}
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importStates()
|
|
{
|
|
$this->setCurrentStatus('States import', $step = 1);
|
|
$this->truncateTables(array('state'));
|
|
|
|
$handle = $this->openCsvFile('states.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('State', $this->states_fields, $line);
|
|
|
|
if (!isset($fields['id_state'])) {
|
|
$state = new State($line[0]);
|
|
$state->id = $line[0];
|
|
} else {
|
|
$state = new State($fields['id_state']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
$state->$key = $field;
|
|
}
|
|
|
|
$state->force_id = true;
|
|
if (!$res) {
|
|
$res = $state->add();
|
|
}
|
|
}
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importTaxRulesGroups()
|
|
{
|
|
$this->setCurrentStatus('Tax Rules Groups import', $step = 1);
|
|
$this->truncateTables(array('tax_rules_group', 'tax_rules_group_shop'));
|
|
|
|
$handle = $this->openCsvFile('tax_rule_groups.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('TaxRulesGroup', $this->tax_rule_group_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$tax_rule_group = new TaxRulesGroup($line[0]);
|
|
$tax_rule_group->id = $line[0];
|
|
} else {
|
|
$tax_rule_group = new TaxRulesGroup($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
$tax_rule_group->$key = $field;
|
|
}
|
|
|
|
$tax_rule_group->force_id = true;
|
|
|
|
if (!$res) {
|
|
$res = $tax_rule_group->add();
|
|
}
|
|
}
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importTaxRules()
|
|
{
|
|
$this->setCurrentStatus('Tax Rules import', $step = 1);
|
|
$this->truncateTables(array('tax_rule'));
|
|
|
|
$handle = $this->openCsvFile('tax_rules.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('TaxRule', $this->tax_rule_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$tax_rule = new TaxRule($line[0]);
|
|
$tax_rule->id = $line[0];
|
|
} else {
|
|
$tax_rule = new TaxRule($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
$tax_rule->$key = $field;
|
|
}
|
|
|
|
$tax_rule->force_id = true;
|
|
if (!$res) {
|
|
$res = $tax_rule->add();
|
|
}
|
|
}
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importTaxes()
|
|
{
|
|
$this->setCurrentStatus('Taxes import', $step = 1);
|
|
$this->truncateTables(array('tax', 'tax_lang'));
|
|
|
|
$handle = $this->openCsvFile('taxes.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Tax', $this->tax_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$tax = new Tax($line[0]);
|
|
$tax->id = $line[0];
|
|
} else {
|
|
$tax = new Tax($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'name') {
|
|
$tax->$key = $this->multilFild($field);
|
|
} else {
|
|
$tax->$key = $field;
|
|
}
|
|
}
|
|
|
|
$tax->force_id = true;
|
|
if (!$res) {
|
|
$res = $tax->add();
|
|
}
|
|
}
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importAddresses()
|
|
{
|
|
$this->setCurrentStatus('Addresses import', $step = 1);
|
|
$this->truncateTables(array('address'));
|
|
|
|
$handle = $this->openCsvFile('address.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Address', $this->address_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$address = new Address((int)$line[0]);
|
|
$address->id = $line[0];
|
|
} else {
|
|
$address = new Address((int)$fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
$address->$key = $field;
|
|
}
|
|
|
|
$address->force_id = true;
|
|
if (!$res) {
|
|
$res = $address->add();
|
|
}
|
|
}
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importAlias() {
|
|
$this->setCurrentStatus('Alias import', $step = 1);
|
|
$this->truncateTables(array('alias'));
|
|
|
|
$handle = $this->openCsvFile('alias.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Alias', $this->alias_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$alias = new Alias((int)$line[0]);
|
|
$alias->id = $line[0];
|
|
} else {
|
|
$alias = new Alias((int)$fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
$alias->$key = $field;
|
|
}
|
|
|
|
$alias->force_id = true;
|
|
if (!$res) {
|
|
$alias->add();
|
|
}
|
|
}
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importAttachments()
|
|
{
|
|
$this->setCurrentStatus('Attachments import', $step = 1);
|
|
$this->truncateTables(array('attachment', 'attachment_lang'));
|
|
|
|
$handle = $this->openCsvFile('attachments.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Attachment', $this->attachments_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$attacment = new Attachment((int)$line[0]);
|
|
$attacment->id = $line[0];
|
|
} else {
|
|
$attacment = new Attachment((int)$fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'name' || $key == 'description') {
|
|
$attacment->$key = $this->multilFild($field);
|
|
} else {
|
|
$attacment->$key = $field;
|
|
}
|
|
}
|
|
|
|
$attacment->force_id = true;
|
|
if (!$res) {
|
|
$attacment->add();
|
|
}
|
|
}
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importAttributeGroups()
|
|
{
|
|
$this->setCurrentStatus('Attribute Groups import', $step = 1);
|
|
$this->truncateTables(array('attribute_group', 'attribute_group_lang', 'attribute_group_shop'));
|
|
|
|
$handle = $this->openCsvFile('attribute_groups.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('AttributeGroup', $this->attribute_groups_fields, $line);
|
|
|
|
if (!isset($fields['id_attribute_group'])) {
|
|
$attribute_group = new AttributeGroup((int)$line[0]);
|
|
$attribute_group->id = $line[0];
|
|
} else {
|
|
$attribute_group = new AttributeGroup((int)$fields['id_attribute_group']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'name' || $key == 'public_name') {
|
|
$attribute_group->$key = $this->multilFild($field);
|
|
} else {
|
|
$attribute_group->$key = $field;
|
|
}
|
|
}
|
|
|
|
$attribute_group->force_id = true;
|
|
if (!$res) {
|
|
$attribute_group->add();
|
|
}
|
|
}
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importAttributes()
|
|
{
|
|
$this->setCurrentStatus('Attribute Groups import', $step = 1);
|
|
$this->truncateTables(array('attribute', 'attribute_lang', 'attribute_shop'));
|
|
|
|
$handle = $this->openCsvFile('attributes.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Attribute', $this->attributes_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$attribute = new Attribute((int)$line[0]);
|
|
$attribute->id = $line[0];
|
|
} else {
|
|
$attribute = new Attribute((int)$fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'name') {
|
|
$attribute->$key = $this->multilFild($field);
|
|
} else {
|
|
$attribute->$key = $field;
|
|
}
|
|
}
|
|
|
|
$attribute->force_id = true;
|
|
if (!$res) {
|
|
$attribute->add();
|
|
}
|
|
}
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importCarriers()
|
|
{
|
|
$this->setCurrentStatus('Carriers import', $step = 1);
|
|
$this->truncateTables(array('carrier', 'carrier_group',
|
|
'carrier_lang', 'carrier_shop',
|
|
'carrier_tax_rules_group_shop', 'carrier_zone',
|
|
'range_weight', 'range_price', 'module_carrier'));
|
|
|
|
$handle = $this->openCsvFile('carriers.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Carrier', $this->carriers_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$carrier = new Carrier((int)$line[0]);
|
|
$carrier->id = $line[0];
|
|
} else {
|
|
$carrier = new Carrier((int)$fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'delay') {
|
|
$carrier->$key = $this->multilFild($field);
|
|
} else {
|
|
$carrier->$key = $field;
|
|
}
|
|
}
|
|
|
|
if (!Tools::isEmpty($line[2])) { // Tax Rules Group ID
|
|
$values = array(
|
|
'id_carrier' => (int)$line[0],
|
|
'id_tax_rules_group' => (int)$line[2],
|
|
'id_shop' => (int)Context::getContext()->shop->id,
|
|
);
|
|
|
|
Cache::clean('carrier_id_tax_rules_group_'.(int)$line[0].'_'.(int)Context::getContext()->shop->id);
|
|
Db::getInstance()->insert('carrier_tax_rules_group_shop', $values);
|
|
}
|
|
if (trim($line[22])) { // Carrier Groups
|
|
$groups = explode(',', $line[22]);
|
|
foreach ($groups as $group) {
|
|
$values = array(
|
|
'id_carrier' => (int)$line[0],
|
|
'id_group' => (int)$group
|
|
);
|
|
Db::getInstance()->insert('carrier_group', $values);
|
|
}
|
|
}
|
|
if (trim($line[23])) { // Carrier Zones
|
|
$zones = explode(',', $line[23]);
|
|
foreach ($zones as $zone) {
|
|
$values = array(
|
|
'id_carrier' => (int)$line[0],
|
|
'id_zone' => (int)$zone
|
|
);
|
|
Db::getInstance()->insert('carrier_zone', $values);
|
|
}
|
|
}
|
|
if (trim($line[24])) {// Range Price
|
|
$range_line = explode(',', $line[24]);
|
|
foreach ($range_line as $range) {
|
|
$rp_res = false;
|
|
$values = explode('-', $range);
|
|
|
|
$rp = new RangePrice();
|
|
$rp->id_carrier = (int)$line[0];
|
|
$rp->delimiter1 = $values[0];
|
|
$rp->delimiter2 = $values[1];
|
|
if (!$rp_res) {
|
|
$rp->add();
|
|
}
|
|
}
|
|
}
|
|
if (trim($line[25])) { // Range Weight
|
|
$range_line = explode(',', $line[25]);
|
|
foreach ($range_line as $range) {
|
|
$rw_res = false;
|
|
$values = explode('-', $range);
|
|
$rw = new RangeWeight();
|
|
$rw->id_carrier = (int)$line[0];
|
|
$rw->delimiter1 = $values[0];
|
|
$rw->delimiter2 = $values[1];
|
|
if (!$rw_res) {
|
|
$rw->add();
|
|
}
|
|
}
|
|
}
|
|
|
|
$carrier->force_id = true;
|
|
if (!$res) {
|
|
$carrier->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importCMSCategories()
|
|
{
|
|
$this->setCurrentStatus('CMS Categories import', $step = 1);
|
|
$new_path = new Sampledatainstall();
|
|
$file = $new_path->sendPath().'input/cms_categories.csv';
|
|
// do nothing if file is empty
|
|
if (Tools::isEmpty(trim(Tools::file_get_contents($file)))) {
|
|
return;
|
|
}
|
|
|
|
$this->truncateTables(array('cms_category', 'cms_category_lang', 'cms_category_shop'));
|
|
|
|
$handle = $this->openCsvFile('cms_categories.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('CMSCategory', $this->cms_category_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$cms_cat = new CMSCategory((int)$line[0]);
|
|
$cms_cat->id = $line[0];
|
|
} else {
|
|
$cms_cat = new CMSCategory((int)$fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'name' || $key == 'description' || $key == 'meta_keywords' || $key == 'meta_description' || $key == 'link_rewrite') {
|
|
$cms_cat->$key = $this->multilFild($field);
|
|
} else {
|
|
$cms_cat->$key = $field;
|
|
}
|
|
}
|
|
|
|
$cms_cat->force_id = 1;
|
|
if (!$res) {
|
|
$cms_cat->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importCMS()
|
|
{
|
|
$this->setCurrentStatus('CMS import', $step = 1);
|
|
$new_path = new Sampledatainstall();
|
|
$file = $new_path->sendPath().'input/cms_pages.csv';
|
|
// do nothing if file is empty
|
|
if (Tools::isEmpty(trim(Tools::file_get_contents($file)))) {
|
|
return;
|
|
}
|
|
|
|
$this->truncateTables(array('cms', 'cms_lang', 'cms_shop'));
|
|
|
|
$handle = $this->openCsvFile('cms_pages.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('CMS', $this->cms_pages_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$cms = new CMS((int)$line[0]);
|
|
$cms->id = $line[0];
|
|
} else {
|
|
$cms = new CMS((int)$fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'meta_title' || $key == 'meta_description' || $key == 'meta_keywords' || $key == 'content' || $key == 'link_rewrite') {
|
|
$cms->$key = $this->multilFild($field);
|
|
} else {
|
|
$cms->$key = $field;
|
|
}
|
|
}
|
|
|
|
$cms->force_id = true;
|
|
if (!$res) {
|
|
$cms->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importDeliveries()
|
|
{
|
|
$this->setCurrentStatus('Deliveries import', $step = 1);
|
|
$this->truncateTables(array('delivery'));
|
|
|
|
$handle = $this->openCsvFile('deliveries.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Delivery', $this->delivery_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$delivery = new Delivery($line[0]);
|
|
$delivery->id = $line[0];
|
|
} else {
|
|
$delivery = new Delivery($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
$delivery->$key = $field;
|
|
}
|
|
|
|
$delivery->force_id = true;
|
|
if (!$res) {
|
|
$delivery->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importCategories()
|
|
{
|
|
$handle = $this->openCsvFile('categories.csv');
|
|
$this->cleanCategoriesTables();
|
|
$this->setCurrentStatus('Categories import', $step = 1);
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Category', $this->category_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$category = new Category($line[0]);
|
|
$category->id = $line[0];
|
|
} else {
|
|
$category = new Category($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'name' || $key == 'description' || $key == 'meta_title' || $key == 'meta_keywords' || $key == 'meta_description' || $key == 'link_rewrite') {
|
|
$category->$key = $this->multilFild($field);
|
|
} else if ($key == 'id_parent') {
|
|
// hack for old wersion where force_id don't working
|
|
$parent_category = new Category((int)$field);
|
|
if (!Validate::isLoadedObject($parent_category)) {
|
|
$category->$key = (int)Configuration::get('PS_HOME_CATEGORY');
|
|
} else {
|
|
$category->$key = $field;
|
|
}
|
|
} else {
|
|
$category->$key = $field;
|
|
}
|
|
}
|
|
|
|
$category->force_id = true;
|
|
|
|
if (!$res) {
|
|
$res = $category->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importManufacturers()
|
|
{
|
|
$this->setCurrentStatus('Manufacturers import', $step = 1);
|
|
$this->truncateTables(array('manufacturer', 'manufacturer_lang', 'manufacturer_shop'));
|
|
|
|
$handle = $this->openCsvFile('manufacturers.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Manufacturer', $this->manufacturers_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$manufacturer = new Manufacturer($line[0]);
|
|
$manufacturer->id = $line[0];
|
|
} else {
|
|
$manufacturer = new Manufacturer($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'description' || $key == 'short_description' || $key == 'meta_title' || $key == 'meta_keywords' || $key == 'meta_description') {
|
|
$manufacturer->$key = $this->multilFild($field);
|
|
} else {
|
|
$manufacturer->$key = $field;
|
|
}
|
|
}
|
|
|
|
$manufacturer->force_id = true;
|
|
if (!$res) {
|
|
$res = $manufacturer->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importSuppliers()
|
|
{
|
|
$this->setCurrentStatus('Suppliers import', $step = 1);
|
|
$this->truncateTables(array('supplier', 'supplier_lang', 'supplier_shop'));
|
|
|
|
$handle = $this->openCsvFile('suppliers.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Supplier', $this->suppliers_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$supplier = new Supplier($line[0]);
|
|
$supplier->id = $line[0];
|
|
} else {
|
|
$supplier = new Supplier($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'description' || $key == 'meta_title' || $key == 'meta_keywords' || $key == 'meta_description') {
|
|
$supplier->$key = $this->multilFild($field);
|
|
} else {
|
|
$supplier->$key = $field;
|
|
}
|
|
}
|
|
|
|
$supplier->force_id = true;
|
|
if (!$res) {
|
|
$res = $supplier->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importFeatures()
|
|
{
|
|
$this->setCurrentStatus('Features import', $step = 1);
|
|
$this->truncateTables(array('feature', 'feature_lang', 'feature_shop'));
|
|
|
|
$handle = $this->openCsvFile('features.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Feature', $this->feature_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$feature = new Feature($line[0]);
|
|
$feature->id = $line[0];
|
|
} else {
|
|
$feature = new Feature($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'name') {
|
|
$feature->$key = $this->multilFild($field);
|
|
} else {
|
|
$feature->$key = $field;
|
|
}
|
|
}
|
|
|
|
$feature->force_id = true;
|
|
if (!$res) {
|
|
$res = $feature->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importFeatureValues()
|
|
{
|
|
$this->setCurrentStatus('Feature Values import', $step = 1);
|
|
$this->truncateTables(array('feature_value', 'feature_value_lang'));
|
|
|
|
$handle = $this->openCsvFile('feature_values.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('FeatureValue', $this->feature_value_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$feature_value = new FeatureValue($line[0]);
|
|
$feature_value->id = $line[0];
|
|
} else {
|
|
$feature_value = new FeatureValue($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'value') {
|
|
$feature_value->$key = $this->multilFild($field);
|
|
} else {
|
|
$feature_value->$key = $field;
|
|
}
|
|
}
|
|
|
|
$feature_value->force_id = true;
|
|
if (!$res) {
|
|
$res = $feature_value->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
** Clean all categories tables except root & home categories
|
|
**/
|
|
public function cleanCategoriesTables()
|
|
{
|
|
$this->setCurrentStatus('Categories table clearing', $step = 1);
|
|
|
|
Db::getInstance()->execute('
|
|
DELETE FROM `'._DB_PREFIX_.'category`
|
|
WHERE id_category NOT IN ('.(int)Configuration::get('PS_HOME_CATEGORY').
|
|
', '.(int)Configuration::get('PS_ROOT_CATEGORY').')');
|
|
Db::getInstance()->execute('
|
|
DELETE FROM `'._DB_PREFIX_.'category_lang`
|
|
WHERE id_category NOT IN ('.(int)Configuration::get('PS_HOME_CATEGORY').
|
|
', '.(int)Configuration::get('PS_ROOT_CATEGORY').')');
|
|
Db::getInstance()->execute('
|
|
DELETE FROM `'._DB_PREFIX_.'category_shop`
|
|
WHERE `id_category` NOT IN ('.(int)Configuration::get('PS_HOME_CATEGORY').
|
|
', '.(int)Configuration::get('PS_ROOT_CATEGORY').')');
|
|
Db::getInstance()->execute('ALTER TABLE `'._DB_PREFIX_.'category` AUTO_INCREMENT = 3');
|
|
}
|
|
|
|
public function importProducts()
|
|
{
|
|
$this->setCurrentStatus('Products import', $step = 1);
|
|
$this->truncateTables(array('product', 'product_lang', 'product_shop',
|
|
'product_sale', 'product_supplier', 'product_tag',
|
|
'feature_product', 'category_product', 'product_carrier',
|
|
'compare_product', 'product_attachment', 'product_country_tax',
|
|
'product_download', 'product_group_reduction_cache', 'scene_products',
|
|
'warehouse_product_location', 'customization', 'customization_field',
|
|
'customization_field_lang', 'supply_order_detail', 'attribute_impact',
|
|
'pack'));
|
|
|
|
$handle = $this->openCsvFile('products.csv');
|
|
$languages = Language::getLanguages(false);
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$product = new Product((int)$line[0]);
|
|
|
|
$product->id = (int)$line[0];
|
|
$product->active = $line[1];
|
|
foreach ($languages as $lang) {
|
|
$product->name[$lang['id_lang']] = $line['2'];
|
|
}
|
|
$categories = explode(',', $line[3]);
|
|
$product->id_category_default = $categories[0] ? $categories[0] : Configuration::get('PS_HOME_CATEGORY');
|
|
|
|
if (isset($categories) && $categories && count($categories)) {
|
|
$product->addToCategories($categories);
|
|
}
|
|
|
|
if (isset($line[4])) {
|
|
$product->price_tex = $line[4];
|
|
}
|
|
if (isset($line[5])) {
|
|
$product->price_tin = $line[5];
|
|
}
|
|
|
|
$product->id_tax_rules_group = trim($line[6]) ? $line[6] : 0;
|
|
$product->wholesale_price = trim($line[7]) ? $line[7] : 0;
|
|
$product->on_sale = trim($line[8]) ? $line[8] : 0;
|
|
if (trim($line[13])) {
|
|
$product->reference = $line[13];
|
|
}
|
|
if (trim($line[14])) {
|
|
$product->supplier_reference = trim($line[14]);
|
|
}
|
|
if (trim($line[15])) {
|
|
$product->id_supplier = (int)$line[15];
|
|
}
|
|
if (isset($product->id) && $product->id && isset($product->id_supplier) && property_exists($product, 'supplier_reference')) {
|
|
$id_product_supplier = (int)ProductSupplier::getIdByProductAndSupplier((int)$product->id, 0, (int)$product->id_supplier);
|
|
if ($id_product_supplier) {
|
|
$product_supplier = new ProductSupplier($id_product_supplier);
|
|
} else {
|
|
$product_supplier = new ProductSupplier();
|
|
}
|
|
|
|
$product_supplier->id_product = (int)$product->id;
|
|
$product_supplier->id_product_attribute = 0;
|
|
$product_supplier->id_supplier = (int)$product->id_supplier;
|
|
$product_supplier->product_supplier_price_te = $product->wholesale_price;
|
|
$product_supplier->product_supplier_reference = $product->supplier_reference;
|
|
$product_supplier->save();
|
|
}
|
|
if (trim($line[16])) {
|
|
$product->id_manufacturer = $line[16];
|
|
}
|
|
if (!Tools::isEmpty(trim($line[17]))) {
|
|
$product->ean13 = $line[17];
|
|
}
|
|
if (trim($line[18])) {
|
|
$product->upc = $line[18];
|
|
}
|
|
if (trim($line[19])) {
|
|
$product->ecotax = $line[19];
|
|
}
|
|
$product->width = $line[20];
|
|
$product->height = $line[21];
|
|
$product->depth = $line[22];
|
|
$product->weight = $line[23];
|
|
if ($line[24]) {
|
|
StockAvailable::setQuantity((int)$product->id, 0, (int)$line[24], (int)$this->context->shop->id);
|
|
}
|
|
|
|
$product->minimal_quantity = $line[25];
|
|
$product->visibility = $line[26];
|
|
$product->additional_shipping_cost = $line[27];
|
|
if (trim($line[28])) {
|
|
$product->unity = $line[28];
|
|
}
|
|
if (trim($line[29])) {
|
|
$product->unit_price = $line[29];
|
|
}
|
|
foreach ($languages as $lang) {
|
|
$product->description_short[$lang['id_lang']] = $line[30];
|
|
$product->description[$lang['id_lang']] = $line[31];
|
|
}
|
|
if ($line[32]) {
|
|
foreach ($languages as $lang) {
|
|
Tag::addTags($lang['id_lang'], $product->id, $line[32]);
|
|
}
|
|
}
|
|
|
|
foreach ($languages as $lang) {
|
|
$product->meta_title[$lang['id_lang']] = $line[33];
|
|
$product->meta_keywords[$lang['id_lang']] = $line[34];
|
|
$product->meta_description[$lang['id_lang']] = $line[35];
|
|
$product->link_rewrite[$lang['id_lang']] = $line[36];
|
|
$product->available_now[$lang['id_lang']] = $line[37];
|
|
$product->available_later[$lang['id_lang']] = $line[38];
|
|
}
|
|
|
|
$product->available_for_order = $line[39];
|
|
$product->available_date = $line[40];
|
|
$product->date_add = $line[41];
|
|
$product->show_price = $line[42];
|
|
|
|
// Features import
|
|
$features = explode(',', $line[45]);
|
|
if ($features) {
|
|
foreach ($features as $feature) {
|
|
$value = explode(':', $feature);
|
|
if ($value[0] && $value[1]) {
|
|
Product::addFeatureProductImport((int)$product->id, (int)$value[0], (int)$value[1]);
|
|
SpecificPriceRule::applyAllRules(array((int)$product->id));
|
|
}
|
|
}
|
|
}
|
|
$product->online_only = trim($line[46]) ? $line[46] : 0;
|
|
$product->condition = $line[47];
|
|
$product->customizable = trim($line[48]) ? $line[48] : 0;
|
|
$product->uploadable_files = trim($line[49]) ? $line[49] : 0;
|
|
$product->text_fields = trim($line[50]) ? $line[50] : 0;
|
|
|
|
if ($product->getType() == Product::PTYPE_VIRTUAL) {
|
|
StockAvailable::setProductOutOfStock((int)$product->id, 1);
|
|
} else {
|
|
StockAvailable::setProductOutOfStock((int)$product->id, (int)$line[51]);
|
|
}
|
|
|
|
$product->id_shop_default = $line[52];
|
|
|
|
// add product accessories
|
|
if ($line[56]) {
|
|
$a = [];
|
|
$accessories = explode(',', $line[56]);
|
|
foreach ($accessories as $accessory) {
|
|
$a[]['id'] = $accessory;
|
|
}
|
|
$product->setWsAccessories($a);
|
|
}
|
|
|
|
// add product carriers
|
|
if ($line[57]) {
|
|
$carriers = explode(',', $line[57]);
|
|
$product->setCarriers($carriers);
|
|
}
|
|
|
|
// add costomisation fields
|
|
if (!Tools::isEmpty($line[58]) && class_exists('CustomizationField')) {
|
|
$customisation_fields_ids = explode(',', $line[58]);
|
|
foreach ($customisation_fields_ids as $customisation_field) {
|
|
$result = false;
|
|
$customisation_data = explode(':', $customisation_field);
|
|
$cf = new CustomizationField();
|
|
$cf->id_product = $product->id;
|
|
$cf->type = $customisation_data[1];
|
|
$cf->required = $customisation_data[2];
|
|
foreach ($languages as $lang) {
|
|
$cf->name[$lang['id_lang']] = $customisation_data[3] ? $customisation_data[3] : ' ';
|
|
}
|
|
$cf->force_id = 1;
|
|
if (!$result) {
|
|
$result = $cf->add();
|
|
}
|
|
}
|
|
}
|
|
|
|
// add attachments
|
|
if ($line[59]) {
|
|
$attachments = explode(',', $line[59]);
|
|
if (isset($attachments) && count($attachments)) {
|
|
Attachment::attachToProduct($product->id, $attachments);
|
|
}
|
|
}
|
|
|
|
if ($line[60]) {
|
|
$product->date_upd = $line[60];
|
|
}
|
|
$product->price = $line[61];
|
|
if (isset($line[62]) && $line[62]) {
|
|
$product->is_virtual = $line[62];
|
|
}
|
|
|
|
$product->force_id = 1;
|
|
if (!$res) {
|
|
$res = $product->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
Search::indexation(true);
|
|
return true;
|
|
}
|
|
|
|
public function importProductsAttributes()
|
|
{
|
|
$this->setCurrentStatus('Products Attributes import', $step = 1);
|
|
$this->truncateTables(array('product_attribute', 'product_attribute_combination', 'product_attribute_shop', 'product_attribute_image'));
|
|
|
|
$handle = $this->openCsvFile('product_attributes.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Combination', $this->product_attribute_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$attribute = new Combination($line[0]);
|
|
$attribute->id = $line[0];
|
|
} else {
|
|
$attribute = new Combination($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
$attribute->$key = $field;
|
|
}
|
|
|
|
// add attribute values in ps_product_attribute_combination
|
|
if ($line[16]) {
|
|
$values = explode(',', $line[16]);
|
|
$attribute->setAttributes($values);
|
|
}
|
|
// add attribute images to ps_product_attribute_image
|
|
if ($line[17]) {
|
|
$images = explode(',', $line[17]);
|
|
$attribute->setImages($images);
|
|
}
|
|
|
|
$attribute->force_id = true;
|
|
if (!$res) {
|
|
$res = $attribute->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importProductsPacks()
|
|
{
|
|
$this->setCurrentStatus('Products Packs import', $step = 1);
|
|
$this->truncateTables(array('pack'));
|
|
|
|
$handle = $this->openCsvFile('product_packs.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
Pack::addItem($line[0], $line[1], $line[3], $line[2]);
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importImages()
|
|
{
|
|
$this->setCurrentStatus('Images import', $step = 1);
|
|
$this->truncateTables(array('image', 'image_lang', 'image_shop'));
|
|
|
|
$handle = $this->openCsvFile('images.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Image', $this->image_fields, $line);
|
|
|
|
if (!isset($fields['id_image'])) {
|
|
$img = new Image($line[0]);
|
|
} else {
|
|
$img = new Image($fields['id_image']);
|
|
}
|
|
|
|
$img->id = $line[0];
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'legend') {
|
|
$img->$key = $this->multilFild($field);
|
|
} else {
|
|
$img->$key = $field;
|
|
}
|
|
}
|
|
|
|
$img->force_id = true;
|
|
if (!$res) {
|
|
$res = $img->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importStockAvailable()
|
|
{
|
|
$this->setCurrentStatus('Stock Available import', $step = 1);
|
|
$this->truncateTables(array('stock', 'stock_available', 'stock_mvt'));
|
|
|
|
$handle = $this->openCsvFile('stock_available.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('StockAvailable', $this->stock_available_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$sa = new StockAvailable($line[0]);
|
|
$sa->id = $line[0];
|
|
} else {
|
|
$sa = new StockAvailable($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
$sa->$key = $field;
|
|
}
|
|
|
|
$sa->force_id = true;
|
|
if (!$res) {
|
|
$res = $sa->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importSpecificPrices()
|
|
{
|
|
$this->setCurrentStatus('Specific Prices import', $step = 1);
|
|
$this->truncateTables(array('specific_price'));
|
|
|
|
$handle = $this->openCsvFile('specific_prices.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('SpecificPrice', $this->specific_price_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$specific_price = new SpecificPrice($line[0]);
|
|
$specific_price->id = $line[0];
|
|
} else {
|
|
$specific_price = new SpecificPrice($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
$specific_price->$key = $field;
|
|
}
|
|
|
|
$specific_price->force_id = true;
|
|
if (!$res) {
|
|
$res = $specific_price->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importSpecificPriceRules()
|
|
{
|
|
$this->setCurrentStatus('Specific Price Rules import', $step = 1);
|
|
$this->truncateTables(array('specific_price_rule', 'specific_price_rule_condition', 'specific_price_rule_condition_group'));
|
|
|
|
$handle = $this->openCsvFile('specific_price_rules.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('SpecificPriceRule', $this->specific_price_rule_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$specific_price_rule = new SpecificPriceRule($line[0]);
|
|
$specific_price_rule->id = $line[0];
|
|
} else {
|
|
$specific_price_rule = new SpecificPriceRule($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
$specific_price_rule->$key = $field;
|
|
}
|
|
|
|
// add price rule conditions ps_specific_price_rule_condition
|
|
if (trim($line[13])) {
|
|
$conditions = explode(',', $line[13]);
|
|
$values = array();
|
|
foreach ($conditions as $condition) {
|
|
$cond = explode(':', $condition);
|
|
$values[] = array('type' => $cond[0], 'value' => $cond[1]);
|
|
}
|
|
$specific_price_rule->addConditions($values);
|
|
}
|
|
|
|
$specific_price_rule->force_id = true;
|
|
if (!$res) {
|
|
$res = $specific_price_rule->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importContacts()
|
|
{
|
|
$this->setCurrentStatus('Contacts import', $step = 1);
|
|
$this->truncateTables(array('contact', 'contact_lang', 'contact_shop'));
|
|
|
|
$handle = $this->openCsvFile('contacts.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Contact', $this->contacts_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$contact = new Contact($line[0]);
|
|
$contact->id = $line[0];
|
|
} else {
|
|
$contact = new Contact($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'name' || $key == 'description') {
|
|
$contact->$key = $this->multilFild($field);
|
|
} else {
|
|
$contact->$key = $field;
|
|
}
|
|
}
|
|
|
|
$contact->force_id = true;
|
|
if (!$res) {
|
|
$res = $contact->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importHomeSlides()
|
|
{
|
|
if (!(int)Validate::isLoadedObject(Module::getInstanceByName('ps_imageslider')) || !Module::isEnabled('ps_imageslider') || !Module::isInstalled('ps_imageslider')) {
|
|
return true;
|
|
}
|
|
$this->setCurrentStatus('Home Slides import', $step = 1);
|
|
|
|
$new_path = new Sampledatainstall();
|
|
$sfile = $new_path->sendPath().'input/home_slides.csv';
|
|
if (!is_file($sfile) && !is_readable($sfile)) {
|
|
return true;
|
|
}
|
|
|
|
$this->truncateTables(array('homeslider', 'homeslider_slides', 'homeslider_slides_lang'));
|
|
|
|
$handle = $this->openCsvFile('home_slides.csv');
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('Ps_HomeSlide', $this->home_slide_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$slide = new Ps_HomeSlide($line[0]);
|
|
$slide->id = $line[0];
|
|
} else {
|
|
$slide = new Ps_HomeSlide($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'description' || $key == 'title' || $key == 'legend' || $key == 'url' || $key == 'image') {
|
|
$slide->$key = $this->multilFild($field);
|
|
} else {
|
|
$slide->$key = $field;
|
|
}
|
|
}
|
|
|
|
$slide->force_id = true;
|
|
if (!$res) {
|
|
$res = $slide->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importInfos()
|
|
{
|
|
if (!(int)Validate::isLoadedObject(Module::getInstanceByName('ps_customtext')) || !Module::isEnabled('ps_customtext') || !Module::isInstalled('ps_customtext')) {
|
|
return true;
|
|
}
|
|
$this->setCurrentStatus('Infos import', $step = 1);
|
|
$new_path = new Sampledatainstall();
|
|
$sfile = $new_path->sendPath().'input/customtext.csv';
|
|
$file_name = 'customtext.csv';
|
|
if (!is_file($sfile)) {
|
|
$sfile = $new_path->sendPath().'input/infos.csv';
|
|
$file_name = 'infos.csv';
|
|
}
|
|
if (!is_file($sfile) || !is_readable($sfile) || !class_exists('CustomText')) {
|
|
return true;
|
|
}
|
|
|
|
$this->truncateTables(array('info', 'info_lang', 'info_shop'));
|
|
|
|
$handle = $this->openCsvFile($file_name);
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
$res = false;
|
|
$fields = $this->filterFields('CustomText', $this->customtext_fields, $line);
|
|
|
|
if (!isset($fields['id'])) {
|
|
$info = new CustomText($line[0]);
|
|
$info->id = $line[0];
|
|
} else {
|
|
$info = new CustomText($fields['id']);
|
|
}
|
|
|
|
foreach ($fields as $key => $field) {
|
|
if ($key == 'text') {
|
|
$info->$key = $this->multilFild($field);
|
|
} else {
|
|
$info->$key = $field;
|
|
}
|
|
}
|
|
|
|
//$info->id_shop = $this->context->shop->id;
|
|
$info->force_id = true;
|
|
if (!$res) {
|
|
$res = $info->add();
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importConfigurations()
|
|
{
|
|
$this->setCurrentStatus('Configurations import', $step = 1);
|
|
$handle = $this->openCsvFile('configurations.csv');
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$this->setCurrentStatus(false, $step++);
|
|
if ($line[0] == 'PS_PURCHASE_MINIMUM' && !$line[1]) {
|
|
$line[1] = '0';
|
|
}
|
|
if ($this->logos && $this->modules && $this->content) {
|
|
if (strpos($line[1], '</') !== false) {
|
|
Configuration::updateValue($line[0], $line[1], true);
|
|
Configuration::updateValue($line[0], $line[1], true); // hack for html content adding
|
|
} else {
|
|
Configuration::updateValue($line[0], $line[1]);
|
|
}
|
|
$this->importConfigurationsLang();
|
|
} else {
|
|
if ($this->logos) {
|
|
if (in_array($line[0], array('PS_LOGO', 'PS_FAVICON', 'PS_STORES_ICON'))) {
|
|
Configuration::updateValue($line[0], $line[1]);
|
|
}
|
|
}
|
|
if ($this->modules) {
|
|
if (in_array($line[0], $this->modulesConfigList)) {
|
|
Configuration::updateValue($line[0], $line[1]);
|
|
}
|
|
$this->importConfigurationsLang();
|
|
}
|
|
if ($this->content) {
|
|
if (in_array($line[0], array('PS_ROOT_CATEGORY', 'PS_HOME_CATEGORY'))) {
|
|
Configuration::updateValue($line[0], $line[1]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importConfigurationsLang()
|
|
{
|
|
$new_path = new Sampledatainstall();
|
|
$file = $new_path->sendPath().'input/configurations_lang.csv';
|
|
if (!is_file($file)) {
|
|
return;
|
|
}
|
|
if ($handle = $this->openCsvFile('configurations_lang.csv')) {
|
|
$this->setCurrentStatus('Configurations lang import', $step = 1);
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
if (strpos($line[1], '</') !== false) {
|
|
Configuration::updateValue($line[0], array(1 => $line[1], 2 => $line[1], 3 => $line[1], 4 => $line[1]), true);
|
|
Configuration::updateValue($line[0], array(1 => $line[1], 2 => $line[1], 3 => $line[1], 4 => $line[1]), true); // hack for html content adding
|
|
} else {
|
|
Configuration::updateValue($line[0], array(1 => $line[1], 2 => $line[1], 3 => $line[1], 4 => $line[1]));
|
|
}
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function importSQLdata()
|
|
{
|
|
$this->setCurrentStatus('SQL data import', $step = 1);
|
|
$new_path = new Sampledatainstall();
|
|
$path = $new_path->sendPath().'input/';
|
|
|
|
$sql_list = Tools::scandir($path, 'sql');
|
|
$sql_settings_list = $this->getSettings();
|
|
|
|
if ($sql_list) {
|
|
foreach ($sql_list as $file) {
|
|
$this->setCurrentStatus(false, $step++, $file);
|
|
if (in_array(str_replace('sql', 'lqs', $file), $sql_settings_list['files_list'])) {
|
|
$sql = Tools::file_get_contents($path.$file);
|
|
if (Tools::isEmpty($sql)) {
|
|
return;
|
|
}
|
|
if (!Db::getInstance()->execute($sql)) {
|
|
$this->errors[] = Tools::displayError('Cannot read the .SQL file');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function getSettings($ajax = false, $rev = false)
|
|
{
|
|
if (!$rev) {
|
|
$handle = $this->openCsvFile('settings.csv');
|
|
} else {
|
|
$handle = $this->openCsvFile('settings.vsc');
|
|
}
|
|
|
|
for ($current_line = 0; $line = fgetcsv($handle, MAX_LINE_SIZE, ';'); $current_line++) {
|
|
$files_list = explode(',', $line[2]);
|
|
if ($ajax) {
|
|
$files_list = $this->filterFilesList($files_list);
|
|
}
|
|
$data = array(
|
|
'current_ps_ver' => _PS_VERSION_,
|
|
'sd_ps_ver' => $line[0],
|
|
'current_db_ver' => Configuration::get('PS_VERSION_DB'),
|
|
'sd_db_ver' => $line[1],
|
|
'files_list' => $files_list
|
|
);
|
|
}
|
|
|
|
$this->closeCsvFile($handle);
|
|
if ($ajax) {
|
|
die(json_encode($data));
|
|
} else {
|
|
return $data;
|
|
}
|
|
}
|
|
|
|
public function filterFilesList($list)
|
|
{
|
|
$result = $list;
|
|
$logos = Tools::getValue('logos');
|
|
$content = Tools::getValue('content');
|
|
$modules = Tools::getValue('modules');
|
|
$all = Tools::getValue('load_all');
|
|
if ($all == 'true') {
|
|
return $list;
|
|
}
|
|
if ($logos == 'false' || $content == 'false' || $modules == 'false') {
|
|
$result = array();
|
|
foreach ($list as $item) {
|
|
$type = explode('.', $item);
|
|
if ($modules == 'false') {
|
|
if ($type[1] == 'lqs') {
|
|
continue;
|
|
}
|
|
if (strpos($item, 'modules#') !== false) {
|
|
continue;
|
|
}
|
|
}
|
|
if ($content == 'false') {
|
|
if ($type[1] == 'vsc') {
|
|
if (($logos != 'false' || $modules != 'false') && $item == 'configurations.vsc') {
|
|
//empty yet
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
if (in_array($type[1], array('gpj', 'gnp', 'fig'))
|
|
&& (strpos($item, '#p#') !== false
|
|
|| strpos($item, '#c@') !== false
|
|
|| strpos($item, '#m@') !== false
|
|
|| strpos($item, '#s@') !== false
|
|
|| strpos($item, '#su@') !== false
|
|
|| strpos($item, '#cms@') !== false)) {
|
|
continue;
|
|
}
|
|
}
|
|
if ($logos == 'false') {
|
|
if (in_array($type[1], array('gpj', 'gnp', 'fig', 'oci')) && strpos($item, 'img@') !== false && strpos($item, '#img@') === false) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
$result[] = $item;
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function openCsvFile($file)
|
|
{
|
|
$new_path = new Sampledatainstall();
|
|
$file = $new_path->sendPath().'input/'.$file;
|
|
$handle = false;
|
|
if (is_file($file) && is_readable($file)) {
|
|
$handle = fopen($file, 'r');
|
|
}
|
|
|
|
if (!$handle) {
|
|
$this->errors[] = Tools::displayError('Cannot read the .CSV file');
|
|
}
|
|
|
|
$this->rewindBomAware($handle);
|
|
|
|
for ($i = 0; $i < 1; ++$i) {
|
|
fgetcsv($handle, MAX_LINE_SIZE, ';');
|
|
}
|
|
return $handle;
|
|
}
|
|
|
|
public function closeCsvFile($handle)
|
|
{
|
|
fclose($handle);
|
|
}
|
|
|
|
protected static function rewindBomAware($handle)
|
|
{
|
|
// A rewind wrapper that skips BOM signature wrongly
|
|
if (!is_resource($handle)) {
|
|
return false;
|
|
}
|
|
rewind($handle);
|
|
if ((fread($handle, 3)) != "\xEF\xBB\xBF") {
|
|
rewind($handle);
|
|
}
|
|
}
|
|
|
|
private function convertBytes($value)
|
|
{
|
|
/**** convert from byte to kb, mb, gb ***/
|
|
|
|
if (is_numeric($value)) {
|
|
return $value;
|
|
} else {
|
|
$value_length = Tools::strlen($value);
|
|
$qty = Tools::substr( $value, 0, $value_length - 1 );
|
|
$unit = Tools::strtolower(Tools::substr( $value, $value_length - 1 ));
|
|
switch ($unit) {
|
|
case 'k':
|
|
$qty *= 1024;
|
|
break;
|
|
case 'm':
|
|
$qty *= 1048576;
|
|
break;
|
|
case 'b':
|
|
$qty *= 1073741824;
|
|
break;
|
|
}
|
|
|
|
return $qty;
|
|
}
|
|
}
|
|
|
|
private function getBrowser()
|
|
{
|
|
/*** get info about current browser ***/
|
|
|
|
$u_agent = $_SERVER['HTTP_USER_AGENT'];
|
|
$bname = 'Unknown';
|
|
$platform = 'Unknown';
|
|
$version = '';
|
|
|
|
//First get the platform?
|
|
if (preg_match('/linux/i', $u_agent)) {
|
|
$platform = 'linux';
|
|
} else if (preg_match('/macintosh|mac os x/i', $u_agent)) {
|
|
$platform = 'mac';
|
|
} else if (preg_match('/windows|win32/i', $u_agent)) {
|
|
$platform = 'windows';
|
|
}
|
|
|
|
// Next get the name of the useragent yes seperately and for good reason
|
|
if (preg_match('/MSIE/i', $u_agent) && !preg_match('/Opera/i', $u_agent)) {
|
|
$bname = 'Internet Explorer';
|
|
$ub = 'MSIE';
|
|
} else if (preg_match('/Firefox/i', $u_agent)) {
|
|
$bname = 'Mozilla Firefox';
|
|
$ub = 'Firefox';
|
|
} else if (preg_match('/Chrome/i', $u_agent)) {
|
|
$bname = 'Google Chrome';
|
|
$ub = 'Chrome';
|
|
} else if (preg_match('/Safari/i', $u_agent)) {
|
|
$bname = 'Apple Safari';
|
|
$ub = 'Safari';
|
|
} elseif (preg_match('/Opera/i', $u_agent)) {
|
|
$bname = 'Opera';
|
|
$ub = 'Opera';
|
|
} elseif (preg_match('/Netscape/i', $u_agent)) {
|
|
$bname = 'Netscape';
|
|
$ub = 'Netscape';
|
|
}
|
|
|
|
// finally get the correct version number
|
|
$known = array('Version', $ub, 'other');
|
|
$pattern = '#(?<browser>'.join('|', $known).')[/ ]+(?<version>[0-9.|a-zA-Z.]*)#';
|
|
preg_match_all($pattern, $u_agent, $matches);
|
|
// see how many we have
|
|
$i = count($matches['browser']);
|
|
if ($i != 1) {
|
|
//we will have two since we are not using 'other' argument yet
|
|
//see if version is before or after the name
|
|
if (strripos($u_agent, 'Version') < strripos($u_agent, $ub)) {
|
|
$version = $matches['version'][0];
|
|
} else {
|
|
$version = $matches['version'][1];
|
|
}
|
|
} else {
|
|
$version = $matches['version'][0];
|
|
}
|
|
// check if we have a number
|
|
if ($version == null || $version == '') {
|
|
$version = '?';
|
|
}
|
|
|
|
return array(
|
|
'userAgent' => $u_agent,
|
|
'name' => $bname,
|
|
'version' => $version,
|
|
'platform' => $platform,
|
|
'pattern' => $pattern
|
|
);
|
|
}
|
|
|
|
private function compabilityServer()
|
|
{
|
|
/*** Check server settings ***/
|
|
// correct settings for server
|
|
$must_settings = array(
|
|
'safe_mode' => 'off',
|
|
'file_uploads' => 'on',
|
|
'memory_limit' => 128,
|
|
'post_max_size' => 8,
|
|
'upload_max_filesize' => 8,
|
|
'max_input_time' => 45,
|
|
'max_execution_time' => 30
|
|
);
|
|
// curret server settings
|
|
$current_settings = array();
|
|
//result array
|
|
$result = array();
|
|
if (ini_get('safe_mode')) {
|
|
$current_settings['safe_mode'] = 'on';
|
|
} else {
|
|
$current_settings['safe_mode'] = 'off';
|
|
}
|
|
if (ini_get('file_uploads')) {
|
|
$current_settings['file_uploads'] = 'on';
|
|
} else {
|
|
$current_settings['file_uploads'] = 'off';
|
|
}
|
|
if ((int)ini_get('memory_limit') == -1
|
|
|| str_replace((int)ini_get('memory_limit'), '', ini_get('memory_limit')) == 'G') {
|
|
$current_settings['memory_limit'] = 1000;
|
|
} else {
|
|
$current_settings['memory_limit'] = (int)ini_get('memory_limit');
|
|
}
|
|
$current_settings['post_max_size'] = (int)ini_get('post_max_size');
|
|
$current_settings['upload_max_filesize'] = (int)ini_get('upload_max_filesize');
|
|
if ((int)ini_get('max_input_time') == -1) {
|
|
$current_settings['max_input_time'] = 1000;
|
|
} else {
|
|
$current_settings['max_input_time'] = (int)ini_get('max_input_time');
|
|
}
|
|
if ((int)ini_get('max_execution_time') == 0) {
|
|
$current_settings['max_execution_time'] = 1000;
|
|
} else {
|
|
$current_settings['max_execution_time'] = (int)ini_get('max_execution_time');
|
|
}
|
|
|
|
$diff = array_diff_assoc($must_settings, $current_settings);
|
|
|
|
if (strcmp($must_settings['safe_mode'], $current_settings['safe_mode'])) {
|
|
$result['safe_mode'] = $must_settings['safe_mode'];
|
|
}
|
|
if (strcmp($must_settings['file_uploads'], $current_settings['file_uploads'])) {
|
|
$result['file_uploads'] = $must_settings['file_uploads'];
|
|
}
|
|
|
|
foreach ($diff as $key => $value) {
|
|
if ($current_settings[$key] < $value) {
|
|
$result[$key] = $value;
|
|
}
|
|
}
|
|
if (!empty($result)) {
|
|
$output = '';
|
|
$count = 0;
|
|
foreach ($result as $key => $value) {
|
|
$units = '';
|
|
if ($key == 'memory_limit' || $key == 'post_max_size' || $key == 'upload_max_filesize') {
|
|
$units = ' (Mb)';
|
|
}
|
|
if ($key == 'max_input_time' || $key == 'max_execution_time') {
|
|
$units = ' (s)';
|
|
}
|
|
$output .= '<tr>';
|
|
$output .= '<td>'.$key.$units.'</td>';
|
|
$output .= '<td class="text-center">'.$current_settings[$key].'</td>';
|
|
$output .= '<td class="text-center">'.$must_settings[$key].'</td>';
|
|
$count++;
|
|
if ($count == 3) {
|
|
$output .= '</tr>';
|
|
}
|
|
}
|
|
|
|
return $output;
|
|
}
|
|
}
|
|
|
|
private function compatibilityBrowser()
|
|
{
|
|
/*** check browser compability ***/
|
|
$response = $this->getBrowser();
|
|
$browser_not_supported = $response['name'] == 'Internet Explorer' && $response['version'] <= 9 || $response['name'] == 'Safari' && $response['version'] <= 6 ? true : false;
|
|
if ($browser_not_supported) {
|
|
$this->context->smarty->assign('info', array(
|
|
'name' => $response['name'],
|
|
'version' => $response['version']
|
|
));
|
|
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public function filesUpload()
|
|
{
|
|
$import_path = new Sampledatainstall();
|
|
/*** upload files from local storage ***/
|
|
if (array_key_exists('file', $_FILES)) {
|
|
$file_name = basename($_FILES['file']['name']);
|
|
$file_arr = explode('.', $file_name);
|
|
$file_ext = $file_arr[(count($file_arr) - 1)]; // file extension
|
|
if (count($file_arr) > 1) { // check if this file from download folder
|
|
$file_name = $file_arr['0'].'.'.strrev($file_ext);
|
|
} else {
|
|
$file_name = $file_arr['0'];
|
|
}
|
|
|
|
if (strrev($file_ext) == 'sql' || strrev($file_ext) == 'csv') {
|
|
$upload_file = $import_path->sendPath().'input/'.$file_name;
|
|
} else {
|
|
$path_tmp = explode('@', $file_name);
|
|
$file_insert_path = str_replace('\\', '/', _PS_ROOT_DIR_.'/'.str_replace('#', '/', $path_tmp[0]).'/');
|
|
$file_name = $path_tmp[1];
|
|
// check for path folder
|
|
if (!is_dir($file_insert_path)) {
|
|
@mkdir($file_insert_path, 0777, true);
|
|
}
|
|
|
|
$upload_file = $file_insert_path.$file_name;
|
|
}
|
|
|
|
if (!move_uploaded_file($_FILES['file']['tmp_name'], $upload_file)) {
|
|
die(json_encode(array('error_status' => 'File Upload Fail')));
|
|
}
|
|
die(json_encode(array('success_status' => 'File Upload Success!', 'error' => false)));
|
|
}
|
|
}
|
|
|
|
public function filterFields($class_name, $fields, $line)
|
|
{
|
|
if (count($fields) != count($line)) {
|
|
$this->clearTemporaryFolder();
|
|
die(json_encode(array('status' => 'error', 'responseText' => sprintf($this->l('Look like your %s file structure is incorrect'), $class_name))));
|
|
}
|
|
|
|
$converted_array = array();
|
|
$i = 0;
|
|
foreach ($fields as $key => $field) {
|
|
if (property_exists($class_name, $key) && !Tools::isEmpty(trim($line[$i]))) {
|
|
$converted_array[$key] = $line[$i];
|
|
}
|
|
$i++;
|
|
}
|
|
return $converted_array;
|
|
}
|
|
|
|
public function multilFild($data)
|
|
{
|
|
$res = array();
|
|
$languages = Language::getLanguages(false);
|
|
foreach ($languages as $lang)
|
|
$res[$lang['id_lang']] = $data;
|
|
return $res;
|
|
}
|
|
|
|
public function clearDb()
|
|
{
|
|
$this->setCurrentStatus('Database clearing', $step = 1);
|
|
$new_path = new Sampledatainstall();
|
|
$sql_list = Tools::scandir($new_path->sendPath().'input/', 'sql');
|
|
foreach ($sql_list as $sql) {
|
|
// return if sql file for this table is empty
|
|
if (Tools::isEmpty(trim(Tools::file_get_contents($new_path->sendPath().'input/'.$sql)))) {
|
|
return;
|
|
}
|
|
$table_name = explode('.', $sql);
|
|
if ($table_name[0] != 'themeconfigurator') {
|
|
$this->dropTable($table_name[0]);
|
|
}
|
|
$this->setCurrentStatus(false, $step++, $table_name);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function truncateTables($tables)
|
|
{
|
|
foreach ($tables as $table) {
|
|
if (count(Db::getInstance()->executeS('SHOW TABLES LIKE \''._DB_PREFIX_.$table.'\' '))) { //check if table exist
|
|
Db::getInstance()->execute('TRUNCATE TABLE `'._DB_PREFIX_.$table.'`');
|
|
}
|
|
}
|
|
}
|
|
|
|
public function dropTable($table)
|
|
{
|
|
if (count(Db::getInstance()->executeS('SHOW TABLES LIKE \''._DB_PREFIX_.$table.'\' '))) { //check if table exist
|
|
Db::getInstance()->execute('DROP TABLE `'._DB_PREFIX_.$table.'`');
|
|
}
|
|
}
|
|
|
|
public function clearTemporaryConfigEntries()
|
|
{
|
|
Configuration::deleteByName('SAMPLEDATAINSTALL_TEMP_CB');
|
|
Configuration::deleteByName('SAMPLEDATAINSTALL_TEMP_CL');
|
|
Configuration::deleteByName('SAMPLEDATAINSTALL_TEMP_CF');
|
|
|
|
return true;
|
|
}
|
|
|
|
public function setCurrentStatus($current_block = false, $current_line = false, $current_file = false)
|
|
{
|
|
if ($current_block) {
|
|
Configuration::updateValue('SAMPLEDATAINSTALL_TEMP_CB', $current_block);
|
|
}
|
|
if ($current_line) {
|
|
Configuration::updateValue('SAMPLEDATAINSTALL_TEMP_CL', $current_line);
|
|
}
|
|
if ($current_file) {
|
|
Configuration::updateValue('SAMPLEDATAINSTALL_TEMP_CF', $current_file);
|
|
}
|
|
else {
|
|
Configuration::deleteByName('SAMPLEDATAINSTALL_TEMP_CF');
|
|
}
|
|
}
|
|
|
|
public function getCurrentStatusAjax()
|
|
{
|
|
$message = sprintf($this->l('An error occurred in %s at line %s'), Configuration::get('SAMPLEDATAINSTALL_TEMP_CB'), (int)Configuration::get('SAMPLEDATAINSTALL_TEMP_CL'));
|
|
die(json_encode(array('responseText' => $message)));
|
|
}
|
|
|
|
public function clearTemporaryFolder()
|
|
{
|
|
$path = new Sampledatainstall();
|
|
$files = glob($path->sendPath().'input/{,.}*', GLOB_BRACE);
|
|
foreach ($files as $file) {
|
|
if (is_file($file)) {
|
|
@unlink($file);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function checkUploadedData($static = false)
|
|
{
|
|
$path = new Sampledatainstall();
|
|
$files = glob($path->sendPath().'input/{,.}*', GLOB_BRACE);
|
|
if ($static && !file_exists($path->sendPath().'input/settings.vsc')) {
|
|
return false;
|
|
} elseif (!$static && $files && !file_exists($path->sendPath().'input/settings.vsc')) {
|
|
return true;
|
|
} elseif (!$files || !file_exists($path->sendPath().'input/settings.vsc')) {
|
|
return false;
|
|
}
|
|
|
|
$settings = $this->getSettings(false, true);
|
|
if (!$settings) {
|
|
return false;
|
|
}
|
|
|
|
$filesByOperations = array();
|
|
foreach ($settings['files_list'] as $requiredFile) {
|
|
if (!file_exists($path->sendPath().'input/'.$requiredFile)) {
|
|
return false;
|
|
}
|
|
$file = explode('.', $requiredFile);
|
|
if (!isset($file[1])) {
|
|
continue;
|
|
}
|
|
$def = strrev($file[1]);
|
|
if (in_array($def, array('csv', 'sql'))) {
|
|
$filesByOperations['rename'][] = $requiredFile;
|
|
} else {
|
|
$filesByOperations['upload'][] = $requiredFile;
|
|
}
|
|
}
|
|
$this->filesByOperations = $filesByOperations;
|
|
|
|
return true;
|
|
}
|
|
|
|
public function prepareUploadedFiles()
|
|
{
|
|
$path = new Sampledatainstall();
|
|
if (!$this->filesByOperations) {
|
|
$this->checkUploadedData();
|
|
}
|
|
if (!$this->filesByOperations) {
|
|
return true;
|
|
}
|
|
$result = true;
|
|
foreach ($this->filesByOperations['rename'] as $file) {
|
|
$info = explode('.', $file);
|
|
$result &= rename($path->sendPath().'input/'.$file, $path->sendPath().'input/'.$info[0].'.'.strrev($info[1]));
|
|
}
|
|
foreach ($this->filesByOperations['upload'] as $file) {
|
|
$result &= $this->moveUploadedFile($file);
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function moveUploadedFile($file)
|
|
{
|
|
$path = new Sampledatainstall();
|
|
$path_tmp = explode('@', $file);
|
|
$file_insert_path = str_replace('\\', '/', _PS_ROOT_DIR_.'/'.str_replace('#', '/', $path_tmp[0]).'/');
|
|
$file_tmp_name = explode('.', $path_tmp[1]);
|
|
$file_name = $file_tmp_name[0].'.'.strrev($file_tmp_name[1]);
|
|
|
|
if (!is_dir($file_insert_path)) {
|
|
mkdir($file_insert_path, 0777, true);
|
|
}
|
|
return rename($path->sendPath().'input/'.$file, $file_insert_path.$file_name);
|
|
}
|
|
}
|