Set all impacted aliases as outdated

@param array $nodeIdList
174488
public function onAliasChange(array $nodeIdList) : void
    {
        $this->aliasManager->invalidateRelated($nodeIdList);
        $this->aliasCacheLookup->refresh();
    }
1064388
public function purgeAllAliases()
    {
        $aliasList = $this->aliasList( false );
        ezpEvent::getInstance()->notify( 'image/purgeAliases', array( $aliasList['original']['url'] ) );
        unset( $aliasList['original'] ); // keeping original

        foreach ( $aliasList as $alias )
        {
            if ( $alias['is_valid'] )
                $this->removeAliasFile( $alias['url'] );

            // remove entry from DOM model
            $doc = $this->ContentObjectAttributeData['DataTypeCustom']['dom_tree'];
            $domXPath = new DOMXPath( $doc );
            foreach ( $domXPath->query( "//alias[@name='{$alias['name']}']") as $aliasNode )
            {
                $aliasNode->parentNode->removeChild( $aliasNode );
            }
        }

        if ( isset( $doc ) )
            $this->storeDOMTree( $doc, true, false );
    }
929914
private function preloadDependencies(array $nodeList)
    {
        $userIdList = [];
        $siteIdList = [];

        foreach ($nodeList as $node) {
            $userIdList[$node->uid] = $node->uid;
            foreach ($node->ucms_sites as $siteId) {
                $siteIdList[$siteId] = $siteId;
            }
        }

        if ($userIdList) {
            $this->entityManager->getStorage('user')->loadMultiple($userIdList);
        }
        if ($siteIdList) {
            $this->manager->getStorage()->loadAll($siteIdList);
        }
    }
449
public function markNodeActive($nodeId)
    {
        $xPath = new DOMXPath($this->getDomXml());
        $nodeList = $xPath->query("//*[@cl='{$nodeId}' or @list='{$nodeId}']");

        if ($nodeList->length) {
            foreach ($nodeList as $node) {
                // special case for external resources
                $node->setAttribute('active', 1);
                $node->parentNode->setAttribute('active', 1);
            }
        }
    }
884958
static function fetchAliasesFromNodeList( $nodeList )
    {
        if ( !is_array( $nodeList ) || count( $nodeList ) < 1 )
            return array();

        $db = eZDB::instance();
        $where = $db->generateSQLINStatement( $nodeList, 'node_id', false, false, 'int' );
        $query = "SELECT node_id, path_identification_string FROM ezcontentobject_tree WHERE $where";
        $pathListArray = $db->arrayQuery( $query );
        return $pathListArray;
    }
237343
public void setDomainStatusList(java.util.Collection<ElasticsearchDomainStatus> domainStatusList) {
        if (domainStatusList == null) {
            this.domainStatusList = null;
            return;
        }

        this.domainStatusList = new java.util.ArrayList<ElasticsearchDomainStatus>(domainStatusList);
    }
881027
static public function removeNodes( array $removeNodeIdList )
    {
        $mainNodeChanged      = array();
        $nodeAssignmentIdList = array();
        $objectIdList         = array();

        $db = eZDB::instance();
        $db->begin();

        foreach ( $removeNodeIdList as $nodeId )
        {
            $node     = eZContentObjectTreeNode::fetch($nodeId);
            $objectId = $node->attribute( 'contentobject_id' );
            foreach ( eZNodeAssignment::fetchForObject( $objectId,
                                                        eZContentObject::fetch( $objectId )->attribute( 'current_version' ),
                                                        0, false ) as $nodeAssignmentKey => $nodeAssignment )
            {
                if ( $nodeAssignment['parent_node'] == $node->attribute( 'parent_node_id' ) )
                {
                    $nodeAssignmentIdList[$nodeAssignment['id']] = 1;
                }
            }

            if ( $nodeId == $node->attribute( 'main_node_id' ) )
                $mainNodeChanged[$objectId] = 1;
            $node->removeThis();

            if ( !isset( $objectIdList[$objectId] ) )
                $objectIdList[$objectId] = eZContentObject::fetch( $objectId );
        }

        eZNodeAssignment::purgeByID( array_keys( $nodeAssignmentIdList ) );

        foreach ( array_keys( $mainNodeChanged ) as $objectId )
        {
            $allNodes = $objectIdList[$objectId]->assignedNodes();
            // Registering node that will be promoted as 'main'
            if ( isset( $allNodes[0] ) )
            {
                $mainNodeChanged[$objectId] = $allNodes[0];
                eZContentObjectTreeNode::updateMainNodeID( $allNodes[0]->attribute( 'node_id' ), $objectId, false, $allNodes[0]->attribute( 'parent_node_id' ) );
            }
        }

        // Give other search engines that the default one a chance to reindex
        // when removing locations.
        if ( !eZSearch::getEngine() instanceof eZSearchEngine )
        {
            foreach ( array_keys( $objectIdList ) as $objectId )
                eZContentOperationCollection::registerSearchObject( $objectId );
        }

        $db->commit();

        //call appropriate method from search engine
        eZSearch::removeNodes( $removeNodeIdList );

        $userClassIdList = eZUser::contentClassIDs();
        foreach ( $objectIdList as $objectId => $object )
        {
            eZContentCacheManager::clearObjectViewCacheIfNeeded( $objectId );

            // clear user policy cache if this was a user object
            if ( in_array( $object->attribute( 'contentclass_id' ), $userClassIdList ) )
            {
                eZUser::purgeUserCacheByUserId( $object->attribute( 'id' ) );
            }

            // Give other search engines that the default one a chance to reindex
            // when removing locations.
            if ( !eZSearch::getEngine() instanceof eZSearchEngine )
            {
                eZContentOperationCollection::registerSearchObject( $objectId );
            }
        }

        // Triggering content/cache filter for Http cache purge
        ezpEvent::getInstance()->filter( 'content/cache', $removeNodeIdList, array_keys( $objectIdList ) );
        // we don't clear template block cache here since it's cleared in eZContentObjectTreeNode::removeNode()

        return array( 'status' => true );
    }
1115263
protected function getIdentifiers( array $aliasList )
    {
        if ( $this->aliases !== null )
        {
            foreach ( $aliasList as $key => $alias )
            {
                $aliasList[$key] = $this->getIdentifier( $alias );
            }
        }
        return $aliasList;
    }
619591
public function swapNode( $nodeID, $selectedNodeID, $nodeIdList = array() )
    {
        $contentObject1 = eZContentObject::fetchByNodeID( $nodeID );
        $contentObject2 = eZContentObject::fetchByNodeID( $selectedNodeID );

        eZContentOperationCollection::registerSearchObject( $contentObject1->attribute( 'id' ) );
        eZContentOperationCollection::registerSearchObject( $contentObject2->attribute( 'id' ) );
    }
706102
public void setCidrAllowedList(java.util.Collection<String> cidrAllowedList) {
        if (cidrAllowedList == null) {
            this.cidrAllowedList = null;
            return;
        }

        this.cidrAllowedList = new java.util.ArrayList<String>(cidrAllowedList);
    }
1030284
public function setNodeMeta(NodeInterface $node, array $values = []) : void
    {
        if ($this->isNodeBlacklisted($node)) {
            return;
        }

        $sqlValues = [];

        foreach ($values as $key => $value) {

            if (empty($value)) {
                $value = null;
            }

            switch ($key) {

                case 'title':
                case 'description':
                    $sqlValues['meta_' . $key] = $value;
                    break;

                default:
                    continue;
            }
        }

        if (empty($values)) {
            return;
        }

        $this
            ->database
            ->update('ucms_seo_node')
            ->fields($sqlValues)
            ->condition('nid', $node->id())
            ->execute()
        ;

        // @todo clear page cache
    }
793231
private function _processMigrationSql(array $sqlList)
    {
        foreach ($sqlList as $sql) {
            if ($this->logger) {
                $this->logger->info($sql.PHP_EOL);
            }
            $this->getDbRepository()->getAdapter()->execute($sql);
        }
    }
92487
public static function clearNodeViewCacheArray( array $nodeList, array $contentObjectList = null )
    {
        if ( count( $nodeList ) == 0 )
        {
            return false;
        }

        eZDebugSetting::writeDebug( 'kernel-content-edit', count( $nodeList ), "count in nodeList" );

        if ( eZINI::instance()->variable( 'ContentSettings', 'StaticCache' ) === 'enabled' )
        {
            $staticCacheHandler = eZExtension::getHandlerClass(
                new ezpExtensionOptions(
                    array(
                        'iniFile' => 'site.ini',
                        'iniSection' => 'ContentSettings',
                        'iniVariable' => 'StaticCacheHandler',
                    )
                )
            );

            $staticCacheHandler->generateAlwaysUpdatedCache();
            $staticCacheHandler->generateNodeListCache( $nodeList );
        }

        eZDebug::accumulatorStart( 'node_cleanup', '', 'Node cleanup' );

        eZContentObject::expireComplexViewModeCache();
        $cleanupValue = eZContentCache::calculateCleanupValue( count( $nodeList ) );

        if ( eZContentCache::inCleanupThresholdRange( $cleanupValue ) )
        {
            $nodeList = ezpEvent::getInstance()->filter( 'content/cache', $nodeList, $contentObjectList );
            eZContentCache::cleanup( $nodeList );
        }
        else
        {
            eZDebug::writeDebug( "Expiring all view cache since list of nodes({$cleanupValue}) exceeds site.ini\[ContentSettings]\CacheThreshold", __METHOD__ );
            ezpEvent::getInstance()->notify( 'content/cache/all' );
            eZContentObject::expireAllViewCache();
        }

        eZDebug::accumulatorStop( 'node_cleanup' );
        return true;
    }
194232
protected function registerNodes($nodeList)
    {
        // If the node list is invalid
        if (!is_array($nodeList) && !($nodeList instanceof \DOMNodeList)) {
            throw new RuntimeException(RuntimeException::INVALID_NODE_LIST_STR, RuntimeException::INVALID_NODE_LIST);
        }

        $nodes = [];

        // Run through and register all nodes
        /** @var \DOMNode $node */
        foreach ($nodeList as $node) {
            $nodes[$node->getNodePath()] = $this->registerNode($node);
        }

        return $nodes;
    }
891737
@Override
  public void onNodesUpdated(final List<NodeReport> nodeReports) {
    for (final NodeReport nodeReport : nodeReports) {
      this.nodeIdToRackName.put(nodeReport.getNodeId().toString(), nodeReport.getRackName());
      this.onNodeReport(nodeReport);
    }
  }
1020292
public function beforeNodePropertyChange(NodeInterface $node, $propertyName, $oldValue, $value)
    {
        if (!$this->eventEmittingService->isEnabled()) {
            return;
        }

        if (count($this->currentNodeAddEvents) > 0) {
            // add is currently running, during that; we do not want any update events
            return;
        }
        if ($oldValue === $value) {
            return;
        }
        if (!isset($this->changedNodes[$node->getContextPath()])) {
            $this->changedNodes[$node->getContextPath()] = ['node' => $node];
        }
        if (!isset($this->changedNodes[$node->getContextPath()]['oldLabel'])) {
            $this->changedNodes[$node->getContextPath()]['oldLabel'] = $node->getLabel();
        }

        $this->changedNodes[$node->getContextPath()]['old'][$propertyName] = $oldValue;
        $this->changedNodes[$node->getContextPath()]['new'][$propertyName] = $value;
    }
1153019
public void setNodeInfoList(java.util.Collection<NodeInfo> nodeInfoList) {
        if (nodeInfoList == null) {
            this.nodeInfoList = null;
            return;
        }

        this.nodeInfoList = new java.util.ArrayList<NodeInfo>(nodeInfoList);
    }