/**
* Displays a message on the appropriate output (cli or eZDebug)
*
* @param string $msg
* @param string $logType
*/
public static function writeMessage($msg, $logType = self::NOTICELOG)
{
self::$cli = eZCLI::instance();
$isWebOutput = self::$cli->isWebOutput();
switch ($logType) {
case self::ERRORLOG:
if (!$isWebOutput) {
self::$cli->error($msg);
} else {
eZDebug::writeError($msg, 'SQLIImport');
}
break;
case self::WARNINGLOG:
if (!$isWebOutput) {
self::$cli->warning($msg);
} else {
eZDebug::writeWarning($msg, 'SQLIImport');
}
break;
case self::NOTICELOG:
default:
if (!$isWebOutput) {
self::$cli->notice($msg);
} else {
eZDebug::writeNotice($msg, 'SQLIImport');
}
break;
}
}
/**
* @param string$question
* @param array $possibleReplies
* @param string $callback
* @param bool $emptyReply
* @return bool|string
*/
function askQuestion ( $question, $possibleReplies = array(), $callback = "validateReply", $emptyReply = false )
{
$response = false;
$first = true;
$this->cli->error( "$question ?" );
if ($callback != 'validateReplyRegex')
{
$this->showReplies ( $possibleReplies );
}
while ( $response === false )
{
if ( !$first )
{
$this->cli->error( "Incorrect Reply, please retry" );
}
else
{
$first = false;
}
$response = trim(fgets(STDIN));
if ( $response == '' && $emptyReply )
{
$this->cli->notice( "No given reply" );
return false;
}
$response = call_user_func( array ( $this, $callback ), $response, $possibleReplies );
}
if ( count($possibleReplies) > 0 && $callback != 'validateReplyRegex' )
{
$reply = $possibleReplies[$response];
}
else
{
$reply = $response;
}
$this->cli->notice( "Given reply : $reply" );
return $response;
}
/**
* Adds an application folder to the publisher folder if it's not yet added
* @param mixed $applicationId
* @param mixed $publisherFolderId
* @param eZCLI $cli
*/
function alignApplicationWithPublisherFolder( $applicationId, $publisherFolderId, eZCLI $cli )
{
$application = $applicationId;
$publisherFolder = $publisherFolderId;
if (! $application instanceof ApplicationLocalized )
{
$application = ApplicationLocalized::getLocalizedApplicationById( $applicationId, false );
}
if ( $application == null )
{
throw new Exception( "Application localized with id {$applicationId} does not exist." );
}
if (! $publisherFolder instanceof MMSynchPublisherFolder )
{
$publisherFolder = MMSynchPublisherFolder::fetch( $publisherFolderId );
}
if ( $publisherFolder == null )
{
throw new Exception( "Publisher folder with id {$publisherFolderId} does not exist." );
}
$remoteId = 'application_folder-' . $application->cluster_identifier . '-' . $application->applicationObject->identifier;
$applicationFolderObject = eZContentObject::fetchByRemoteID( $remoteId );
if ( $applicationFolderObject == null )
{
throw new Exception( "Application folder object with remote id {$remoteId} doesn't exist" );
}
$applicationFolderId = $applicationFolderObject->attribute( 'id' );
//use getContent with true to create problems
$path = $publisherFolder->getContent( )->fields->path->toString();
if ( $path )
{
$contentobject = $publisherFolder->getContent()->getRawContentObject();
$languages = $contentobject->availableLanguages();
foreach ( $languages as $language )
{
$dataMap = $contentobject->dataMap();
$contentObjectAttributeTargetCS = $dataMap['target_cs'];
$objectIds = explode( '-', $contentObjectAttributeTargetCS->toString() );
if ( !in_array( $applicationFolderId, $objectIds ) )
{
$objectIds[] = $applicationFolderId;
$contentObjectAttributeTargetCS->fromString( implode( '-', $objectIds ) );
$contentObjectAttributeTargetCS->store();
}
else
{
$cli->notice( "Ommiting application folder with path {$remoteId}" );
}
}
}
}
function setClusterFrontendUrlData(array $clusterDomains, eZDBInterface $db, eZCLI $cli, $dumpSql)
{
$db->beginQuery();
foreach ($clusterDomains as $clusterIdentifier => $url)
{
$query = sprintf("UPDATE bo_cluster SET frontend_url = '%s' WHERE identifier='%s';", $url, $clusterIdentifier);
if ($dumpSql) {
$cli->notice($query);
continue;
}
$cli->notice("Setting frontend_url to {$url} for cluster {$clusterIdentifier}");
$db->query($query);
}
return $db->commitQuery();
}
/**
* Starts to run the import
* @param array( SQLIImportItem ) $aImportItems
* @throws SQLIImportBaseException
* @throws ezcConfigurationNoConfigException
*/
public function runImport(array $aImportItems)
{
// First check if an import is already running
if (SQLIImportToken::importIsRunning()) {
throw new SQLIImportBaseException('Another import is already running. Aborting...', SQLIImportBaseException::IMPORT_ALREADY_RUNNING);
}
$this->token = SQLIImportToken::registerNewImport();
$this->handlePerformanceSettings();
if (empty($aImportItems)) {
// If no source handler is provided, consider processing all source handlers available
$aImportItems = $this->importINI->variable('ImportSettings', 'AvailableSourceHandlers');
}
// Process import items one by one
for ($i = 0, $iMax = count($aImportItems); $i < $iMax; ++$i) {
try {
if (!$aImportItems[$i] instanceof SQLIImportItem) {
throw new SQLIImportRuntimeException('Invalid import item !');
}
// Update status for import item
$aImportItems[$i]->setAttribute('status', SQLIImportItem::STATUS_RUNNING);
$aImportItems[$i]->store();
$this->currentImportItem = $aImportItems[$i];
// First check if this handler has all needed configuration
$handler = $aImportItems[$i]->attribute('handler');
$handlerSection = $handler . '-HandlerSettings';
if (!$this->importINI->hasSection($handlerSection)) {
// Check INI Section
throw new ezcConfigurationNoConfigException('Error : Handler "' . $handler . '" does not have proper config section in sqliimport.ini !');
}
if (!$this->importINI->hasVariable($handlerSection, 'ClassName')) {
// Check if ClassName is properly defined
throw new ezcConfigurationNoConfigException('Error : ClassName not defined for "' . $handler . '" in sqliimport.ini !');
}
// Default values
$handlerClassName = $this->importINI->variable($handlerSection, 'ClassName');
$handlerEnabled = true;
$debug = false;
$defaultParentNodeID = $this->importINI->variable('ImportSettings', 'DefaultParentNodeID');
$streamTimeout = $this->importINI->variable('ImportSettings', 'StreamTimeout');
if ($this->importINI->hasVariable($handlerSection, 'Enabled')) {
$handlerEnabled = $this->importINI->variable($handlerSection, 'Enabled') === 'true';
}
if ($this->importINI->hasVariable($handlerSection, 'Debug')) {
$debug = $this->importINI->variable($handlerSection, 'Debug') === 'enabled';
}
if ($this->importINI->hasVariable($handlerSection, 'DefaultParentNodeID')) {
$localParentNodeID = $this->importINI->variable($handlerSection, 'DefaultParentNodeID');
$defaultParentNodeID = is_int($localParentNodeID) ? (int) $localParentNode : $defaultParentNodeID;
}
if ($this->importINI->hasVariable($handlerSection, 'StreamTimeout')) {
$streamTimeout = (int) $this->importINI->variable($handlerSection, 'StreamTimeout');
}
// Check $defaultParentNodeID and throw an exception if not consistent
$parentNode = eZContentObjectTreeNode::fetch($defaultParentNodeID, false, false);
if (!$parentNode) {
throw new SQLIImportRuntimeException('Error : invalid DefaultParentNodeID ( ' . $defaultParentNodeID . ' )');
}
unset($parentNode);
// Check handler class validity
if (!class_exists($handlerClassName)) {
throw new SQLIImportRuntimeException('Error : invalid handler class "' . $handlerClassName . '". Did you regenerate autolads ?');
}
// ####################################
// ##### IMPORT HANDLER PROCESSING
// ####################################
// Instantiate the handler with appropriate options and process it.
// Handler must implement ISQLIImportHandler and extend SQLIImportAbstractHandler
$handlerOptions = $aImportItems[$i]->attribute('options');
$importHandler = new $handlerClassName($handlerOptions);
if (!$importHandler instanceof ISQLIImportHandler || !$importHandler instanceof SQLIImportAbstractHandler) {
throw new SQLIImportRuntimeException('Error : invalid handler "' . $handlerClassName . '". Must implement ISQLIImportHandler and extend SQLIImportAbstractHandler.');
}
$importHandler->handlerConfArray = $this->importINI->group($handlerSection);
$importHandler->initialize();
// Get process length to calculate advancement percentage to track advancement
$processLength = $importHandler->getProcessLength();
$percentageAdvancementStep = 100 / $processLength;
$handlerName = $importHandler->getHandlerName();
$handlerIdentifier = $importHandler->getHandlerIdentifier();
// Progress bar implementation
$progressBarOptions = array('emptyChar' => ' ', 'barChar' => '=');
$progressBar = new ezcConsoleProgressbar($this->output, $processLength, $progressBarOptions);
$progressBar->start();
$this->cli->warning('Now processing "' . $handlerName . '" handler.');
$isInterrupted = false;
while ($row = $importHandler->getNextRow()) {
try {
$progressBar->advance();
$startTime = time();
$importHandler->process($row);
} catch (Exception $e) {
SQLIImportLogger::logError('An error occurred during "' . $handlerIdentifier . '" import process : ' . $e->getMessage());
}
$aImportItems[$i]->updateProgress($percentageAdvancementStep, $importHandler->getProgressionNotes());
// Now calculate process time for this iteration
$endTime = time();
$diffTime = $endTime - $startTime;
$oldProcessTime = $aImportItems[$i]->attribute('process_time');
$aImportItems[$i]->setAttribute('process_time', $oldProcessTime + $diffTime);
$aImportItems[$i]->store(array('process_time'));
// Interruption handling
if ($aImportItems[$i]->isInterrupted()) {
$this->cli->notice();
SQLIImportLogger::logNotice('Interruption has been requested for current import ! Cleaning and aborting process...');
$isInterrupted = true;
break;
}
}
$importHandler->cleanup();
$progressBar->finish();
$this->cli->notice();
unset($importHandler);
if (!$isInterrupted) {
$aImportItems[$i]->setAttribute('status', SQLIImportItem::STATUS_COMPLETED);
$aImportItems[$i]->setAttribute('percentage', 100);
// Force percentage to 100%
$aImportItems[$i]->store();
}
// ####################################
// ##### END IMPORT HANDLER PROCESSING
// ####################################
} catch (Exception $e) {
SQLIImportLogger::logError($e->getMessage());
$aImportItems[$i]->setAttribute('status', SQLIImportItem::STATUS_FAILED);
$aImportItems[$i]->store();
if (isset($importHandler)) {
$importHandler->cleanup();
unset($importHandler);
}
continue;
}
}
}
function printFields($id, array $fields, eZCLI $cli)
{
$cli->notice("Fields for object with id {$id}");
foreach ($fields as $field)
{
$cli->output($field);
}
$cli->output();
}
