%PDF-
%PDF-
Mini Shell
Mini Shell
<?
use Bitrix\Main\Localization\Loc;
Loc::loadMessages(__FILE__);
final class CIBlockXmlImport
{
const ACTION_NOTHING = 'N';
const ACTION_DEACTIVATE = 'A';
const ACTION_REMOVE = 'D';
const STEP_INIT_IMPORT_TABLES = 'INIT_IMPORT_TABLES';
const STEP_READ_XML = 'READ_XML';
const STEP_INDEX_IMPORT_TABLES = 'INDEX_IMPORT_TABLES';
const STEP_IMPORT_METADATA = 'IMPORT_METADATA';
const STEP_IMPORT_SECTIONS = 'IMPORT_SECTIONS';
const STEP_MISSING_SECTIONS = 'MISSING_SECTIONS';
const STEP_RESORT_SECTIONS = 'RESORT_SECTIONS';
const STEP_IMPORT_ELEMENTS = 'IMPORT_ELEMENTS';
const STEP_MISSING_ELEMENTS = 'MISSING_ELEMENTS';
const STEP_IMPORT_PRODUCT_BUNDLES = 'IMPORT_PRODUCT_BUNDLES';
const STEP_FINAL = 'FINAL';
const RESULT_TYPE_SUCCESS = 0;
const RESULT_TYPE_ERROR = 1;
const TRANSLITERATION_ON_ADD = 0x0001;
const TRANSLITERATION_ON_UPDATE = 0x0002;
const SESSION_STORAGE_ID = 'BX_CML2_IMPORT';
/** @var \CIBlockCMLImport importer */
private $xmlImport = null;
private $fileHandler = null;
private $fileParameters = [
'PATH' => '',
'ABSOLUTE_PATH' => '',
'FILES_DIRECTORY' => '',
'SIZE' => 0
];
private $parameters = [];
private $config = [];
private $stepList = [
self::STEP_INIT_IMPORT_TABLES,
self::STEP_READ_XML,
self::STEP_INDEX_IMPORT_TABLES,
self::STEP_IMPORT_METADATA,
self::STEP_IMPORT_SECTIONS,
self::STEP_MISSING_SECTIONS,
self::STEP_RESORT_SECTIONS,
self::STEP_IMPORT_ELEMENTS,
self::STEP_IMPORT_PRODUCT_BUNDLES,
self::STEP_MISSING_ELEMENTS,
self::STEP_FINAL
];
private $stepId = null;
private $stepParameters = null;
private $final = false;
private $iblockId = null;
private $message = '';
private $progressCounter = [];
private $errors = [];
private $startTime = null;
public function __construct()
{
}
public function __destruct()
{
$this->closeXmlFile();
$this->destroyXmlImporter();
}
public function init(array $parameters, array $config = [])
{
$this->startTime = time();
$this->final = false;
$this->clearErrors();
$this->setParameters($parameters);
if (!$this->isSuccess())
return;
$this->setConfig($config);
if (!$this->isSuccess())
return;
$this->initSessionStorage();
if (!$this->isSuccess())
return;
$this->internalInit();
}
private function initSessionStorage()
{
if (!isset($_SESSION[self::SESSION_STORAGE_ID]) || !is_array($_SESSION[self::SESSION_STORAGE_ID]))
$_SESSION[self::SESSION_STORAGE_ID] = [];
if (!isset($_SESSION[self::SESSION_STORAGE_ID]['SECTIONS_MAP']))
$_SESSION[self::SESSION_STORAGE_ID]['SECTIONS_MAP'] = null;
if (!isset($_SESSION[self::SESSION_STORAGE_ID]['PRICES_MAP']))
$_SESSION[self::SESSION_STORAGE_ID]['PRICES_MAP'] = null;
$this->initStepParameters();
}
private function initStepParameters()
{
if (
!isset($_SESSION[self::SESSION_STORAGE_ID]['STEP_ID'])
|| (
!isset($_SESSION[self::SESSION_STORAGE_ID]['STEP_PARAMETERS'])
|| !is_array($_SESSION[self::SESSION_STORAGE_ID]['STEP_PARAMETERS'])
)
)
{
$_SESSION[self::SESSION_STORAGE_ID]['STEP_ID'] = reset($this->stepList);
$_SESSION[self::SESSION_STORAGE_ID]['STEP_PARAMETERS'] = [];
}
if (
array_search(
$_SESSION[self::SESSION_STORAGE_ID]['STEP_ID'],
$this->stepList
) === false
)
{
$this->addError(Loc::getMessage('IBLOCK_XML_IMPORT_ERR_BAD_STEP_ID'));
return;
}
$this->stepId = &$_SESSION[self::SESSION_STORAGE_ID]['STEP_ID'];
$this->stepParameters = &$_SESSION[self::SESSION_STORAGE_ID]['STEP_PARAMETERS'];
}
/**
* @return void
*/
private function internalInit()
{
$this->closeXmlFile();
$this->destroyXmlImporter();
$this->createXmlImporter();
}
/**
* @return bool
*/
public function isFinal()
{
return $this->final;
}
/**
* @return void
*/
public function run()
{
$this->setXmlImporterParameters();
$this->setMessage('');
$this->clearProgressCounter();
switch ($this->getCurrentStep())
{
case self::STEP_INIT_IMPORT_TABLES:
$this->initTemporaryTablesAction();
break;
case self::STEP_READ_XML:
$this->readXmlAction();
break;
case self::STEP_INDEX_IMPORT_TABLES:
$this->indexTemporaryTablesAction();
break;
case self::STEP_IMPORT_METADATA:
$this->importMetadataAction();
break;
case self::STEP_IMPORT_SECTIONS:
$this->importSectionsAction();
break;
case self::STEP_MISSING_SECTIONS:
$this->processMissingSectionsAction();
break;
case self::STEP_RESORT_SECTIONS:
$this->resortSectionsAction();
break;
case self::STEP_IMPORT_ELEMENTS:
$this->importElementsAction();
break;
case self::STEP_MISSING_ELEMENTS:
$this->processMissingElementsAction();
break;
case self::STEP_IMPORT_PRODUCT_BUNDLES:
$this->importProductBundlesAction();
break;
case self::STEP_FINAL:
$this->finalAction();
break;
}
}
/**
* @return array
*/
public function getStepResult()
{
$result = [];
if ($this->isSuccess())
{
$result['TYPE'] = self::RESULT_TYPE_SUCCESS;
$result['MESSAGE'] = $this->getMessage();
$result['IS_FINAL'] = 'Y';
if (!$this->isFinal())
{
$result['IS_FINAL'] = 'N';
$progress = $this->getProgressCounter();
if (!empty($progress))
$result['PROGRESS'] = $progress;
unset($progress);
}
}
else
{
$result['TYPE'] = self::RESULT_TYPE_ERROR;
$result['ERROR'] = implode("\n", $this->getErrors());
$result['IS_FINAL'] = 'Y';
}
return $result;
}
/**
* @return null|int
*/
public function getIblockId()
{
return $this->iblockId;
}
/**
* @return bool
*/
public function isSuccess()
{
return empty($this->errors);
}
/**
* @return array
*/
public function getErrors()
{
return $this->errors;
}
/**
* @return void
*/
public function clearErrors()
{
$this->errors = [];
}
/**
* @param string $error
* @return void
*/
private function addError($error)
{
$error = trim((string)$error);
if ($error === '')
return;
$this->errors[] = $error;
}
/**
* @param array $parameters
* @return void
*/
private function setParameters(array $parameters)
{
$this->prepareParameters($parameters);
if (!$this->isSuccess())
return;
$this->parameters = $parameters;
}
/**
* @param array &$parameters
* @return void
*/
private function prepareParameters(array &$parameters)
{
$parameters = array_filter($parameters, '\CIBlockXmlImport::clearNull');
$parameters = array_merge($this->getDefaultParameters(), $parameters);
$parameters['FILE'] = trim($parameters['FILE']);
if ($parameters['FILE'] === '')
{
$this->addError(Loc::getMessage('IBLOCK_XML_IMPORT_ERR_PARAMETER_FILE_IS_EMPTY'));
}
else
{
$rawFilename = $parameters['FILE'];
if(
file_exists($rawFilename)
&& is_file($rawFilename)
&& (
substr($rawFilename, -4) === ".xml"
)
)
{
$this->fileParameters['PATH'] = substr($rawFilename, strlen($_SERVER['DOCUMENT_ROOT']));
$this->fileParameters['ABSOLUTE_PATH'] = $rawFilename;
}
else
{
$rawFilename = trim(str_replace("\\", '/', $rawFilename), '/');
$filename = rel2abs($_SERVER['DOCUMENT_ROOT'], '/'.$rawFilename);
if (strlen($filename) > 1 && $filename === '/'.$rawFilename)
{
$this->fileParameters['PATH'] = $filename;
$this->fileParameters['ABSOLUTE_PATH'] = $_SERVER['DOCUMENT_ROOT'].$filename;
}
unset($filename, $rawFilename);
}
$this->fileParameters['FILES_DIRECTORY'] = substr(
$this->fileParameters['ABSOLUTE_PATH'],
0,
strrpos($this->fileParameters['ABSOLUTE_PATH'], '/') + 1
);
}
$parameters['IBLOCK_TYPE'] = trim($parameters['IBLOCK_TYPE']);
if (!is_array($parameters['SITE_LIST']))
$parameters['SITE_LIST'] = [$parameters['SITE_LIST']];
}
/**
* @param string $name
* @return mixed|null
*/
private function getParameter($name)
{
$name = (string)$name;
if ($name === '')
return null;
return (isset($this->parameters[$name]) ? $this->parameters[$name] : null);
}
/**
* @return array
*/
private function getDefaultParameters()
{
return [
'FILE' => '',
'IBLOCK_TYPE' => '',
'SITE_LIST' => [],
'MISSING_SECTION_ACTION' => self::ACTION_NOTHING,
'MISSING_ELEMENT_ACTION' => self::ACTION_NOTHING,
'INTERVAL' => 30
];
}
/**
* @param array $config
* @return void
*/
private function setConfig(array $config)
{
$this->prepareConfig($config);
if (!$this->isSuccess())
return;
$this->config = $config;
}
/**
* @param array &$config
* @return void
*/
private function prepareConfig(array &$config)
{
$config = array_filter($config, '\CIBlockXmlImport::clearNull');
$config = array_merge($this->getDefaultConfig(), $config);
}
/**
* @return array
*/
private function getConfig()
{
return $this->config;
}
private function getConfigFieldValue($field)
{
$field = (string)$field;
if ($field === '')
return null;
return (isset($this->config[$field]) ? $this->config[$field] : null);
}
/**
* @return array
*/
private function getDefaultConfig()
{
return [
'USE_CRC' => true,
'PREVIEW_PICTURE_SETTINGS' => false,
'DETAIL_PICTURE_SETTINGS' => false,
'USE_OFFERS' => false, // ?
'FORCE_OFFERS' => false, // ?
'USE_IBLOCK_TYPE_ID' => false, // ?
'TRANSLITERATION' => [
'MODE' => 0,
'SETTINGS' => [
'TRANS_LEN' => 255,
'TRANS_CASE' => 'L',
'TRANS_SPACE' => '-',
'TRANS_OTHER' => '-',
'TRANS_EAT' => 'Y',
],
],
'SKIP_ROOT_SECTION' => false, // ?
'DISABLE_CHANGE_PRICE_NAME' => false,
'TABLE_NAME' => 'b_xml_tree',
'READ_BLOCKSIZE' => 1024
];
}
/**
* @return mixed
*/
private function getCurrentStep()
{
return $this->stepId;
}
/**
* @param mixed $step
* @return void
*/
private function setCurrentStep($step)
{
$this->stepId = $step;
}
/**
* @return void
*/
private function nextStep()
{
$index = array_search($this->getCurrentStep(), $this->stepList);
if (isset($this->stepList[$index+1]))
$this->setCurrentStep($this->stepList[$index+1]);
else
$this->final = true;
}
/**
* @param string $message
* @return void
*/
private function setMessage($message)
{
$this->message = $message;
}
/**
* @return string
*/
private function getMessage()
{
return $this->message;
}
/**
* @return void
*/
private function clearProgressCounter()
{
$this->progressCounter = [];
}
/**
* @param int $total
* @param int $current
* @return void
*/
private function setProgressCounter($total, $current)
{
$this->progressCounter = [
'TOTAL' => $total,
'CURRENT' => $current
];
}
/**
* @return array|null
*/
private function getProgressCounter()
{
return (!empty($this->progressCounter) ? $this->progressCounter : null);
}
/**
* @return void
*/
private function setXmlImporterParameters()
{
$this->xmlImport->InitEx($this->stepParameters, $this->getXmlImporterConfig());
}
/**
* @return array
*/
private function getXmlImporterConfig()
{
$config = $this->getConfig();
$result = [
'files_dir' => $this->fileParameters['FILES_DIRECTORY'],
'use_crc' => $config['USE_CRC'],
'preview' => $config['PREVIEW_PICTURE_SETTINGS'],
'detail' => $config['DETAIL_PICTURE_SETTINGS'],
'use_offers' => $config['USE_OFFERS'],
'force_offers' => $config['FORCE_OFFERS'],
'use_iblock_type_id' => $config['USE_IBLOCK_TYPE_ID'],
'skip_root_section' => $config['SKIP_ROOT_SECTION'],
'disable_change_price_name' => $config['DISABLE_CHANGE_PRICE_NAME'],
'table_name' => $config['TABLE_NAME']
] + $this->getXmlImporterTransliterationSettings();
unset($config);
return $result;
}
/**
* @return void
*/
private function initTemporaryTablesAction()
{
$this->xmlImport->DropTemporaryTables();
if (!$this->xmlImport->CreateTemporaryTables())
{
$this->addError(Loc::getMessage('IBLOCK_XML_IMPORT_ERR_CANNOT_CREATE_TEMPORARY_TABLES'));
}
$this->nextStep();
}
/**
* @return void
*/
private function readXmlAction()
{
$this->openXmlFile();
if (!$this->isSuccess())
return;
if ($this->xmlImport->ReadXMLToDatabase(
$this->fileHandler,
$this->stepParameters,
$this->getParameter('INTERVAL'),
$this->getConfigFieldValue('READ_BLOCKSIZE')
))
{
$this->setMessage(Loc::getMessage('IBLOCK_XML_IMPORT_MESS_XML_FILE_READ_COMPLETE'));
$this->nextStep();
}
else
{
$this->setMessage(Loc::getMessage(
'IBLOCK_XML_IMPORT_MESS_XML_FILE_READ_PROGRESS',
['#PERCENT#' => $this->getXmlFileProgressPercent()]
));
}
$this->closeXmlFile();
}
/**
* @return void
*/
private function indexTemporaryTablesAction()
{
if (!$this->xmlImport->IndexTemporaryTables())
{
$this->addError(Loc::getMessage('IBLOCK_XML_IMPORT_ERR_CANNOT_CREATE_TEMPORARY_TABLES_INDEX'));
return;
}
$this->setMessage(Loc::getMessage('IBLOCK_XML_IMPORT_MESS_CREATE_TEMPORARY_TABLES_INDEX_COMPLETE'));
$this->nextStep();
}
/**
* @return void
*/
private function importMetadataAction()
{
$result = $this->xmlImport->ImportMetaData(
$this->xmlImport->GetRoot(),
$this->getParameter('IBLOCK_TYPE'),
$this->getParameter('SITE_LIST')
);
if ($result === true)
{
$this->nextStep();
$this->setMessage(Loc::getMessage('IBLOCK_XML_IMPORT_MESS_METADATA_IMPORT_COMPLETE'));
}
else
{
if (is_array($result))
$result = "\n".implode("\n", $result);
$this->addError(Loc::getMessage(
'IBLOCK_XML_IMPORT_ERR_METADATA_IMPORT_FAILURE',
['#ERROR#' => $result]
));
}
unset($result);
}
/**
* @return void
*/
private function importSectionsAction()
{
$result = $this->xmlImport->ImportSections();
if ($result === true)
{
$this->nextStep();
$this->setMessage(Loc::getMessage('IBLOCK_XML_IMPORT_MESS_IBLOCK_SECTIONS_IMPORT_COMPLETE'));
}
else
{
$this->addError(Loc::getMessage(
'IBLOCK_XML_IMPORT_ERR_IBLOCK_SECTIONS_IMPORT_FAILURE',
['#ERROR#' => $result]
));
}
}
/**
* @return void
*/
private function processMissingSectionsAction()
{
$this->xmlImport->DeactivateSections($this->getParameter('MISSING_SECTION_ACTION'));
$this->xmlImport->SectionsResort();
$this->nextStep();
$this->setMessage(Loc::getMessage('IBLOCK_XML_IMPORT_MESS_PROCESS_MISSING_IBLOCK_SECTIONS_COMPLETE'));
}
/**
* @return void
*/
private function resortSectionsAction()
{
$this->xmlImport->SectionsResort();
$this->nextStep();
$this->setMessage(Loc::getMessage('IBLOCK_XML_IMPORT_MESS_IBLOCK_SECTIONS_RESORT_COMPLETE'));
}
/**
* @return void
*/
private function importElementsAction()
{
$result = $this->xmlImport->GetTotalCountElementsForImport();
if (!$result)
{
$this->addError(Loc::getMessage(
'IBLOCK_XML_IMPORT_ERR_ELEMENTS_IMPORT_FAILURE',
['#ERROR#' => $this->xmlImport->LAST_ERROR]
));
return;
}
$this->xmlImport->ReadCatalogData(
$_SESSION[self::SESSION_STORAGE_ID]['SECTIONS_MAP'],
$_SESSION[self::SESSION_STORAGE_ID]['PRICES_MAP']
);
$result = $this->xmlImport->ImportElements(
$this->startTime,
$this->getParameter('INTERVAL')
);
$result = $this->xmlImport->updateCounters($result);
if ($result == 0)
{
$this->nextStep();
$this->setMessage(Loc::getMessage('IBLOCK_XML_IMPORT_MESS_IBLOCK_ELEMENTS_IMPORT_COMPLETE'));
}
else
{
$this->setMessage(Loc::getMessage(
'IBLOCK_XML_IMPORT_MESS_IBLOCK_ELEMENTS_IMPORT_PROGRESS',
[
'#TOTAL#' => $this->stepParameters['DONE']['ALL'],
'#DONE#' => $this->stepParameters['DONE']['CRC']
]
));
$this->setProgressCounter(
$this->stepParameters['DONE']['ALL'],
$this->stepParameters['DONE']['CRC']
);
}
}
/**
* @return void
*/
private function processMissingElementsAction()
{
$result = $this->xmlImport->DeactivateElement(
$this->getParameter('MISSING_ELEMENT_ACTION'),
$this->startTime,
$this->getParameter('INTERVAL')
);
$result = $this->xmlImport->updateCounters($result);
if ($result == 0)
{
$this->nextStep();
$this->setMessage(Loc::getMessage('IBLOCK_XML_IMPORT_MESS_PROCESS_MISSING_IBLOCK_ELEMENTS_COMPLETE'));
}
else
{
$this->setMessage(Loc::getMessage(
'IBLOCK_XML_IMPORT_MESS_IBLOCK_ELEMENTS_IMPORT_PROGRESS',
[
'#TOTAL#' => $this->stepParameters['DONE']['ALL'],
'#DONE#' => $this->stepParameters['DONE']['NON']
]
));
$this->setProgressCounter(
$this->stepParameters['DONE']['ALL'],
$this->stepParameters['DONE']['NON']
);
}
}
/**
* @return void
*/
private function importProductBundlesAction()
{
$this->xmlImport->ImportProductSets();
$this->nextStep();
$this->setMessage(Loc::getMessage('IBLOCK_XML_IMPORT_MESS_PRODUCT_BUNDLES_IMPORT_COMPLETE'));
}
/**
* @return void
*/
private function finalAction()
{
$this->iblockId = $this->stepParameters['IBLOCK_ID'];
$this->nextStep();
$this->setMessage(Loc::getMessage('IBLOCK_XML_IMPORT_MESS_FINAL_SUCCESS'));
$this->destroyXmlImporter();
$this->destroySessionStorage();
}
/**
* @return void
*/
private function openXmlFile()
{
$this->closeXmlFile();
if ($this->fileParameters['ABSOLUTE_PATH'] == '')
{
$this->addError(Loc::getMessage('IBLOCK_XML_IMPORT_ERR_OPEN_XML_FILE'));
return;
}
$this->fileHandler = fopen($this->fileParameters['ABSOLUTE_PATH'], 'rb');
if (!is_resource($this->fileHandler))
{
$this->addError(Loc::getMessage('IBLOCK_XML_IMPORT_ERR_OPEN_XML_FILE'));
return;
}
$this->fileParameters['SIZE'] = (int)filesize($this->fileParameters['ABSOLUTE_PATH']);
if ($this->fileParameters['SIZE'] <= 0)
{
$this->addError(Loc::getMessage('IBLOCK_XML_IMPORT_ERR_OPEN_XML_FILE'));
return;
}
}
/**
* @return void
*/
private function closeXmlFile()
{
if (!is_resource($this->fileHandler))
return;
fclose($this->fileHandler);
$this->fileHandler = null;
}
/**
* @return float|int
*/
private function getXmlFileProgressPercent()
{
if (!is_resource($this->fileHandler))
return 0;
if ($this->fileParameters['SIZE'] <= 0)
return 0;
return round($this->xmlImport->GetFilePosition()*100/$this->fileParameters['SIZE'], 2);
}
/**
* @return void
*/
private function createXmlImporter()
{
$this->xmlImport = new \CIBlockCMLImport();
}
/**
* @return void
*/
private function destroyXmlImporter()
{
if (is_object($this->xmlImport))
$this->xmlImport = null;
}
/**
* @return void
*/
private function destroySessionStorage()
{
unset($this->stepId);
unset($this->stepParameters);
if (array_key_exists(self::SESSION_STORAGE_ID, $_SESSION))
unset($_SESSION[self::SESSION_STORAGE_ID]);
}
/**
* @param int $currentValue
* @param int $mode
* @return bool
*/
private function checkTranslitMode($currentValue, $mode)
{
return ($currentValue & $mode) > 0;
}
/**
* @return array
*/
private function getXmlImporterTransliterationSettings()
{
$config = $this->getConfigFieldValue('TRANSLITERATION');
$result = [
'translit_on_add' => $this->checkTranslitMode(
$config['MODE'],
self::TRANSLITERATION_ON_ADD
),
'translit_on_update' => $this->checkTranslitMode(
$config['MODE'],
self::TRANSLITERATION_ON_UPDATE
),
'translit_params' => [
'max_len' => $config['SETTINGS']['TRANS_LEN'],
'change_case' => $config['SETTINGS']['TRANS_CASE'],
'replace_space' => $config['SETTINGS']['TRANS_SPACE'],
'replace_other' => $config['SETTINGS']['TRANS_OTHER'],
'delete_repeat_replace' => $config['SETTINGS']['TRANS_EAT'] == 'Y'
]
];
unset($config);
return $result;
}
/**
* @param mixed $value
* @return bool
*/
private static function clearNull($value)
{
return $value !== null;
}
}
Zerion Mini Shell 1.0