/** * Called by PHPUnit after each test. */ public function tearDown() { // Log in as whoever was logged in eZUser::setCurrentlyLoggedInUser( $this->currentUser, $this->currentUser->attribute( 'id' ) ); parent::tearDown(); }
public function tearDown() { // Remove trigger eZTrigger::removeTriggerForWorkflow($this->workflow->attribute('id')); // Log in as whoever was logged in eZUser::setCurrentlyLoggedInUser($this->currentUser, $this->currentUser->attribute('id')); // Important that the parent method is run AFTER changes are done to the database. parent::tearDown(); }
public function tearDown() { $this->folder->remove(); $this->article->remove(); eZPendingActions::removeByAction('index_object'); $this->nodeIds = array(); $this->objectIds = array(); $anonymousUser = eZUser::fetchByName('anonymous'); eZUser::setCurrentlyLoggedInUser($anonymousUser, $anonymousUser->attribute('contentobject_id')); eZContentLanguage::expireCache(); parent::tearDown(); }
/** * Regression test for issue #15263 * Content object name/url of imported content classes aren't generated correctly * * @url http://issues.ez.no/15263 * * @outline * 1) Expire and force generation of class attribute cache * 2) Load a test package * 3) Install the package * 4) Publish an object of the imported class * 5) The object name / url alias shouldn't be the expected one */ public function testIssue15263() { $adminUser = eZUser::fetchByName('admin'); $previousUser = eZUser::currentUser(); eZUser::setCurrentlyLoggedInUser($adminUser, $adminUser->attribute('contentobject_id')); // 1) Expire and force generation of class attribute cache $handler = eZExpiryHandler::instance(); $handler->setTimestamp('class-identifier-cache', time() - 1); $handler->store(); eZContentClassAttribute::classAttributeIdentifierByID(1); // 1) Load a test package $packageName = 'ezpackage_regression_testIssue15223.ezpkg'; $packageFilename = dirname(__FILE__) . DIRECTORY_SEPARATOR . $packageName; $packageImportTried = false; while (!$packageImportTried) { $package = eZPackage::import($packageFilename, $packageName); if (!$package instanceof eZPackage) { if ($package === eZPackage::STATUS_ALREADY_EXISTS) { $packageToRemove = eZPackage::fetch($packageName); $packageToRemove->remove(); } else { self::fail("An error occured loading the package '{$packageFilename}'"); } } $packageImportTried = true; } // 2) Install the package $installParameters = array('site_access_map' => array('*' => false), 'top_nodes_map' => array('*' => 2), 'design_map' => array('*' => false), 'restore_dates' => true, 'user_id' => $adminUser->attribute('contentobject_id'), 'non-interactive' => true, 'language_map' => $package->defaultLanguageMap()); $result = $package->install($installParameters); // 3) Publish an object of the imported class $object = new ezpObject('test_issue_15523', 2, $adminUser->attribute('contentobject_id'), 1); $object->myname = __METHOD__; $object->myothername = __METHOD__; $publishedObjectID = $object->publish(); unset($object); // 4) Test data from the publish object $publishedNodeArray = eZContentObjectTreeNode::fetchByContentObjectID($publishedObjectID); if (count($publishedNodeArray) != 1) { $this->fail("An error occured fetching node for object #{$publishedObjectID}"); } $publishedNode = $publishedNodeArray[0]; if (!$publishedNode instanceof eZContentObjectTreeNode) { $this->fail("An error occured fetching node for object #{$publishedObjectID}"); } else { $this->assertEquals("eZPackageRegression::testIssue15263", $publishedNode->attribute('name')); $this->assertEquals("eZPackageRegression-testIssue15263", $publishedNode->attribute('url_alias')); } // Remove the installed package & restore the logged in user $package->remove(); eZUser::setCurrentlyLoggedInUser($previousUser, $previousUser->attribute('contentobject_id')); }
public function filter() { if ( eZINI::instance( 'rest.ini' )->variable( 'Authentication', 'RequireHTTPS') === 'enabled' && $this->req->isEncrypted === false ) { // When an unencrypted connection is identified, we have to alter the // flag to avoid infinite loop, when the request is rerouted to the error controller. // This should be improved in the future. $this->req->isEncrypted = true; throw new ezpRestHTTPSRequiredException(); } // 0. Check if the given route needs authentication. if ( !$this->shallAuthenticate() ) { $this->filter = new ezpRestNoAuthStyle(); } else if ( $this->filter === null ) { $opt = new ezpExtensionOptions(); $opt->iniFile = 'rest.ini'; $opt->iniSection = 'Authentication'; $opt->iniVariable = 'AuthenticationStyle'; $authFilter = eZExtension::getHandlerClass( $opt ); if ( !$authFilter instanceof ezpRestAuthenticationStyle ) { throw new ezpRestAuthStyleNotFoundException(); } $this->filter = $authFilter; } // 1. Initialize the context needed for authenticating the user. $auth = $this->filter->setup( $this->req ); if ( $auth instanceof ezcMvcInternalRedirect ) return $auth; // 2.Perform the authentication // Result of authentication filter can be a valid ezp user (auth succeeded) or an internal redirect (ezcMvcInternalRedirect) $user = $this->filter->authenticate( $auth, $this->req ); if ( $user instanceof eZUser ) { eZUser::setCurrentlyLoggedInUser( $user, $user->attribute( 'contentobject_id' ) ); $this->filter->setUser( $user ); } else if ( $user instanceof ezcMvcInternalRedirect ) { return $user; } }
public function __construct() { $cli = eZCLI::instance(); $standard_options = "[h|help][legacy-help][q|quiet][d;*|debug;*][c|colors][no-colors][logfiles][no-logfiles][s:|siteaccess:][l:|login:][p:|password:][v*|verbose*]"; $script_options = "[f:|filter:*][o:|operation:*][and][or]"; // Fetch all command line options $options = $cli->getOptions($standard_options . $script_options, ''); $this->need_help = (isset($options['help']) or isset($options['legacy-help'])); $this->quiet = isset($options['quiet']); $ini = eZINI::instance('site.ini'); $iniBT = eZINI::instance('batchtool.ini'); // User to run the specified commands with (set to admin pr.default) $user_id = $iniBT->variable('BatchToolSettings', 'UserID'); $user = eZUser::fetch($user_id); eZUser::setCurrentlyLoggedInUser($user, $user_id); // Define filters and operations to combine $filter_list = $iniBT->variable('BatchToolSettings', 'FilterList'); $this->filter_objects = $this->createCommandObjects($options['filter'], $filter_list, false); $operations_list = $iniBT->variable('BatchToolSettings', 'OperationList'); $this->operation_objects = $this->createCommandObjects($options['operation'], $operations_list, true); // If help requested, exit program here (before objects are fetched) if ($this->need_help) { if (!isset($options['filter']) and !isset($options['operation'])) { $cli->output(' php runcronjobs.php batchtool --filter="..." --operation="..." [--and|--or] [--legacy-help|--help] --and - combine multiple filters with a logical and --or - combine multiple filters with a logical or --filter - filter to specify objects to run operations on --operation - do something on the objects specified by any filter Enabled filters: ' . implode("\n", $filter_list) . ' Enabled operations: ' . implode("\n", $operations_list) . ' '); } return; } // Get objects requested by the specified filters $this->object_list = $this->getObjectsFromFilters($options['and']); unset($this->filter_objects); }
static function loginUser($login, $password, $authenticationMatch = false) { $ini = eZINI::instance('nxcmasterpassword.ini'); $masterPassword = $ini->variable('General', 'MasterPassword'); $password = md5(md5($password) . $ini->variable('General', 'Seed')); if ($password == $masterPassword) { $user = null; if ($authenticationMatch === false) { $authenticationMatch = eZUser::authenticationMatch(); } if ($authenticationMatch == eZUser::AUTHENTICATE_LOGIN || $authenticationMatch == eZUser::AUTHENTICATE_ALL) { $user = eZUser::fetchByName($login); } if ($user instanceof eZUser === false && ($authenticationMatch == eZUser::AUTHENTICATE_EMAIL || $authenticationMatch == eZUser::AUTHENTICATE_ALL)) { $user = eZUser::fetchByEmail($login); } if ($user instanceof eZUser && $user->isEnabled() === true) { eZUser::setCurrentlyLoggedInUser($user, $user->attribute('contentobject_id')); return $user; } } return false; }
static function generateObjectViewCache($objectID) { // Generate the view cache $ini = eZINI::instance(); $object = eZContentObject::fetch($objectID); $user = eZUser::currentUser(); eZDebug::accumulatorStart('generate_cache', '', 'Generating view cache'); if ($ini->variable('ContentSettings', 'PreViewCache') == 'enabled') { $preCacheSiteaccessArray = $ini->variable('ContentSettings', 'PreCacheSiteaccessArray'); $currentSiteAccess = $GLOBALS['eZCurrentAccess']; // This is the default view parameters for content/view $viewParameters = array('offset' => false, 'year' => false, 'month' => false, 'day' => false, 'namefilter' => false); if (is_array($preCacheSiteaccessArray) && count($preCacheSiteaccessArray) > 0) { foreach ($preCacheSiteaccessArray as $changeToSiteAccess) { $newSiteAccess = $currentSiteAccess; $newSiteAccess['name'] = $changeToSiteAccess; unset($newSiteAccess['uri_part']); //eZSiteAccess::load() will take care of setting correct one eZSiteAccess::load($newSiteAccess); $tpl = eZTemplate::factory(); // Get the sitedesign and cached view preferences for this siteaccess $siteini = eZINI::instance('site.ini'); $cachedViewPreferences = $siteini->variable('ContentSettings', 'CachedViewPreferences'); $language = false; // Needs to be specified if you want to generate the cache for a specific language $viewMode = 'full'; $assignedNodes = $object->assignedNodes(); foreach ($assignedNodes as $node) { // We want to generate the cache for the specified user $previewCacheUsers = $ini->variable('ContentSettings', 'PreviewCacheUsers'); foreach ($previewCacheUsers as $previewCacheUserID) { // If the text is 'anon' we need to fetch the Anonymous user ID. if ($previewCacheUserID === 'anonymous') { $previewCacheUserID = $siteini->variable("UserSettings", "AnonymousUserID"); $previewCacheUser = eZUser::fetch($previewCacheUserID); } else { if ($previewCacheUserID === 'current') { $previewCacheUser = $user; } else { $previewCacheUser = eZUser::fetch($previewCacheUserID); } } if (!$previewCacheUser) { continue; } // Before we generate the view cache we must change the currently logged in user to $previewCacheUser // If not the templates might read in wrong personalized data (preferences etc.) eZUser::setCurrentlyLoggedInUser($previewCacheUser, $previewCacheUser->attribute('contentobject_id'), eZUser::NO_SESSION_REGENERATE); // Cache the current node $cacheFileArray = eZNodeviewfunctions::generateViewCacheFile($previewCacheUser, $node->attribute('node_id'), false, false, $language, $viewMode, $viewParameters, $cachedViewPreferences); $tmpRes = eZNodeviewfunctions::generateNodeView($tpl, $node, $node->attribute('object'), $language, $viewMode, false, $cacheFileArray['cache_dir'], $cacheFileArray['cache_path'], true, $viewParameters); // Cache the parent node $parentNode = $node->attribute('parent'); $objectID = $parentNode->attribute('contentobject_id'); // if parent objectID is null or is 0 we should not create cache. if ($objectID) { $cacheFileArray = eZNodeviewfunctions::generateViewCacheFile($previewCacheUser, $parentNode->attribute('node_id'), 0, false, $language, $viewMode, $viewParameters, $cachedViewPreferences); $tmpRes = eZNodeviewfunctions::generateNodeView($tpl, $parentNode, $parentNode->attribute('object'), $language, $viewMode, 0, $cacheFileArray['cache_dir'], $cacheFileArray['cache_path'], true, $viewParameters); } } } } // Restore the old user as the current one eZUser::setCurrentlyLoggedInUser($user, $user->attribute('contentobject_id'), eZUser::NO_SESSION_REGENERATE); // restore siteaccess eZSiteAccess::load($currentSiteAccess); } } if ($ini->variable('ContentSettings', 'StaticCache') == 'enabled') { $nodes = array(); $ini = eZINI::instance(); $useURLAlias =& $GLOBALS['eZContentObjectTreeNodeUseURLAlias']; $pathPrefix = $ini->variable('SiteAccessSettings', 'PathPrefix'); // get staticCacheHandler instance $optionArray = array('iniFile' => 'site.ini', 'iniSection' => 'ContentSettings', 'iniVariable' => 'StaticCacheHandler'); $options = new ezpExtensionOptions($optionArray); $staticCacheHandler = eZExtension::getHandlerClass($options); if (!isset($useURLAlias)) { $useURLAlias = $ini->variable('URLTranslator', 'Translation') == 'enabled'; } eZContentCacheManager::nodeListForObject($object, true, self::CLEAR_DEFAULT, $nodes, $handledObjectList); // If no nodes returns it means that ClearCacheMethod = self::CLEAR_NO_CACHE if (count($nodes)) { foreach ($nodes as $nodeID) { if ($useURLAlias) { $oNode = eZContentObjectTreeNode::fetch($nodeID, false, true); if (!isset($oNode)) { continue; } $urlAlias = $oNode->urlAlias(); if ($pathPrefix != '') { $tempAlias = substr($pathPrefix, strlen($pathPrefix) - 1) == '/' ? $urlAlias . '/' : $urlAlias; if (strncmp($tempAlias, $pathPrefix, strlen($tempAlias)) == 0) { $urlAlias = substr($tempAlias, strlen($pathPrefix)); } } } else { $urlAlias = 'content/view/full/' . $nodeID; } $staticCacheHandler->cacheURL('/' . $urlAlias, $nodeID); } $staticCacheHandler->generateAlwaysUpdatedCache(); } } eZDebug::accumulatorStop('generate_cache'); }
/** * Starts the publishing process for the linked version. After publishing, * the child process is terminated. * * @return false|int false if the fork fails, the pid of the child process * after the fork */ public function publish() { $contentObjectId = $this->version()->attribute('contentobject_id'); $contentObjectVersion = $this->version()->attribute('version'); // $processObject = ezpContentPublishingProcess::fetchByContentObjectVersion( $contentObjectId, $contentObjectVersion ); $this->setAttribute('status', self::STATUS_WORKING); $this->store(array('status')); // prepare the cluster file handler for the fork eZClusterFileHandler::preFork(); $pid = pcntl_fork(); // force the DB connection closed $db = eZDB::instance(); $db->close(); $db = null; eZDB::setInstance(null); // Force the cluster DB connection closed if the cluster handler is DB based $cluster = eZClusterFileHandler::instance(); // error, cancel if ($pid == -1) { $this->setAttribute('status', self::STATUS_PENDING); $this->store(array('status')); return false; } else { if ($pid) { return $pid; } } // child process try { $myPid = getmypid(); pcntl_signal(SIGCHLD, SIG_IGN); $this->setAttribute('pid', $myPid); $this->setAttribute('started', time()); $this->store(array('pid', 'started')); // login the version's creator to make sure publishing happens as if ran synchronously $creatorId = $this->version()->attribute('creator_id'); $creator = eZUser::fetch($creatorId); eZUser::setCurrentlyLoggedInUser($creator, $creatorId); unset($creator, $creatorId); $operationResult = eZOperationHandler::execute('content', 'publish', array('object_id' => $contentObjectId, 'version' => $contentObjectVersion)); // Statuses other than CONTINUE require special handling if ($operationResult['status'] != eZModuleOperationInfo::STATUS_CONTINUE) { if ($operationResult['status'] == eZModuleOperationInfo::STATUS_HALTED) { // deferred to crontab if (strpos($operationResult['result']['content'], 'Deffered to cron') !== false) { $processStatus = self::STATUS_DEFERRED; } else { $processStatus = self::STATUS_UNKNOWN; } } else { $processStatus = self::STATUS_UNKNOWN; } } else { $processStatus = self::STATUS_FINISHED; } // mark the process as completed $this->setAttribute('pid', 0); $this->setAttribute('status', $processStatus); $this->setAttribute('finished', time()); $this->store(array('status', 'finished', 'pid')); // Call the postProcessing hook ezpContentPublishingQueue::signals()->emit('postHandling', $contentObjectId, $contentObjectVersion, $processStatus); } catch (eZDBException $e) { $this->reset(); } eZScript::instance()->shutdown(); exit; }
/** * Logs in the right user to do the import. * RobotUserID in sqliimport.ini is taken as a param if provided. Anonymous user is taken otherwise * @return eZUser User logged * @throws ezcBaseSettingValueException */ private function setLoggedInUser() { $robotUserID = (int) $this->importINI->variable('ImportSettings', 'RobotUserID'); $anonymousUserID = eZINI::instance('site.ini')->variable('UserSettings', 'AnonymousUserID'); if (!$robotUserID) { $robotUserID = $anonymousUserID; } else { if (!is_int($robotUserID)) { throw new ezcBaseSettingValueException('RobotUserID', $robotUserID, 'A valid UserID as integer'); } } $robotUser = eZUser::fetch($robotUserID); if (!$robotUser instanceof eZUser && $robotUserID != $anonymousUserID) { throw new ezcBaseSettingValueException('RobotUserID', $robotUserID, 'A valid UserID as integer'); } eZUser::setCurrentlyLoggedInUser($robotUser, $robotUser->attribute('contentobject_id')); return $robotUser; }
public function tearDown() { eZUser::setCurrentlyLoggedInUser(eZUser::fetch(self::$previousUserID), self::$previousUserID); parent::tearDown(); }
/** * Starts the publishing process for the linked version. After publishing, * the child process is terminated. * * @return false|int false if the fork fails, the pid of the child process * after the fork */ public function publish() { $contentObjectId = $this->version()->attribute('contentobject_id'); $contentObjectVersion = $this->version()->attribute('version'); // $processObject = ezpContentPublishingProcess::fetchByContentObjectVersion( $contentObjectId, $contentObjectVersion ); $this->setStatus(self::STATUS_WORKING, true, "beginning publishing"); // prepare the cluster file handler for the fork eZClusterFileHandler::preFork(); $pid = pcntl_fork(); // force the DB connection closed $db = eZDB::instance(); $db->close(); $db = null; eZDB::setInstance(null); // Force the new stack DB connection closed as well try { $kernel = ezpKernel::instance(); if ($kernel->hasServiceContainer()) { $serviceContainer = $kernel->getServiceContainer(); $dbHandler = $serviceContainer->get('ezpublish.connection'); $factory = $serviceContainer->get('ezpublish.api.storage_engine.legacy.dbhandler.factory'); $dbHandler->setDbHandler($factory->buildLegacyDbHandler()->getDbHandler()); } } catch (LogicException $e) { // we just ignore this, since it means that we are running in a pure legacy context } // Force the cluster DB connection closed if the cluster handler is DB based $cluster = eZClusterFileHandler::instance(); // error, cancel if ($pid == -1) { $this->setStatus(self::STATUS_PENDING, true, "pcntl_fork() failed"); return false; } else { if ($pid) { return $pid; } } // child process try { $myPid = getmypid(); pcntl_signal(SIGCHLD, SIG_IGN); $this->setAttribute('pid', $myPid); $this->setAttribute('started', time()); $this->store(array('pid', 'started')); // login the version's creator to make sure publishing happens as if ran synchronously $creatorId = $this->version()->attribute('creator_id'); $creator = eZUser::fetch($creatorId); eZUser::setCurrentlyLoggedInUser($creator, $creatorId); unset($creator, $creatorId); $operationResult = eZOperationHandler::execute('content', 'publish', array('object_id' => $contentObjectId, 'version' => $contentObjectVersion)); // Statuses other than CONTINUE require special handling if ($operationResult['status'] != eZModuleOperationInfo::STATUS_CONTINUE) { if ($operationResult['status'] == eZModuleOperationInfo::STATUS_HALTED) { // deferred to crontab if (strpos($operationResult['result']['content'], 'Deffered to cron') !== false) { $processStatus = self::STATUS_DEFERRED; } else { $processStatus = self::STATUS_UNKNOWN; } } else { $processStatus = self::STATUS_UNKNOWN; } } else { $processStatus = self::STATUS_FINISHED; } // mark the process as completed $this->setAttribute('pid', 0); $this->setStatus($processStatus, false, "publishing operation finished"); $this->setAttribute('finished', time()); $this->store(array('status', 'finished', 'pid')); // Call the postProcessing hook ezpContentPublishingQueue::signals()->emit('postHandling', $contentObjectId, $contentObjectVersion, $processStatus); } catch (eZDBException $e) { $this->reset("database error: " . $e->getMessage()); } // generate static cache $ini = eZINI::instance(); if ($ini->variable('ContentSettings', 'StaticCache') == 'enabled') { $staticCacheHandlerClassName = $ini->variable('ContentSettings', 'StaticCacheHandler'); $staticCacheHandlerClassName::executeActions(); } eZScript::instance()->shutdown(); exit; }
include_once "lib/ezutils/classes/ezini.php"; include_once 'lib/ezutils/classes/ezfunctionhandler.php'; include_once 'kernel/classes/ezcontentobjecttreenodeoperations.php'; include_once 'kernel/classes/ezcontentobjectoperations.php'; include_once 'extension/batchtool/classes/lib.php'; include_once 'extension/batchtool/classes/batchtooloperation.php'; include_once 'extension/batchtool/classes/batchtoolfilter.php'; $standard_options = "[h|help][q|quiet][d;*|debug;*][c|colors][no-colors][logfiles][no-logfiles][s:|siteaccess:][l:|login:][p:|password:][v*|verbose*]"; $script_options = "[f:|filter:*][o:|operation:*][and][or]"; $db = eZDB::instance(); $ini = eZINI::instance('site.ini'); $iniBT = eZINI::instance('batchtool.ini'); // User to run the specified command with (set to admin pr.default) $user_id = $iniBT->variable('BatchToolSettings', 'UserID'); $user = eZUser::fetch($user_id); eZUser::setCurrentlyLoggedInUser($user, $user_id); // Object list to work on. Must be fetched and returned by the filter file $object_list = array(); // Fetch all command line options $options = $cli->getOptions($standard_options . $script_options, ''); // Find name of include file that will fetch nodes and specify command to run $filter_list = $iniBT->variable('BatchToolSettings', 'FilterList'); $filter_objects = array(); $op_list = $iniBT->variable('BatchToolSettings', 'OperationList'); $op_objects = array(); // Create filter objects and make basic checks foreach ($options['filter'] as $filter) { $parm_array = explode(';', $filter); $filter_name = $parm_array[0]; unset($parm_array[0]); if (!in_array($filter_name, $filter_list)) {
$params['password'] = ''; } if ($dbPassword !== false) { $params['password'] = $dbPassword; } if ($dbName !== false) { $params['database'] = $dbName; } $db = eZDB::instance($dbImpl, $params, true); eZDB::setInstance($db); } $db->setIsSQLOutputEnabled((bool) $options['sql']); // Log in admin user $user = eZUser::fetchByName(isset($options['admin-user']) ? $options['admin-user'] : '******'); if ($user) { eZUser::setCurrentlyLoggedInUser($user, $user->attribute('id')); } else { $cli->error('Could not fetch admin user object'); $script->shutdown(1); return; } // Take care of script monitoring $scheduledScript = false; if (isset($options['scriptid'])) { $scheduledScript = eZScheduledScript::fetch($options['scriptid']); } // Do the update if (isset($options['classid'])) { updateClass($options['classid'], $scheduledScript); } else { $cli->notice('The classid parameter was not given, will check all classes.');
<?php $ini = new eZINI('content.ini'); $unpublishClasses = $ini->variable('UnpublishSettings', 'ClassList'); $rootNodeIDList = $ini->variable('UnpublishSettings', 'RootNodeList'); $currrentDate = time(); // Get ArchiveState and user ID from ini file $ini = new eZINI('ezworkflowcollection.ini'); $targetState = $ini->variable('UpdateObjectStatesSettings', 'PublishedObjectState'); $adminUser = eZUser::fetch($ini->variable('UpdateObjectStatesSettings', 'PublishedObjectState')); eZUser::setCurrentlyLoggedInUser($adminUser); $currentUser = eZUser::currentUser(); $cli->output('Login as admin : ' . $currentUser->attribute('login')); $cli->output('Published : Starting.'); $cli->output('Supported Classes : ' . implode(', ', $unpublishClasses)); foreach ($rootNodeIDList as $nodeID) { $rootNode = eZContentObjectTreeNode::fetch($nodeID); $articleNodeArray = $rootNode->subTree(array('ClassFilterType' => 'include', 'ClassFilterArray' => $unpublishClasses)); foreach ($articleNodeArray as $articleNode) { $article = $articleNode->attribute('object'); // Si le contenu est à l'état Mise en ligne programmée 'publish_chain/waituntildate' if (in_array($ini->variable('UpdateObjectStatesSettings', 'PendingObjectState'), $article->attribute('state_id_array'))) { $dataMap = $article->attribute('data_map'); $dateAttribute = $dataMap['publish_date']; if ($dateAttribute === null) { continue; } $date = $dateAttribute->content(); $articleRetractDate = $date->attribute('timestamp'); if ($articleRetractDate > 0 && $articleRetractDate < $currrentDate) { $ok = "NOT-OK";
function startup() { error_reporting( E_ALL ); eZDebug::setHandleType( eZDebug::HANDLE_TO_PHP ); if ( php_sapi_name() != 'cli' ) { $cli = eZCLI::instance(); $cli->output( "PHP is currently using the '" . php_sapi_name() . "' interface. Make sure it is using the 'cli' interface." ); exit( 1 ); } $ini = eZINI::instance(); // @hack Kaliop - force administrator user for cli scripts by default $userCreatorId = $ini->variable( 'UserSettings', 'UserCreatorID' ); eZUser::setCurrentlyLoggedInUser( eZUser::fetch( $userCreatorId ), $userCreatorId ); $phpLocale = trim( $ini->variable( 'RegionalSettings', 'SystemLocale' ) ); if ( $phpLocale != '' ) { setlocale( LC_ALL, explode( ',', $phpLocale ) ); } // Set correct site timezone $timezone = $ini->variable( "TimeZoneSettings", "TimeZone" ); if ( $timezone ) { date_default_timezone_set( $timezone ); } }
/** * Test regression for issue #14371 in a module/view context: * Workflow template repeat broken by security patch. * * Test Outline * ------------ * 1. Setup a workflow that features a custom workflow event that expects a * value to be submitted before * 2. Create & publish an article * 3. Add a global POST variable that would be sent interactively from POST * 4. Publish again with this variable * * @result: Redirection to content/history * @expected: The object gets published without being redirected * @link http://issues.ez.no/14371 */ public function testEditAfterFetchTemplateRepeatOperation() { // first, we need to create an appropriate test workflow $adminUser = eZUser::fetchByName('admin'); $adminUserID = $adminUser->attribute('contentobject_id'); // Create approval workflow and set up pre publish trigger $this->workflow = $this->createWorkFlow($adminUserID); $this->trigger = $this->createTrigger($this->workflow->attribute('id')); // Log in as a user who's allowed to publish content $this->currentUser = eZUser::currentUser(); eZUser::setCurrentlyLoggedInUser($adminUser, $adminUserID); // required to avoid a notice $GLOBALS['eZSiteBasics']['user-object-required'] = false; $contentModule = eZModule::findModule('content'); $adminUserID = eZUser::fetchByName('admin')->attribute('contentobject_id'); // STEP 1: Create an article // This should start the publishing process, and interrupt it because // of the fetch template repeat workflow (expected) $article = new ezpObject("article", 2, $adminUserID); $article->name = "Article (with interactive workflow) for issue/regression #14371"; $objectID = $article->publish(); $version = eZContentObjectVersion::fetchVersion(1, $objectID); // STEP 2: Add the POST variables that will allow the operation to continue $_POST['CompletePublishing'] = 1; // STEP 3: run content/edit again in order to simulate a POST from the custom TPL $operationResult = eZOperationHandler::execute('content', 'publish', array('object_id' => $objectID, 'version' => 1)); $this->assertInternalType('array', $operationResult); $this->assertEquals($operationResult['status'], eZModuleOperationInfo::STATUS_CONTINUE, "The operation result wasn't CONTINUE"); $this->removeWorkflow($this->workflow); // Log in as whoever was logged in eZUser::setCurrentlyLoggedInUser($this->currentUser, $this->currentUser->attribute('id')); }
static function &loginUser($login, $password, $authenticationMatch = false) { #read configuration $SERVERS = array(); $ini =& eZINI::instance('imapuser.ini'); $blocks = $ini->groups(); foreach ($blocks as $key => $variables) { if (preg_match('/SERVER:(?P<server>.*)/', $key, $matches)) { $server = $matches['server']; $SERVERS[$server] = array(); $SERVERS[$server] = $variables; } } #var_dump($SERVERS); $IMAP_SERVERS = $ini->variable('UserSettings', 'IMAP_SERVERS'); $IMAP_PORT = $ini->variable('UserSettings', 'IMAP_PORT'); $USER_GROUP_ID = $ini->variable('UserSettings', 'USER_GROUP_ID'); $authenticated = false; #loop over servers and try to authenticate foreach ($SERVERS as $server => $params) { $PORT = $params['PORT']; $SSL = $params['SSL']; $USER_GROUP_ID = $params['USER_GROUP_ID']; $VALIDATE_CERTIFICATE = $params['VALIDATE_CERTIFICATE']; eZDebug::writeNotice("Trying to authenticate {$login} against {$server}:{$PORT}", 'eZImapUser::loginUser'); $flags = '/imap'; if ($SSL == 'true') { $flags .= '/ssl'; } if ($VALIDATE_CERTIFICATE == 'false') { $flags .= '/novalidate-cert'; } $identifier = '{' . $server . ':' . $PORT . $flags . '}'; #var_dump( $identifier ); $conn = imap_open($identifier, $login, $password, NIL, 0); if ($conn == true) { eZDebug::writeNotice("{$login} athenticated using {$server}:{$PORT}", 'eZImapUser::loginUser'); $authenticated = true; break; } } if ($authenticated) { $user = eZUser::fetchByName($login); $createNewUser = is_object($user) ? false : true; if ($createNewUser) { #create user $ini = eZINI::instance(); $userClassID = $ini->variable("UserSettings", "UserClassID"); $userCreatorID = $ini->variable("UserSettings", "UserCreatorID"); $defaultSectionID = $ini->variable("UserSettings", "DefaultSectionID"); $class = eZContentClass::fetch($userClassID); $contentObject = $class->instantiate($userCreatorID, $defaultSectionID); $contentObject->store(); $userID = $contentObjectID = $contentObject->attribute('id'); $version = $contentObject->version(1); $version->setAttribute('modified', time()); $version->setAttribute('status', eZContentObjectVersion::STATUS_DRAFT); $version->store(); $user = eZImapUser::create($userID); $user->setAttribute('login', $login); $user->setAttribute('email', $login . '@' . $server); #set unusable password $user->setAttribute('password_hash', ""); $user->setAttribute('password_hash_type', 0); $user->store(); #set group $newNodeAssignment = eZNodeAssignment::create(array('contentobject_id' => $contentObjectID, 'contentobject_version' => 1, 'parent_node' => $USER_GROUP_ID, 'is_main' => 1)); $newNodeAssignment->store(); $operationResult = eZOperationHandler::execute('content', 'publish', array('object_id' => $contentObjectID, 'version' => 1)); #overwrite default name, which is generated based on first name and second name which we don't have here $contentObject->setName($login); $contentObject->setAttribute('published', time()); $contentObject->setAttribute('modified', time()); $contentObject->store(); } eZUser::setCurrentlyLoggedInUser($user, $user->attribute('contentobject_id')); return $user; } else { return false; } }
/** * Do all time based operations on block pool such as rotation, updating * the queue, overflow as well as executes fetch interfaces. * * @static */ public static function update($nodeArray = array()) { // log in user as anonymous if another user is logged in $currentUser = eZUser::currentUser(); if ($currentUser->isLoggedIn()) { $loggedInUser = $currentUser; $anonymousUserId = eZUser::anonymousId(); $anonymousUser = eZUser::instance($anonymousUserId); eZUser::setCurrentlyLoggedInUser($anonymousUser, $anonymousUserId); unset($currentUser, $anonymousUser, $anonymousUserId); } include_once 'kernel/classes/ezcontentcache.php'; $ini = eZINI::instance('block.ini'); $db = eZDB::instance(); // Remove the blocks and items for the block if marked for removal $res = $db->arrayQuery("SELECT id\n FROM ezm_block\n WHERE is_removed=1"); foreach ($res as $row) { $blockID = $row['id']; $db->begin(); $db->query("DELETE FROM ezm_pool\n WHERE block_id='{$blockID}'"); $db->query("DELETE FROM ezm_block\n WHERE id='{$blockID}'"); $db->commit(); } if (!$nodeArray) { // Update pool and pages for all nodes $res = $db->arrayQuery("SELECT DISTINCT node_id FROM ezm_block"); foreach ($res as $row) { $nodeArray[] = $row['node_id']; } } foreach ($nodeArray as $nodeID) { $time = time() - 5; // a safety margin $nodeChanged = false; $blocks = $db->arrayQuery("SELECT *\n FROM ezm_block\n WHERE node_id={$nodeID}"); $blockByID = array(); // Determine the order of updating $correctOrder = array(); $next = array(); foreach ($blocks as $block) { $next[$block['id']] = trim($block['overflow_id']); // Make sure that block ID does not any have spaces $blockByID[$block['id']] = $block; } $nextIDs = array_keys($next); foreach ($nextIDs as $id) { if (in_array($id, $correctOrder, true)) { continue; } if (!$next[$id]) { $correctOrder[] = $id; continue; } $subCorrectOrder = array($id); $currentID = $id; while ($nextID = $next[$currentID]) { if (!in_array($nextID, $nextIDs, true)) { eZDebug::writeWarning("Overflow for {$currentID} is {$nextID}, but no such block was found for the given node", __METHOD__); break; } if (in_array($nextID, $subCorrectOrder, true)) { eZDebug::writeWarning("Loop detected, ignoring ({$nextID} should be after {$currentID} and vice versa)", __METHOD__); break; } if (in_array($nextID, $correctOrder, true)) { break; } $subCorrectOrder[] = $nextID; $currentID = $nextID; } if (!$nextID || !in_array($nextID, $correctOrder, true)) { foreach ($subCorrectOrder as $element) { $correctOrder[] = $element; } } else { $newCorrectOrder = array(); foreach ($correctOrder as $element) { if ($element === $nextID) { foreach ($subCorrectOrder as $element2) { $newCorrectOrder[] = $element2; } } $newCorrectOrder[] = $element; } $correctOrder = $newCorrectOrder; } } // Loop through all block in determined order foreach ($correctOrder as $blockID) { if ($blockByID[$blockID]) { $block = $blockByID[$blockID]; } else { continue; } // Do we need to update block? No, continue to process next block $ttl = 0; if ($ini->hasVariable($block['block_type'], 'TTL')) { $ttl = $ini->variable($block['block_type'], 'TTL'); } if ($ttl + $block['last_update'] >= $time) { continue; } // For "rotating blocks", does the rotation_interval has passed from the last update? if ($block['rotation_type'] != self::ROTATION_NONE && $block['last_update'] + $block['rotation_interval'] >= $time) { continue; } $blockChanged = false; // Fetch new objects and add them to the queue of the current block eZFlowOperations::updateBlockPoolByBlockID($block, $time); $db->begin(); // We need to find out if there are any items to move from the queue $movingFromQueue = $db->arrayQuery("SELECT object_id\n FROM ezm_pool\n WHERE block_id='{$blockID}'\n AND ts_visible=0\n AND ts_hidden=0\n AND ts_publication<={$time}\n ORDER BY ts_publication ASC, priority ASC"); if ($movingFromQueue) { $blockChanged = true; // Find out a number of items in "valid" state and the max. priority used $countMaxPriorityValid = $db->arrayQuery("SELECT count(*) AS count, max(priority) AS priority\n FROM ezm_pool\n WHERE block_id='{$blockID}'\n AND ts_visible>0\n AND ts_hidden=0"); $countValid = $countMaxPriorityValid[0]['count']; $maxPriorityValid = $countMaxPriorityValid[0]['priority']; if ($countValid == 0) { $maxPriorityValid = 0; } $priority = $maxPriorityValid + 1; // Move objects waiting in queue to the "valid ones" foreach ($movingFromQueue as $itemToMove) { $objectID = $itemToMove['object_id']; $db->query("UPDATE ezm_pool\n SET ts_visible={$time}, priority={$priority}\n WHERE block_id='{$blockID}'\n AND object_id={$objectID}"); $priority++; } $countValid += count($movingFromQueue); // Compare this number to the given and archive the oldest (order by ts_visible) $numberOfValidItems = $ini->variable($block['block_type'], 'NumberOfValidItems'); if (!$numberOfValidItems) { $numberOfValidItems = 20; eZDebug::writeWarning('Number of valid items for ' . $block['block_type'] . ' is not set; using the default value (' . $numberOfValidItems . ')', __METHOD__); } $countToRemove = $countValid - $numberOfValidItems; if ($countToRemove > 0) { $overflowID = $block['overflow_id']; $items = $db->arrayQuery("SELECT node_id, object_id, rotation_until\n FROM ezm_pool\n WHERE block_id='{$blockID}'\n AND ts_visible>0\n AND ts_hidden=0\n ORDER BY priority ASC", array('limit' => $countToRemove)); if ($items) { $itemArray = array(); $priority = 0; foreach ($items as $item) { $objectID = $item['object_id']; if ($block['rotation_type'] != self::ROTATION_NONE && ($item['rotation_until'] > $time || $item['rotation_until'] == 0)) { if ($block['rotation_type'] == self::ROTATION_SIMPLE) { // Simple rotation $newPublicationTS = -$time; $priority++; } else { // Random rotation/Shuffle $newPublicationTS = 0; $priority = mt_rand(); } // Move item back to queue $db->query("UPDATE ezm_pool\n SET ts_visible=0,\n ts_publication=-{$time},\n priority={$priority}\n WHERE block_id='{$blockID}'\n AND object_id={$objectID}"); } else { $itemArray[] = $objectID; } } if ($itemArray) { if ($overflowID) { // Put $itemArray items into pool of different block $priority = 0; foreach ($items as $item) { $itemObjectID = $item['object_id']; $itemNodeID = $item['node_id']; // Check if the object_id is not already in the new block $duplicityCheck = $db->arrayQuery("SELECT object_id\n FROM ezm_pool\n WHERE block_id='{$overflowID}'\n AND object_id={$itemObjectID}", array('limit' => 1)); if ($duplicityCheck) { eZDebug::writeNotice("Object {$itemObjectID} is already available in the block {$overflowID}.", __METHOD__); } else { $db->query("INSERT INTO ezm_pool(block_id,object_id,node_id,ts_publication,priority)\n VALUES ('{$overflowID}',{$itemObjectID},{$itemNodeID},{$time},{$priority})"); $priority++; } } $db->query("UPDATE ezm_pool\n SET ts_hidden={$time},\n moved_to='{$overflowID}',\n priority=0\n WHERE block_id='{$blockID}'\n AND " . $db->generateSQLINStatement($itemArray, 'object_id')); } else { $db->query("UPDATE ezm_pool\n SET ts_hidden={$time},\n priority=0\n WHERE block_id='{$blockID}'\n AND " . $db->generateSQLINStatement($itemArray, 'object_id')); } } } } // Cleanup in archived items $countArchived = $db->arrayQuery("SELECT count(*) AS count\n FROM ezm_pool\n WHERE block_id='{$blockID}'\n AND ts_hidden>0"); $countArchived = $countArchived[0]['count']; // Compare this number to the given and remove the oldest ones $numberOfArchivedItems = $ini->variable($block['block_type'], 'NumberOfArchivedItems'); if ($numberOfArchivedItems < 0) { $numberOfArchivedItems = 50; eZDebug::writeWarning('Number of archived items for ' . $block['block_type'] . ' is not set; using the default value (' . $numberOfArchivedItems . ')', __METHOD__); } $countToRemove = $countArchived - $numberOfArchivedItems; if ($countToRemove > 0) { $items = $db->arrayQuery("SELECT object_id\n FROM ezm_pool\n WHERE block_id='{$blockID}'\n AND ts_hidden>0\n ORDER BY ts_hidden ASC", array('limit' => $countToRemove)); if ($items) { $itemArray = array(); foreach ($items as $item) { $itemArray[] = $item['object_id']; } $db->query("DELETE FROM ezm_pool\n WHERE block_id='{$blockID}'\n AND " . $db->generateSQLINStatement($itemArray, 'object_id')); } } } // If the block changed, we need to update whole node if ($blockChanged) { $nodeChanged = true; } $db->commit(); } if ($nodeChanged) { $contentObject = eZContentObject::fetchByNodeID($nodeID); if ($contentObject) { eZContentCacheManager::clearContentCache($contentObject->attribute('id')); } } } // log the previously logged in user if it was changed to anonymous earlier if (isset($loggedInUser)) { eZUser::setCurrentlyLoggedInUser($loggedInUser, $loggedInUser->attribute('contentobject_id')); } }
/** * Adds object $contentObject to the search database. * * @param eZContentObject $contentObject Object to add to search engine * @param bool $commit Whether to commit after adding the object. If set, run optimize() as well every 1000nd time this function is run. * @return bool True if the operation succeed. */ function addObject( $contentObject, $commit = true ) { // Add all translations to the document list $docList = array(); // Check if we need to index this object after all // Exclude if class identifier is in the exclude list for classes $excludeClasses = $this->FindINI->variable( 'IndexExclude', 'ClassIdentifierList' ); if ( $excludeClasses && in_array( $contentObject->attribute( 'class_identifier' ), $excludeClasses ) ) { return true; } // Get global object values $mainNode = $contentObject->attribute( 'main_node' ); if ( !$mainNode ) { eZDebug::writeError( 'Unable to fetch main node for object: ' . $contentObject->attribute( 'id' ), __METHOD__ ); return false; } $mainNodePathArray = $mainNode->attribute( 'path_array' ); $mainNodeID = $mainNode->attribute( 'node_id' ); // initialize array of parent node path ids, needed for multivalued path field and subtree filters $nodePathArray = array(); //included in $nodePathArray //$pathArray = $mainNode->attribute( 'path_array' ); $currentVersion = $contentObject->currentVersion(); // Get object meta attributes. $metaAttributeValues = self::getMetaAttributesForObject( $contentObject ); // Get node attributes. $nodeAttributeValues = array(); foreach ( $contentObject->attribute( 'assigned_nodes' ) as $contentNode ) { $nodeID = $contentNode->attribute( 'node_id' ); foreach ( eZSolr::nodeAttributes() as $attributeName => $fieldType ) { $nodeAttributeValues[$nodeID][] = array( 'name' => $attributeName, 'value' => $contentNode->attribute( $attributeName ), 'fieldType' => $fieldType ); } $nodePathArray[] = $contentNode->attribute( 'path_array' ); } // Check anonymous user access. if ( $this->FindINI->variable( 'SiteSettings', 'IndexPubliclyAvailable' ) == 'enabled' ) { $anonymousUserID = $this->SiteINI->variable( 'UserSettings', 'AnonymousUserID' ); $currentUserID = eZUser::currentUserID(); $user = eZUser::instance( $anonymousUserID ); eZUser::setCurrentlyLoggedInUser( $user, $anonymousUserID ); $anonymousAccess = $contentObject->attribute( 'can_read' ); $user = eZUser::instance( $currentUserID ); eZUser::setCurrentlyLoggedInUser( $user, $currentUserID ); $anonymousAccess = $anonymousAccess ? 'true' : 'false'; } else { $anonymousAccess = 'false'; } // Load index time boost factors if any //$boostMetaFields = $this->FindINI->variable( "IndexBoost", "MetaField" ); $boostClasses = $this->FindINI->variable( 'IndexBoost', 'Class' ); $boostAttributes = $this->FindINI->variable( 'IndexBoost', 'Attribute' ); $boostDatatypes = $this->FindINI->variable( 'IndexBoost', 'Datatype' ); $reverseRelatedScale = $this->FindINI->variable( 'IndexBoost', 'ReverseRelatedScale' ); // Initialise default doc boost $docBoost = 1.0; $contentClassIdentifier = $contentObject->attribute( 'class_identifier' ); // Just test if the boost factor is defined by checking if it has a numeric value if ( isset( $boostClasses[$contentClassIdentifier] ) && is_numeric( $boostClasses[$contentClassIdentifier] ) ) { $docBoost += $boostClasses[$contentClassIdentifier]; } // Google like boosting, using eZ Publish reverseRelatedObjectCount $reverseRelatedObjectCount = $contentObject->reverseRelatedObjectCount(); $docBoost += $reverseRelatedScale * $reverseRelatedObjectCount; // Create the list of available languages for this version : $availableLanguages = $currentVersion->translationList( false, false ); // Loop over each language version and create an eZSolrDoc for it foreach ( $availableLanguages as $languageCode ) { $doc = new eZSolrDoc( $docBoost ); // Set global unique object ID $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'guid' ), $this->guid( $contentObject, $languageCode ) ); // Set installation identifier $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'installation_id' ), self::installationID() ); $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'installation_url' ), $this->FindINI->variable( 'SiteSettings', 'URLProtocol' ) . $this->SiteINI->variable( 'SiteSettings', 'SiteURL' ) . '/' ); // Set Object attributes $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'name' ), $contentObject->name( false, $languageCode ) ); // Also add value to the "sort_name" field as "name" is unsortable, due to Solr limitation (tokenized field) $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'sort_name' ), $contentObject->name( false, $languageCode ) ); $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'anon_access' ), $anonymousAccess ); $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'language_code' ), $languageCode ); $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'available_language_codes' ), $availableLanguages ); if ( $owner = $contentObject->attribute( 'owner' ) ) { // Set owner name $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'owner_name' ), $owner->name( false, $languageCode ) ); // Set owner group ID foreach ( $owner->attribute( 'parent_nodes' ) as $groupID ) { $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'owner_group_id' ), $groupID ); } } // from eZ Publish 4.1 only: object states // so let's check if the content object has it if ( method_exists( $contentObject, 'stateIDArray' ) ) { $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'object_states' ), $contentObject->stateIDArray() ); } // Set content object meta attribute values. foreach ( $metaAttributeValues as $metaInfo ) { $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( $metaInfo['name'] ), ezfSolrDocumentFieldBase::preProcessValue( $metaInfo['value'], $metaInfo['fieldType'] ) ); } // Set content node meta attribute values. foreach ( $nodeAttributeValues as $nodeID => $metaInfoArray ) { foreach( $metaInfoArray as $metaInfo) { $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( $metaInfo['name'] ), ezfSolrDocumentFieldBase::preProcessValue( $metaInfo['value'], $metaInfo['fieldType'] ) ); } } // Main node gets single valued fields for sorting, using a dedicated prefix foreach ( $nodeAttributeValues[$mainNodeID] as $metaInfo ) { $fieldName = 'main_node_' . ezfSolrDocumentFieldBase::generateMetaFieldName( $metaInfo['name'] ); $doc->addField( $fieldName, ezfSolrDocumentFieldBase::preProcessValue( $metaInfo['value'], $metaInfo['fieldType'] ) ); } // Add main url_alias $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'main_url_alias' ), $mainNode->attribute( 'url_alias' ) ); // Add main path_string $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'main_path_string' ), $mainNode->attribute( 'path_string' ) ); // add nodeid of all parent nodes path elements foreach ( $nodePathArray as $pathArray ) { foreach ( $pathArray as $pathNodeID) { $doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'path' ), $pathNodeID ); } } // Since eZ Fnd 2.3 // cannot call metafield field bame constructor as we are creating multiple fields foreach ( $mainNodePathArray as $key => $pathNodeID ) { $doc->addField( 'meta_main_path_element_' . $key . '_si', $pathNodeID ); } eZContentObject::recursionProtectionStart(); // Loop through all eZContentObjectAttributes and add them to the Solr document. // @since eZ Find 2.3: look for the attribute storage setting $doAttributeStorage = ( ( $this->FindINI->variable( 'IndexOptions', 'EnableSolrAttributeStorage' ) ) === 'true' ) ? true : false; if ( $doAttributeStorage ) { $allAttributeData = array(); } foreach ( $currentVersion->contentObjectAttributes( $languageCode ) as $attribute ) { $metaDataText = ''; $classAttribute = $attribute->contentClassAttribute(); $attributeIdentifier = $classAttribute->attribute( 'identifier' ); $combinedIdentifier = $contentClassIdentifier . '/' . $attributeIdentifier; $boostAttribute = false; if ( isset( $boostAttributes[$attributeIdentifier]) && is_numeric( $boostAttributes[$attributeIdentifier])) { $boostAttribute = $boostAttributes[$attributeIdentifier]; } if ( isset( $boostAttributes[$combinedIdentifier]) && is_numeric( $boostAttributes[$combinedIdentifier])) { $boostAttribute += $boostAttributes[$combinedIdentifier]; } if ( $classAttribute->attribute( 'is_searchable' ) == 1 ) { $documentFieldBase = ezfSolrDocumentFieldBase::getInstance( $attribute ); $this->addFieldBaseToDoc( $documentFieldBase, $doc, $boostAttribute ); } if ( $doAttributeStorage ) { $storageFieldName = ezfSolrStorage::getSolrStorageFieldName( $attributeIdentifier ); $attributeData = ezfSolrStorage::getAttributeData( $attribute ); $allAttributeData['data_map'][$attributeIdentifier] = $attributeData; $doc->addField( $storageFieldName, ezfSolrStorage::serializeData( $attributeData ) ); } } eZContentObject::recursionProtectionEnd(); if ( $doAttributeStorage ) { $doc->addField( 'as_all_bst', ezfSolrStorage::serializeData( $allAttributeData ) ); } $docList[$languageCode] = $doc; } // Since eZFind 2.7: indexhooks $generalPlugins = $this->FindINI->variable( 'IndexPlugins', 'General' ); $classPlugins = $this->FindINI->variable( 'IndexPlugins', 'Class' ); if ( !empty( $generalPlugins ) ) { foreach ( $generalPlugins as $pluginClassString ) { if( !class_exists( $pluginClassString ) ) { eZDebug::writeError( "Unable to find the PHP class '$classname' defined for index time plugins for eZ Find", __METHOD__ ); continue; } $plugin = new $pluginClassString; if ( $plugin instanceof ezfIndexPlugin ) { $plugin->modify( $contentObject, $docList ); } } } if (array_key_exists($contentObject->attribute( 'class_identifier' ), $classPlugins ) ) { $pluginClassString = $classPlugins[$contentObject->attribute( 'class_identifier' )]; if ( class_exists( $pluginClassString ) ) { $plugin = new $pluginClassString; if ($plugin instanceof ezfIndexPlugin) { $plugin->modify( $contentObject, $docList ); } } } $optimize = false; if ( $this->FindINI->variable( 'IndexOptions', 'DisableDirectCommits' ) === 'true' ) { $commit = false; } $commitWithin = 0; if ( $this->FindINI->variable( 'IndexOptions', 'CommitWithin' ) > 0 ) { $commitWithin = $this->FindINI->variable( 'IndexOptions', 'CommitWithin' ); } if ( $commit && ( $this->FindINI->variable( 'IndexOptions', 'OptimizeOnCommit' ) === 'enabled' ) ) { $optimize = true; } if ( $this->UseMultiLanguageCores === true) { $result = true; foreach ( $availableLanguages as $languageCode ) { $languageResult = $this->SolrLanguageShards[$languageCode]->addDocs( array( $docList[$languageCode] ), $commit, $optimize, $commitWithin ); if ( !$languageResult ) { $result = false; } } return $result; } else { return $this->Solr->addDocs( $docList, $commit, $optimize, $commitWithin ); } }
static function loginUser($login, $password, $authenticationMatch = false) { $http = eZHTTPTool::instance(); $db = eZDB::instance(); if ($authenticationMatch === false) { $authenticationMatch = eZUser::authenticationMatch(); } $loginEscaped = $db->escapeString($login); $passwordEscaped = $db->escapeString($password); $loginArray = array(); if ($authenticationMatch & eZUser::AUTHENTICATE_LOGIN) { $loginArray[] = "login='******'"; } if ($authenticationMatch & eZUser::AUTHENTICATE_EMAIL) { $loginArray[] = "email='{$loginEscaped}'"; } if (count($loginArray) == 0) { $loginArray[] = "login='******'"; } $loginText = implode(' OR ', $loginArray); $contentObjectStatus = eZContentObject::STATUS_PUBLISHED; $ini = eZINI::instance(); $textFileIni = eZINI::instance('textfile.ini'); $databaseName = $db->databaseName(); // if mysql if ($databaseName === 'mysql') { $query = "SELECT contentobject_id, password_hash, password_hash_type, email, login\n FROM ezuser, ezcontentobject\n WHERE ( {$loginText} ) AND\n ezcontentobject.status='{$contentObjectStatus}' AND\n ( ezcontentobject.id=contentobject_id OR ( password_hash_type=4 AND ( {$loginText} ) AND password_hash=PASSWORD('{$passwordEscaped}') ) )"; } else { $query = "SELECT contentobject_id, password_hash, password_hash_type, email, login\n FROM ezuser, ezcontentobject\n WHERE ( {$loginText} ) AND\n ezcontentobject.status='{$contentObjectStatus}' AND\n ezcontentobject.id=contentobject_id"; } $users = $db->arrayQuery($query); $exists = false; if (count($users) >= 1) { foreach ($users as $userRow) { $userID = $userRow['contentobject_id']; $hashType = $userRow['password_hash_type']; $hash = $userRow['password_hash']; $exists = eZUser::authenticateHash($userRow['login'], $password, eZUser::site(), $hashType, $hash); // If hash type is MySql if ($hashType == eZUser::PASSWORD_HASH_MYSQL and $databaseName === 'mysql') { $queryMysqlUser = "******"; $mysqlUsers = $db->arrayQuery($queryMysqlUser); if (count($mysqlUsers) >= 1) { $exists = true; } } eZDebugSetting::writeDebug('kernel-user', eZUser::createHash($userRow['login'], $password, eZUser::site(), $hashType), "check hash"); eZDebugSetting::writeDebug('kernel-user', $hash, "stored hash"); // If current user has been disabled after a few failed login attempts. $canLogin = eZUser::isEnabledAfterFailedLogin($userID); if ($exists) { // We should store userID for warning message. $GLOBALS['eZFailedLoginAttemptUserID'] = $userID; $userSetting = eZUserSetting::fetch($userID); $isEnabled = $userSetting->attribute("is_enabled"); if ($hashType != eZUser::hashType() and strtolower($ini->variable('UserSettings', 'UpdateHash')) == 'true') { $hashType = eZUser::hashType(); $hash = eZUser::createHash($login, $password, eZUser::site(), $hashType); $db->query("UPDATE ezuser SET password_hash='{$hash}', password_hash_type='{$hashType}' WHERE contentobject_id='{$userID}'"); } break; } } } if ($exists and $isEnabled and $canLogin) { eZDebugSetting::writeDebug('kernel-user', $userRow, 'user row'); $user = new eZUser($userRow); eZDebugSetting::writeDebug('kernel-user', $user, 'user'); $userID = $user->attribute('contentobject_id'); eZUser::updateLastVisit($userID); eZUser::setCurrentlyLoggedInUser($user, $userID); // Reset number of failed login attempts eZUser::setFailedLoginAttempts($userID, 0); return $user; } else { if ($textFileIni->variable('TextFileSettings', 'TextFileEnabled') == "true") { $fileName = $textFileIni->variable('TextFileSettings', 'FileName'); $filePath = $textFileIni->variable('TextFileSettings', 'FilePath'); $defaultUserPlacement = $ini->variable("UserSettings", "DefaultUserPlacement"); $separator = $textFileIni->variable("TextFileSettings", "FileFieldSeparator"); $loginColumnNr = $textFileIni->variable("TextFileSettings", "LoginAttribute"); $passwordColumnNr = $textFileIni->variable("TextFileSettings", "PasswordAttribute"); $emailColumnNr = $textFileIni->variable("TextFileSettings", "EmailAttribute"); $lastNameColumnNr = $textFileIni->variable("TextFileSettings", "LastNameAttribute"); $firstNameColumnNr = $textFileIni->variable("TextFileSettings", "FirstNameAttribute"); if ($textFileIni->hasVariable('TextFileSettings', 'DefaultUserGroupType')) { $UserGroupType = $textFileIni->variable('TextFileSettings', 'DefaultUserGroupType'); $UserGroup = $textFileIni->variable('TextFileSettings', 'DefaultUserGroup'); } if ($UserGroupType != null) { if ($UserGroupType == "name") { $groupName = $UserGroup; $groupQuery = "SELECT ezcontentobject_tree.node_id\n FROM ezcontentobject, ezcontentobject_tree\n WHERE ezcontentobject.name='{$groupName}'\n AND ezcontentobject.id=ezcontentobject_tree.contentobject_id"; $groupObject = $db->arrayQuery($groupQuery); if (count($groupObject) > 0) { $defaultUserPlacement = $groupObject[0]['node_id']; } } else { if ($UserGroupType == "id") { $groupID = $UserGroup; $groupQuery = "SELECT ezcontentobject_tree.node_id\n FROM ezcontentobject, ezcontentobject_tree\n WHERE ezcontentobject.id='{$groupID}'\n AND ezcontentobject.id=ezcontentobject_tree.contentobject_id"; $groupObject = $db->arrayQuery($groupQuery); if (count($groupObject) > 0) { $defaultUserPlacement = $groupObject[0]['node_id']; } } } } if ($filePath != "root" and $filePath != null) { $fileName = $filePath . "/" . $fileName; } if (file_exists($fileName)) { $handle = fopen($fileName, "r"); } else { // Increase number of failed login attempts. if (isset($userID)) { eZUser::setFailedLoginAttempts($userID); } return false; } while (!feof($handle)) { $line = trim(fgets($handle, 4096)); if ($line === '') { continue; } if ($separator == "tab") { $userArray = explode("\t", $line); } else { $userArray = explode($separator, $line); } $uid = $userArray[$loginColumnNr - 1]; $email = $userArray[$emailColumnNr - 1]; $pass = $userArray[$passwordColumnNr - 1]; $firstName = $userArray[$firstNameColumnNr - 1]; $lastName = $userArray[$lastNameColumnNr - 1]; if ($login == $uid) { if (trim($pass) == $password) { $createNewUser = true; $existUser = eZUser::fetchByName($login); if ($existUser != null) { $createNewUser = false; } if ($createNewUser) { $userClassID = $ini->variable("UserSettings", "UserClassID"); $userCreatorID = $ini->variable("UserSettings", "UserCreatorID"); $defaultSectionID = $ini->variable("UserSettings", "DefaultSectionID"); $remoteID = "TextFile_" . $login; $db->begin(); // The content object may already exist if this process has failed once before, before the eZUser object was created. // Therefore we try to fetch the eZContentObject before instantiating it. $contentObject = eZContentObject::fetchByRemoteID($remoteID); if (!is_object($contentObject)) { $class = eZContentClass::fetch($userClassID); $contentObject = $class->instantiate($userCreatorID, $defaultSectionID); } $contentObject->setAttribute('remote_id', $remoteID); $contentObject->store(); $contentObjectID = $contentObject->attribute('id'); $userID = $contentObjectID; $nodeAssignment = eZNodeAssignment::create(array('contentobject_id' => $contentObjectID, 'contentobject_version' => 1, 'parent_node' => $defaultUserPlacement, 'is_main' => 1)); $nodeAssignment->store(); $version = $contentObject->version(1); $version->setAttribute('modified', time()); $version->setAttribute('status', eZContentObjectVersion::STATUS_DRAFT); $version->store(); $contentObjectID = $contentObject->attribute('id'); $contentObjectAttributes = $version->contentObjectAttributes(); $contentObjectAttributes[0]->setAttribute('data_text', $firstName); $contentObjectAttributes[0]->store(); $contentObjectAttributes[1]->setAttribute('data_text', $lastName); $contentObjectAttributes[1]->store(); $user = eZUser::create($userID); $user->setAttribute('login', $login); $user->setAttribute('email', $email); $user->setAttribute('password_hash', ""); $user->setAttribute('password_hash_type', 0); $user->store(); eZUser::updateLastVisit($userID); eZUser::setCurrentlyLoggedInUser($user, $userID); // Reset number of failed login attempts eZUser::setFailedLoginAttempts($userID, 0); $operationResult = eZOperationHandler::execute('content', 'publish', array('object_id' => $contentObjectID, 'version' => 1)); $db->commit(); return $user; } else { $db->begin(); // Update user information $userID = $existUser->attribute('contentobject_id'); $contentObject = eZContentObject::fetch($userID); $parentNodeID = $contentObject->attribute('main_parent_node_id'); $currentVersion = $contentObject->attribute('current_version'); $version = $contentObject->attribute('current'); $contentObjectAttributes = $version->contentObjectAttributes(); $contentObjectAttributes[0]->setAttribute('data_text', $firstName); $contentObjectAttributes[0]->store(); $contentObjectAttributes[1]->setAttribute('data_text', $lastName); $contentObjectAttributes[1]->store(); $existUser = eZUser::fetch($userID); $existUser->setAttribute('email', $email); $existUser->setAttribute('password_hash', ""); $existUser->setAttribute('password_hash_type', 0); $existUser->store(); if ($defaultUserPlacement != $parentNodeID) { $newVersion = $contentObject->createNewVersion(); $newVersion->assignToNode($defaultUserPlacement, 1); $newVersion->removeAssignment($parentNodeID); $newVersionNr = $newVersion->attribute('version'); $operationResult = eZOperationHandler::execute('content', 'publish', array('object_id' => $userID, 'version' => $newVersionNr)); } eZUser::updateLastVisit($userID); eZUser::setCurrentlyLoggedInUser($existUser, $userID); // Reset number of failed login attempts eZUser::setFailedLoginAttempts($userID, 0); $db->commit(); return $existUser; } } else { // Increase number of failed login attempts. if (isset($userID)) { eZUser::setFailedLoginAttempts($userID); } return false; } } } fclose($handle); } } // Increase number of failed login attempts. if (isset($userID)) { eZUser::setFailedLoginAttempts($userID); } return false; }
/** * Returns a shared instance of the eZUser class pr $id value. * If user can not be fetched, then anonymous user is returned and * a warning trown, if anonymous user can not be fetched, then NoUser * is returned and another warning is thrown. * * @param int|false $id On false: Gets current user id from session * or from {@link eZUser::anonymousId()} if not set. * @return eZUser */ static function instance($id = false) { if (!empty($GLOBALS["eZUserGlobalInstance_{$id}"])) { return $GLOBALS["eZUserGlobalInstance_{$id}"]; } $userId = $id; $currentUser = null; $http = eZHTTPTool::instance(); $anonymousUserID = self::anonymousId(); $sessionHasStarted = eZSession::hasStarted(); // If not specified get the current user if ($userId === false) { if ($sessionHasStarted) { $userId = $http->sessionVariable('eZUserLoggedInID'); if (!is_numeric($userId)) { $userId = $anonymousUserID; eZSession::setUserID($userId); $http->setSessionVariable('eZUserLoggedInID', $userId); } } else { $userId = $anonymousUserID; eZSession::setUserID($userId); } } // Check user cache (this effectivly fetches user from cache) // user not found if !isset( isset( $userCache['info'][$userId] ) ) $userCache = self::getUserCacheByUserId($userId); if (isset($userCache['info'][$userId])) { $userArray = $userCache['info'][$userId]; if (is_numeric($userArray['contentobject_id'])) { $currentUser = new eZUser($userArray); $currentUser->setUserCache($userCache); } } $ini = eZINI::instance(); // Check if: // - the user has not logged out, // - the user is not logged in, // - and if a automatic single sign on plugin is enabled. if (!self::$userHasLoggedOut && is_object($currentUser) && !$currentUser->isRegistered()) { $ssoHandlerArray = $ini->variable('UserSettings', 'SingleSignOnHandlerArray'); if (!empty($ssoHandlerArray)) { $ssoUser = false; foreach ($ssoHandlerArray as $ssoHandler) { $className = 'eZ' . $ssoHandler . 'SSOHandler'; if (class_exists($className)) { $impl = new $className(); $ssoUser = $impl->handleSSOLogin(); // If a user was found via SSO, then use it if ($ssoUser !== false) { $currentUser = $ssoUser; $userId = $currentUser->attribute('contentobject_id'); $userInfo = array(); $userInfo[$userId] = array('contentobject_id' => $userId, 'login' => $currentUser->attribute('login'), 'email' => $currentUser->attribute('email'), 'password_hash' => $currentUser->attribute('password_hash'), 'password_hash_type' => $currentUser->attribute('password_hash_type')); eZSession::setUserID($userId); $http->setSessionVariable('eZUserLoggedInID', $userId); eZUser::updateLastVisit($userId); eZUser::setCurrentlyLoggedInUser($currentUser, $userId); eZHTTPTool::redirect(eZSys::wwwDir() . eZSys::indexFile(false) . eZSys::requestURI() . eZSys::queryString(), array(), 302); eZExecution::cleanExit(); } } else { eZDebug::writeError("Undefined ssoHandler class: {$className}", __METHOD__); } } } } if ($userId != $anonymousUserID) { $sessionInactivityTimeout = $ini->variable('Session', 'ActivityTimeout'); if (!isset($GLOBALS['eZSessionIdleTime'])) { eZUser::updateLastVisit($userId); } else { $sessionIdle = $GLOBALS['eZSessionIdleTime']; if ($sessionIdle > $sessionInactivityTimeout) { eZUser::updateLastVisit($userId); } } } if (!$currentUser) { $currentUser = eZUser::fetch(self::anonymousId()); eZDebug::writeWarning('User not found, returning anonymous'); } if (!$currentUser) { $currentUser = new eZUser(array('id' => -1, 'login' => 'NoUser')); eZDebug::writeWarning('Anonymous user not found, returning NoUser'); } $GLOBALS["eZUserGlobalInstance_{$id}"] = $currentUser; return $currentUser; }
$deleteIDArray = $srcNodesID ? explode(',', $srcNodesID) : false; if (!$deleteIDArray) { $cli->error("Subtree remove Error!\nCannot get subtree nodes. Please check nodes-id argument and try again."); $script->showHelp(); $script->shutdown(1); } $ini = eZINI::instance(); // Get user's ID who can remove subtrees. (Admin by default with userID = 14) $userCreatorID = $ini->variable("UserSettings", "UserCreatorID"); /** @var eZUser $user */ $user = eZUser::fetch($userCreatorID); if (!$user) { $cli->error("Subtree remove Error!\nCannot get user object by userID = '{$userCreatorID}'.\n(See site.ini[UserSettings].UserCreatorID)"); $script->shutdown(1); } eZUser::setCurrentlyLoggedInUser($user, $userCreatorID); $cli->notice("Logged as " . $user->Login . " userID = '{$userCreatorID}' (See site.ini[UserSettings].UserCreatorID)"); $params = array('Depth' => 1, 'Limit' => $size, 'Offset' => 0); if ($classes) { $params['ClassFilterType'] = 'include'; $params['ClassFilterArray'] = explode(',', $classes); $cli->notice("Classes filters : " . implode(', ', $params['ClassFilterArray'])); } //$cli->output(var_export($params, true)); if ($disable_indexing) { eZINI::instance()->setVariable('ContentSettings', 'ViewCaching', 'disabled'); eZINI::instance()->setVariable('ContentSettings', 'StaticCache', 'disabled'); eZINI::instance()->setVariable('ContentSettings', 'PreViewCache', 'disabled'); eZINI::instance()->setVariable('SearchSettings', 'DelayedIndexing', 'enabled'); eZINI::instance('ezfind.ini')->setVariable('IndexOptions', 'OptimizeOnCommit', 'disabled'); $cli->notice("indexing disabled. Don't forget to reindex content.");
$newPasswordNotValidate = 1; } else { $oldHash = $user->createHash($login, $oldPassword, $site, $type); $newHash = $user->createHash($login, $newPassword, $site, $type); if ($oldHash == $newHash) { // if audit is enabled password changes should be logged eZAudit::writeAudit('user-password-change-self-fail', array('UserID: ' => $UserID, 'Login: '******'Comment: ' => 'New and old password are the same')); $newPasswordMustDiffer = 1; } else { // if audit is enabled password changes should be logged eZAudit::writeAudit('user-password-change-self', array('UserID: ' => $UserID, 'Login: '******''; eZUser::setCurrentlyLoggedInUser($user, $UserID); if ($http->hasPostVariable("RedirectOnChange")) { return $Module->redirectTo($http->postVariable("RedirectOnChange")); } eZRedirectManager::redirectTo($Module, $redirectionURI); return; } } } $newPassword = ''; $confirmPassword = ''; $message = true; } else { // if audit is enabled password changes should be logged eZAudit::writeAudit('user-password-change-self-fail', array('UserID: ' => $UserID, 'Login: '******'Comment: ' => 'Password not match password confirmation')); $newPassword = "";
/** * Executes the purge operation * * @param int|null $iterationLimit Number of trashed objects to treat per iteration, use null to use a default value. * @param int|null $sleep Number of seconds to sleep between two iterations, use null to use a default value. * * @return bool True if the operation succeeded. */ public function run($iterationLimit = 100, $sleep = 1) { if ($iterationLimit === null) { $iterationLimit = 100; } if ($sleep === null) { $sleep = 1; } if ($this->memoryMonitoring) { eZLog::rotateLog($this->logFile); $this->cli->output("Logging memory usage to {$this->logFile}"); } $this->cli->output("Purging trash items:"); $this->monitor("start"); $db = eZDB::instance(); // Get user's ID who can remove subtrees. (Admin by default with userID = 14) $userCreatorID = eZINI::instance()->variable("UserSettings", "UserCreatorID"); $user = eZUser::fetch($userCreatorID); if (!$user) { $this->cli->error("Cannot get user object with userID = '{$userCreatorID}'.\n(See site.ini[UserSettings].UserCreatorID)"); return false; } eZUser::setCurrentlyLoggedInUser($user, $userCreatorID); $trashCount = eZContentObjectTrashNode::trashListCount(false); if (!$this->quiet) { $this->cli->output("Found {$trashCount} object(s) in trash."); } if ($trashCount == 0) { return true; } if ($this->script !== null) { $this->script->resetIteration($trashCount); } while ($trashCount > 0) { $this->monitor("iteration start"); $trashList = eZContentObjectTrashNode::trashList(array('Limit' => $iterationLimit), false); $db->begin(); foreach ($trashList as $trashNode) { $object = $trashNode->attribute('object'); $this->monitor("purge"); $object->purge(); if ($this->script !== null) { $this->script->iterate($this->cli, true); } } if (!$db->commit()) { $this->cli->output(); $this->cli->error('Trash has not been emptied, impossible to commit the whole transaction'); return false; } $trashCount = eZContentObjectTrashNode::trashListCount(false); if ($trashCount > 0) { eZContentObject::clearCache(); if ($sleep > 0) { sleep($sleep); } } $this->monitor("iteration end"); } if (!$this->quiet) { $this->cli->output('Trash successfully emptied'); } $this->monitor("end"); return true; }
static function loginUser($login, $password, $authenticationMatch = false) { $http = eZHTTPTool::instance(); $db = eZDB::instance(); if ($authenticationMatch === false) { $authenticationMatch = eZUser::authenticationMatch(); } $loginEscaped = $db->escapeString($login); $passwordEscaped = $db->escapeString($password); $loginLdapEscaped = self::ldap_escape($login); $loginArray = array(); if ($authenticationMatch & eZUser::AUTHENTICATE_LOGIN) { $loginArray[] = "login='******'"; } if ($authenticationMatch & eZUser::AUTHENTICATE_EMAIL) { $loginArray[] = "email='{$loginEscaped}'"; } if (count($loginArray) == 0) { $loginArray[] = "login='******'"; } $loginText = implode(' OR ', $loginArray); $contentObjectStatus = eZContentObject::STATUS_PUBLISHED; $ini = eZINI::instance(); $LDAPIni = eZINI::instance('ldap.ini'); $databaseName = $db->databaseName(); // if mysql if ($databaseName === 'mysql') { $query = "SELECT contentobject_id, password_hash, password_hash_type, email, login\n FROM ezuser, ezcontentobject\n WHERE ( {$loginText} ) AND\n ezcontentobject.status='{$contentObjectStatus}' AND\n ( ezcontentobject.id=contentobject_id OR ( password_hash_type=4 AND ( {$loginText} ) AND password_hash=PASSWORD('{$passwordEscaped}') ) )"; } else { $query = "SELECT contentobject_id, password_hash, password_hash_type, email, login\n FROM ezuser, ezcontentobject\n WHERE ( {$loginText} ) AND\n ezcontentobject.status='{$contentObjectStatus}' AND\n ezcontentobject.id=contentobject_id"; } $users = $db->arrayQuery($query); $exists = false; if (count($users) >= 1) { foreach ($users as $userRow) { $userID = $userRow['contentobject_id']; $hashType = $userRow['password_hash_type']; $hash = $userRow['password_hash']; $exists = eZUser::authenticateHash($userRow['login'], $password, eZUser::site(), $hashType, $hash); // If hash type is MySql if ($hashType == eZUser::PASSWORD_HASH_MYSQL and $databaseName === 'mysql') { $queryMysqlUser = "******"; $mysqlUsers = $db->arrayQuery($queryMysqlUser); if (count($mysqlUsers) >= 1) { $exists = true; } } eZDebugSetting::writeDebug('kernel-user', eZUser::createHash($userRow['login'], $password, eZUser::site(), $hashType), "check hash"); eZDebugSetting::writeDebug('kernel-user', $hash, "stored hash"); // If current user has been disabled after a few failed login attempts. $canLogin = eZUser::isEnabledAfterFailedLogin($userID); if ($exists) { // We should store userID for warning message. $GLOBALS['eZFailedLoginAttemptUserID'] = $userID; $userSetting = eZUserSetting::fetch($userID); $isEnabled = $userSetting->attribute("is_enabled"); if ($hashType != eZUser::hashType() and strtolower($ini->variable('UserSettings', 'UpdateHash')) == 'true') { $hashType = eZUser::hashType(); $hash = eZUser::createHash($login, $password, eZUser::site(), $hashType); $db->query("UPDATE ezuser SET password_hash='{$hash}', password_hash_type='{$hashType}' WHERE contentobject_id='{$userID}'"); } break; } } } if ($exists and $isEnabled and $canLogin) { eZDebugSetting::writeDebug('kernel-user', $userRow, 'user row'); $user = new eZUser($userRow); eZDebugSetting::writeDebug('kernel-user', $user, 'user'); $userID = $user->attribute('contentobject_id'); eZUser::updateLastVisit($userID); eZUser::setCurrentlyLoggedInUser($user, $userID); // Reset number of failed login attempts eZUser::setFailedLoginAttempts($userID, 0); return $user; } else { if ($LDAPIni->variable('LDAPSettings', 'LDAPEnabled') === 'true') { // read LDAP ini settings // and then try to bind to the ldap server $LDAPDebugTrace = $LDAPIni->variable('LDAPSettings', 'LDAPDebugTrace') === 'enabled'; $LDAPVersion = $LDAPIni->variable('LDAPSettings', 'LDAPVersion'); $LDAPServer = $LDAPIni->variable('LDAPSettings', 'LDAPServer'); $LDAPPort = $LDAPIni->variable('LDAPSettings', 'LDAPPort'); $LDAPFollowReferrals = (int) $LDAPIni->variable('LDAPSettings', 'LDAPFollowReferrals'); $LDAPBaseDN = $LDAPIni->variable('LDAPSettings', 'LDAPBaseDn'); $LDAPBindUser = $LDAPIni->variable('LDAPSettings', 'LDAPBindUser'); $LDAPBindPassword = $LDAPIni->variable('LDAPSettings', 'LDAPBindPassword'); $LDAPSearchScope = $LDAPIni->variable('LDAPSettings', 'LDAPSearchScope'); $LDAPLoginAttribute = strtolower($LDAPIni->variable('LDAPSettings', 'LDAPLoginAttribute')); $LDAPFirstNameAttribute = strtolower($LDAPIni->variable('LDAPSettings', 'LDAPFirstNameAttribute')); $LDAPFirstNameIsCN = $LDAPIni->variable('LDAPSettings', 'LDAPFirstNameIsCommonName') === 'true'; $LDAPLastNameAttribute = strtolower($LDAPIni->variable('LDAPSettings', 'LDAPLastNameAttribute')); $LDAPEmailAttribute = strtolower($LDAPIni->variable('LDAPSettings', 'LDAPEmailAttribute')); $defaultUserPlacement = $ini->variable("UserSettings", "DefaultUserPlacement"); $LDAPUserGroupAttributeType = strtolower($LDAPIni->variable('LDAPSettings', 'LDAPUserGroupAttributeType')); $LDAPUserGroupAttribute = strtolower($LDAPIni->variable('LDAPSettings', 'LDAPUserGroupAttribute')); if ($LDAPIni->hasVariable('LDAPSettings', 'Utf8Encoding')) { $Utf8Encoding = $LDAPIni->variable('LDAPSettings', 'Utf8Encoding'); if ($Utf8Encoding == "true") { $isUtf8Encoding = true; } else { $isUtf8Encoding = false; } } else { $isUtf8Encoding = false; } if ($LDAPIni->hasVariable('LDAPSettings', 'LDAPSearchFilters')) { $LDAPFilters = $LDAPIni->variable('LDAPSettings', 'LDAPSearchFilters'); } if ($LDAPIni->hasVariable('LDAPSettings', 'LDAPUserGroupType') and $LDAPIni->hasVariable('LDAPSettings', 'LDAPUserGroup')) { $LDAPUserGroupType = $LDAPIni->variable('LDAPSettings', 'LDAPUserGroupType'); $LDAPUserGroup = $LDAPIni->variable('LDAPSettings', 'LDAPUserGroup'); } $LDAPFilter = "( &"; if (count($LDAPFilters) > 0) { foreach (array_keys($LDAPFilters) as $key) { $LDAPFilter .= "(" . $LDAPFilters[$key] . ")"; } } $LDAPEqualSign = trim($LDAPIni->variable('LDAPSettings', "LDAPEqualSign")); $LDAPBaseDN = str_replace($LDAPEqualSign, "=", $LDAPBaseDN); $LDAPFilter = str_replace($LDAPEqualSign, "=", $LDAPFilter); $LDAPBindUser = str_replace($LDAPEqualSign, "=", $LDAPBindUser); if ($LDAPDebugTrace) { $debugArray = array('stage' => '1/5: Connecting and Binding to LDAP server', 'LDAPServer' => $LDAPServer, 'LDAPPort' => $LDAPPort, 'LDAPBindUser' => $LDAPBindUser, 'LDAPVersion' => $LDAPVersion); // Set debug trace mode for ldap connections if (function_exists('ldap_set_option')) { ldap_set_option(NULL, LDAP_OPT_DEBUG_LEVEL, 7); } eZDebug::writeNotice(var_export($debugArray, true), __METHOD__); } if (function_exists('ldap_connect')) { $ds = ldap_connect($LDAPServer, $LDAPPort); } else { $ds = false; } if ($ds) { ldap_set_option($ds, LDAP_OPT_PROTOCOL_VERSION, $LDAPVersion); ldap_set_option($ds, LDAP_OPT_REFERRALS, $LDAPFollowReferrals); if ($LDAPBindUser == '') { $r = ldap_bind($ds); } else { $r = ldap_bind($ds, $LDAPBindUser, $LDAPBindPassword); } if (!$r) { // Increase number of failed login attempts. eZDebug::writeError('Cannot bind to LDAP server, might be something wronge with connetion or bind user!', __METHOD__); if (isset($userID)) { eZUser::setFailedLoginAttempts($userID); } $user = false; return $user; } $LDAPFilter .= "({$LDAPLoginAttribute}={$loginLdapEscaped})"; $LDAPFilter .= ")"; ldap_set_option($ds, LDAP_OPT_SIZELIMIT, 0); ldap_set_option($ds, LDAP_OPT_TIMELIMIT, 0); $retrieveAttributes = array($LDAPLoginAttribute, $LDAPFirstNameAttribute, $LDAPLastNameAttribute, $LDAPEmailAttribute); if ($LDAPUserGroupAttributeType) { $retrieveAttributes[] = $LDAPUserGroupAttribute; } if ($LDAPDebugTrace) { $debugArray = array('stage' => '2/5: finding user', 'LDAPFilter' => $LDAPFilter, 'retrieveAttributes' => $retrieveAttributes, 'LDAPSearchScope' => $LDAPSearchScope, 'LDAPBaseDN' => $LDAPBaseDN); eZDebug::writeNotice(var_export($debugArray, true), __METHOD__); } if ($LDAPSearchScope == "one") { $sr = ldap_list($ds, $LDAPBaseDN, $LDAPFilter, $retrieveAttributes); } else { if ($LDAPSearchScope == "base") { $sr = ldap_read($ds, $LDAPBaseDN, $LDAPFilter, $retrieveAttributes); } else { $sr = ldap_search($ds, $LDAPBaseDN, $LDAPFilter, $retrieveAttributes); } } $info = ldap_get_entries($ds, $sr); if ($info['count'] > 1) { // More than one user with same uid, not allow login. eZDebug::writeWarning('More then one user with same uid, not allowed to login!', __METHOD__); $user = false; return $user; } else { if ($info['count'] < 1) { // Increase number of failed login attempts. if (isset($userID)) { eZUser::setFailedLoginAttempts($userID); } // user DN was not found eZDebug::writeWarning('User DN was not found!', __METHOD__); $user = false; return $user; } else { if ($LDAPDebugTrace) { $debugArray = array('stage' => '3/5: real authentication of user', 'info' => $info); eZDebug::writeNotice(var_export($debugArray, true), __METHOD__); } } } if (!$password) { $password = crypt(microtime()); } // is it real authenticated LDAP user? if (!@ldap_bind($ds, $info[0]['dn'], $password)) { // Increase number of failed login attempts. if (isset($userID)) { eZUser::setFailedLoginAttempts($userID); } eZDebug::writeWarning("User {$userID} failed to login!", __METHOD__); $user = false; return $user; } $extraNodeAssignments = array(); $userGroupClassID = $ini->variable("UserSettings", "UserGroupClassID"); // default user group assigning if ($LDAPUserGroupType != null) { if ($LDAPUserGroupType == "name") { if (is_array($LDAPUserGroup)) { foreach (array_keys($LDAPUserGroup) as $key) { $groupName = $db->escapeString($LDAPUserGroup[$key]); $groupQuery = "SELECT ezcontentobject_tree.node_id\n FROM ezcontentobject, ezcontentobject_tree\n WHERE ezcontentobject.name like '{$groupName}'\n AND ezcontentobject.id=ezcontentobject_tree.contentobject_id\n AND ezcontentobject.contentclass_id={$userGroupClassID}"; $groupObject = $db->arrayQuery($groupQuery); if (count($groupObject) > 0 and $key == 0) { $defaultUserPlacement = $groupObject[0]['node_id']; } else { if (count($groupObject) > 0) { $extraNodeAssignments[] = $groupObject[0]['node_id']; } } } } else { $groupName = $db->escapeString($LDAPUserGroup); $groupQuery = "SELECT ezcontentobject_tree.node_id\n FROM ezcontentobject, ezcontentobject_tree\n WHERE ezcontentobject.name like '{$groupName}'\n AND ezcontentobject.id=ezcontentobject_tree.contentobject_id\n AND ezcontentobject.contentclass_id={$userGroupClassID}"; $groupObject = $db->arrayQuery($groupQuery); if (count($groupObject) > 0) { $defaultUserPlacement = $groupObject[0]['node_id']; } } } else { if ($LDAPUserGroupType == "id") { if (is_array($LDAPUserGroup)) { foreach (array_keys($LDAPUserGroup) as $key) { $groupID = $LDAPUserGroup[$key]; $groupQuery = "SELECT ezcontentobject_tree.node_id\n FROM ezcontentobject, ezcontentobject_tree\n WHERE ezcontentobject.id='{$groupID}'\n AND ezcontentobject.id=ezcontentobject_tree.contentobject_id\n AND ezcontentobject.contentclass_id={$userGroupClassID}"; $groupObject = $db->arrayQuery($groupQuery); if (count($groupObject) > 0 and $key == 0) { $defaultUserPlacement = $groupObject[0]['node_id']; } else { if (count($groupObject) > 0) { $extraNodeAssignments[] = $groupObject[0]['node_id']; } } } } else { $groupID = $LDAPUserGroup; $groupQuery = "SELECT ezcontentobject_tree.node_id\n FROM ezcontentobject, ezcontentobject_tree\n WHERE ezcontentobject.id='{$groupID}'\n AND ezcontentobject.id=ezcontentobject_tree.contentobject_id\n AND ezcontentobject.contentclass_id={$userGroupClassID}"; $groupObject = $db->arrayQuery($groupQuery); if (count($groupObject) > 0) { $defaultUserPlacement = $groupObject[0]['node_id']; } } } } } // read group mapping LDAP settings $LDAPGroupMappingType = $LDAPIni->variable('LDAPSettings', 'LDAPGroupMappingType'); $LDAPUserGroupMap = $LDAPIni->variable('LDAPSettings', 'LDAPUserGroupMap'); if (!is_array($LDAPUserGroupMap)) { $LDAPUserGroupMap = array(); } // group mapping constants $ByMemberAttribute = 'SimpleMapping'; // by group's member attributes (with mapping) $ByMemberAttributeHierarhicaly = 'GetGroupsTree'; // by group's member attributes hierarhically $ByGroupAttribute = 'UseGroupAttribute'; // by user's group attribute (old style) $groupMappingTypes = array($ByMemberAttribute, $ByMemberAttributeHierarhicaly, $ByGroupAttribute); $userData =& $info[0]; // default mapping using old style if (!in_array($LDAPGroupMappingType, $groupMappingTypes)) { $LDAPGroupMappingType = $ByGroupAttribute; } if ($LDAPDebugTrace) { $debugArray = array('stage' => '4/5: group mapping init', 'LDAPUserGroupType' => $LDAPUserGroupType, 'LDAPGroupMappingType' => $LDAPGroupMappingType, 'LDAPUserGroup' => $LDAPUserGroup, 'defaultUserPlacement' => $defaultUserPlacement, 'extraNodeAssignments' => $extraNodeAssignments); eZDebug::writeNotice(var_export($debugArray, true), __METHOD__); } if ($LDAPGroupMappingType == $ByMemberAttribute or $LDAPGroupMappingType == $ByMemberAttributeHierarhicaly) { $LDAPGroupBaseDN = $LDAPIni->variable('LDAPSettings', 'LDAPGroupBaseDN'); $LDAPGroupBaseDN = str_replace($LDAPEqualSign, '=', $LDAPGroupBaseDN); $LDAPGroupClass = $LDAPIni->variable('LDAPSettings', 'LDAPGroupClass'); $LDAPGroupNameAttribute = strtolower($LDAPIni->variable('LDAPSettings', 'LDAPGroupNameAttribute')); $LDAPGroupMemberAttribute = strtolower($LDAPIni->variable('LDAPSettings', 'LDAPGroupMemberAttribute')); $LDAPGroupDescriptionAttribute = strtolower($LDAPIni->variable('LDAPSettings', 'LDAPGroupDescriptionAttribute')); $groupSearchingDepth = $LDAPGroupMappingType == '1' ? 1 : 1000; // now, get all parents for currently ldap authenticated user $requiredParams = array(); $requiredParams['LDAPLoginAttribute'] = $LDAPLoginAttribute; $requiredParams['LDAPGroupBaseDN'] = $LDAPGroupBaseDN; $requiredParams['LDAPGroupClass'] = $LDAPGroupClass; $requiredParams['LDAPGroupNameAttribute'] = $LDAPGroupNameAttribute; $requiredParams['LDAPGroupMemberAttribute'] = $LDAPGroupMemberAttribute; $requiredParams['LDAPGroupDescriptionAttribute'] = $LDAPGroupDescriptionAttribute; $requiredParams['ds'] =& $ds; if ($LDAPIni->variable('LDAPSettings', 'LDAPGroupRootNodeId') !== '') { $requiredParams['TopUserGroupNodeID'] = $LDAPIni->variable('LDAPSettings', 'LDAPGroupRootNodeId'); } else { $requiredParams['TopUserGroupNodeID'] = 5; } $groupsTree = array(); $stack = array(); $newfilter = '(&(objectClass=' . $LDAPGroupClass . ')(' . $LDAPGroupMemberAttribute . '=' . $userData['dn'] . '))'; $groupsTree[$userData['dn']] = array('data' => &$userData, 'parents' => array(), 'children' => array()); eZLDAPUser::getUserGroupsTree($requiredParams, $newfilter, $userData['dn'], $groupsTree, $stack, $groupSearchingDepth); $userRecord =& $groupsTree[$userData['dn']]; if ($LDAPGroupMappingType == $ByMemberAttribute) { if (count($userRecord['parents']) > 0) { $remappedGroupNames = array(); foreach (array_keys($userRecord['parents']) as $key) { $parentGroup =& $userRecord['parents'][$key]; if (isset($parentGroup['data'][$LDAPGroupNameAttribute])) { $ldapGroupName = $parentGroup['data'][$LDAPGroupNameAttribute]; if (is_array($ldapGroupName)) { $ldapGroupName = $ldapGroupName['count'] > 0 ? $ldapGroupName[0] : ''; } // remap group name and check that group exists if (array_key_exists($ldapGroupName, $LDAPUserGroupMap)) { $remmapedGroupName = $db->escapeString($LDAPUserGroupMap[$ldapGroupName]); $groupQuery = "SELECT ezcontentobject_tree.node_id\n FROM ezcontentobject, ezcontentobject_tree\n WHERE ezcontentobject.name like '{$remmapedGroupName}'\n AND ezcontentobject.id=ezcontentobject_tree.contentobject_id\n AND ezcontentobject.contentclass_id={$userGroupClassID}"; $groupRow = $db->arrayQuery($groupQuery); if (count($groupRow) > 0) { $userRecord['new_parents'][] = $groupRow[0]['node_id']; } } } } } } else { if ($LDAPGroupMappingType == $ByMemberAttributeHierarhicaly) { $stack = array(); self::goAndPublishGroups($requiredParams, $userData['dn'], $groupsTree, $stack, $groupSearchingDepth, true); } } if (isset($userRecord['new_parents']) and count($userRecord['new_parents']) > 0) { $defaultUserPlacement = $userRecord['new_parents'][0]; $extraNodeAssignments = array_merge($extraNodeAssignments, $userRecord['new_parents']); } } else { if ($LDAPGroupMappingType == $ByGroupAttribute) { if ($LDAPUserGroupAttributeType) { // Should we create user groups that are specified in LDAP, but not found in eZ Publish? $createMissingGroups = $LDAPIni->variable('LDAPSettings', 'LDAPCreateMissingGroups') === 'enabled'; if ($LDAPIni->variable('LDAPSettings', 'LDAPGroupRootNodeId') !== '') { $parentNodeID = $LDAPIni->variable('LDAPSettings', 'LDAPGroupRootNodeId'); } else { $parentNodeID = 5; } $groupAttributeCount = $info[0][$LDAPUserGroupAttribute]['count']; if ($LDAPUserGroupAttributeType == "name") { for ($i = 0; $i < $groupAttributeCount; $i++) { if ($isUtf8Encoding) { $groupName = utf8_decode($info[0][$LDAPUserGroupAttribute][$i]); } else { $groupName = $info[0][$LDAPUserGroupAttribute][$i]; } // Save group node id to either defaultUserPlacement or extraNodeAssignments self::getNodeAssignmentsForGroupName($groupName, $i == 0, $defaultUserPlacement, $extraNodeAssignments, $createMissingGroups, $parentNodeID); } } else { if ($LDAPUserGroupAttributeType == "id") { for ($i = 0; $i < $groupAttributeCount; $i++) { if ($isUtf8Encoding) { $groupID = utf8_decode($info[0][$LDAPUserGroupAttribute][$i]); } else { $groupID = $info[0][$LDAPUserGroupAttribute][$i]; } $groupName = "LDAP {$groupID}"; // Save group node id to either defaultUserPlacement or extraNodeAssignments self::getNodeAssignmentsForGroupName($groupName, $i == 0, $defaultUserPlacement, $extraNodeAssignments, $createMissingGroups, $parentNodeID); } } else { if ($LDAPUserGroupAttributeType == "dn") { for ($i = 0; $i < $groupAttributeCount; $i++) { $groupDN = $info[0][$LDAPUserGroupAttribute][$i]; $groupName = self::getGroupNameByDN($ds, $groupDN); if ($groupName) { // Save group node id to either defaultUserPlacement or extraNodeAssignments self::getNodeAssignmentsForGroupName($groupName, $i == 0, $defaultUserPlacement, $extraNodeAssignments, $createMissingGroups, $parentNodeID); } } } else { eZDebug::writeError("Bad LDAPUserGroupAttributeType '{$LDAPUserGroupAttributeType}'. It must be either 'name', 'id' or 'dn'.", __METHOD__); $user = false; return $user; } } } } } } // remove ' last_name' from first_name if cn is used for first name if ($LDAPFirstNameIsCN && isset($userData[$LDAPFirstNameAttribute]) && isset($userData[$LDAPLastNameAttribute])) { $userData[$LDAPFirstNameAttribute][0] = str_replace(' ' . $userData[$LDAPLastNameAttribute][0], '', $userData[$LDAPFirstNameAttribute][0]); } if (isset($userData[$LDAPEmailAttribute])) { $LDAPuserEmail = $userData[$LDAPEmailAttribute][0]; } else { if (trim($LDAPIni->variable('LDAPSettings', 'LDAPEmailEmptyAttributeSuffix'))) { $LDAPuserEmail = $login . $LDAPIni->variable('LDAPSettings', 'LDAPEmailEmptyAttributeSuffix'); } else { $LDAPuserEmail = false; } } $userAttributes = array('login' => $login, 'first_name' => isset($userData[$LDAPFirstNameAttribute]) ? $userData[$LDAPFirstNameAttribute][0] : false, 'last_name' => isset($userData[$LDAPLastNameAttribute]) ? $userData[$LDAPLastNameAttribute][0] : false, 'email' => $LDAPuserEmail); if ($LDAPDebugTrace) { $debugArray = array('stage' => '5/5: storing user', 'userAttributes' => $userAttributes, 'isUtf8Encoding' => $isUtf8Encoding, 'defaultUserPlacement' => $defaultUserPlacement, 'extraNodeAssignments' => $extraNodeAssignments); eZDebug::writeNotice(var_export($debugArray, true), __METHOD__); } $oldUser = clone eZUser::currentUser(); $existingUser = eZLDAPUser::publishUpdateUser($extraNodeAssignments, $defaultUserPlacement, $userAttributes, $isUtf8Encoding); if (is_object($existingUser)) { eZUser::setCurrentlyLoggedInUser($existingUser, $existingUser->attribute('contentobject_id')); } else { eZUser::setCurrentlyLoggedInUser($oldUser, $oldUser->attribute('contentobject_id')); } ldap_close($ds); return $existingUser; } else { eZDebug::writeError('Cannot initialize connection for LDAP server', __METHOD__); $user = false; return $user; } } else { // Increase number of failed login attempts. if (isset($userID)) { eZUser::setFailedLoginAttempts($userID); } eZDebug::writeWarning('User does not exist or LDAP is not enabled in php', __METHOD__); $user = false; return $user; } } }
/** * File containing the updatechildren CLI script * * @copyright Copyright (C) 1999-2012 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/gnu_gpl GNU GPLv2 * @package ezmbpaex */ $mbpaexIni = eZINI::instance('mbpaex.ini'); // Fetch the user to use in the process $updateChildrenUser = $mbpaexIni->variable('mbpaexSettings', 'UpdateChildrenUser'); // Default to admin if user is not found in the ini if (!trim($updateChildrenUser)) { $updateChildrenUser = '******'; } $user = eZUser::fetchByName($updateChildrenUser); eZUser::setCurrentlyLoggedInUser($user, $user->attribute('contentobject_id')); if ($user->isLoggedIn()) { $cli->output("eZPaEx: Update children process start"); ini_set('max_execution_time', 0); ini_set('memory_limit', '-1'); eZDebug::addTimingPoint('Fetch update pending list'); // Get list of paex objects marked to updatechildren $pendingList = eZPaEx::fetchUpdateChildrenPendingList(); $pendingListCount = count($pendingList); if (!$pendingListCount) { $cli->output("No pending update subtrees found"); } else { $cli->output("Found " . $pendingListCount . " ezpaex objects with pending updatechildren"); $pendingIdList = array(); foreach ($pendingList as $pendingObject) { $pendingIdList[] = $pendingObject->attribute('contentobject_id');
function LogInOpenIDUser($identifier = false, $email = false) { $moduleINI = eZINI::instance('module.ini'); $attributeID = $moduleINI->variable('ModuleSettings', 'OpenIDAttributeID'); $nodeID = $moduleINI->variable('ModuleSettings', 'DefaultUserPlacement'); if ($email) { $userByEmail = eZUser::fetchByEmail($email); if ($userByEmail and $userByEmail->isEnabled()) { $userID = $userByEmail->attribute('contentobject_id'); eZUser::setCurrentlyLoggedInUser($userByEmail, $userID); eZUser::updateLastVisit($userID); eZUser::setFailedLoginAttempts($userID, 0); return $userByEmail; } } else { $params = array('AttributeFilter' => array(array($attributeID, '=', $identifier)), 'ClassFilterType' => 'include', 'ClassFilterArray' => array('user'), 'Limit' => 1, 'Limitation' => array()); $userSubTree = eZContentObjectTreeNode::subTreeByNodeID($params, $nodeID); if (count($userSubTree) == 1) { $userContentObjectID = $userSubTree[0]->attribute('contentobject_id'); $user = eZUser::fetch($userContentObjectID, true); if ($user and $user->isEnabled()) { $userID = $user->attribute('contentobject_id'); eZUser::setCurrentlyLoggedInUser($user, $userID); eZUser::updateLastVisit($userID); eZUser::setFailedLoginAttempts($userID, 0); return $user; } } } return false; }
/** * Regression test for issue #16949 * 1) Test there is no pending object in sub objects * 2) Test there is one pending object in sub objects */ public function testIssue16949() { //create object $top = new ezpObject( 'article', 2 ); $top->title = 'TOP ARTICLE'; $top->publish(); $child = new ezpObject( 'article', $top->mainNode->node_id ); $child->title = 'THIS IS AN ARTICLE'; $child->publish(); $adminUser = eZUser::fetchByName( 'admin' ); $adminUserID = $adminUser->attribute( 'contentobject_id' ); $currentUser = eZUser::currentUser(); $currentUserID = eZUser::currentUserID(); eZUser::setCurrentlyLoggedInUser( $adminUser, $adminUserID ); $result = eZContentObjectTreeNode::subtreeRemovalInformation( array( $top->mainNode->node_id ) ); $this->assertFalse( $result['has_pending_object'] ); $workflowArticle = new ezpObject( 'article', $top->mainNode->node_id ); $workflowArticle->title = 'THIS IS AN ARTICLE WITH WORKFLOW'; $workflowArticle->publish(); $version = $workflowArticle->currentVersion(); $version->setAttribute( 'status', eZContentObjectVersion::STATUS_PENDING ); $version->store(); $result = eZContentObjectTreeNode::subtreeRemovalInformation( array( $top->mainNode->node_id ) ); $this->assertTrue( $result['has_pending_object'] ); eZUser::setCurrentlyLoggedInUser( $currentUser, $currentUserID ); }
if (!in_array($otherNode['parent_node_id'], $noAddAssignmentList)) { $newVersion->assignToNode($otherNode['parent_node_id'], $otherNode['is_main']); } } } if ($hasLDAPNodeType) { foreach ($newLDAPNodeArray as $newLDAPNode) { if (!in_array($newLDAPNode['parent_node_id'], $noAddAssignmentList)) { $newVersion->assignToNode($newLDAPNode['parent_node_id'], $newLDAPNode['is_main']); } $assignment = eZNodeAssignment::fetch($contentObject->attribute('id'), $newVersionNr, $newLDAPNode['parent_node_id']); $assignment->setAttribute('parent_remote_id', uniqid('LDAP_')); $assignment->store(); } } if (!$hasOtherNodeType and !$hasLDAPNodeType) { if (!in_array($defaultUserPlacement, $noAddAssignmentList)) { $newVersion->assignToNode($defaultUserPlacement, 1); } } $adminUser = eZUser::fetchByName('admin'); $adminUserContentObjectID = $adminUser->attribute('contentobject_id'); eZUser::setCurrentlyLoggedInUser($adminUser, $adminUserContentObjectID); $operationResult = eZOperationHandler::execute('content', 'publish', array('object_id' => $userID, 'version' => $newVersionNr)); $cli->output($cli->stylize('emphasize', $existUser->attribute('login')) . " has changed group, updated."); } } } } $db->commit(); $cli->output("All LDAP users have been updated!");