/**
     * @see eZContentObjectEditHandler::publish()
     * @param int $contentObjectID
     * @param eZContentObjectVersion $contentObjectVersion
     */
    function publish( $contentObjectID, $contentObjectVersion )
    {
        $contentObject = eZContentObject::fetch( $contentObjectID );

        if( $contentObject instanceof eZContentObject )
        {
            switch($contentObject->ClassIdentifier)
            {
                case 'article':
                {
                    ObjectVisibilityManager::updateGlobalLimitation($contentObject);

                    /* @type $mainNode eZContentObjectTreeNode */
                    /* @type $clustersToHide array */
                    $db                 = eZDB::instance();
                    $mainNode           = $contentObject->mainNode();
                    $clustersToHide     = eZINI::instance( 'merck.ini' )->variable( 'PublishSettings', 'clustersToHide' );
                    $publisherNodeId    = PublisherFolderTool::getPublisherNodeIdFromArticleNode($mainNode);
                    $publisherInfo      = PublisherFolderTool::getNodeIdToPathMapping($publisherNodeId);
                    $publisherClusters  = PublisherFolderTool::getClustersFromPath($publisherInfo['path']);
                    $inserted           = false;
                    
                    foreach( $clustersToHide as $clusterToHide )
                    {
                        if( in_array($clusterToHide, $publisherClusters) )
                        {
                            if ( !$inserted )
                            {
                                $db->query( sprintf(
                                    "INSERT INTO ezpending_actions (action, created, param)
                                        VALUES ('check_node_visibility', %d, '%s' )",
                                    time(),
                                    $contentObject->mainNodeID()
                                ));
                                $inserted = true;
                            }
                            
                            ObjectVisibilityManager::updateClusterLimitation($contentObjectID, $clusterToHide, true);
                        }
                    }
                }
                break;
            }
        }
    }
/**
 * @param array $contentObjectList
 */
function checkObjectVisibility ($contentObjectList)
{
    foreach ( array_keys($contentObjectList) as $index )
    {
        $contentObjectId  = $contentObjectList[$index]['contentobject_id'];

        echo "Checking visibility of object $contentObjectId\n";

        $articleContentObject = eZContentObject::fetch($contentObjectId);

        if ( $articleContentObject && $articleContentObject->attribute('class_identifier') === "article" )
            ObjectVisibilityManager::updateGlobalLimitation($articleContentObject);

        unset($articleContentObject);

        eZContentObject::clearCache();
    }
}
    /**
     * @param int $contentObjectId
     * @return boolean[]
     */
    public static function getClusterVisibilities($contentObjectId)
    {
        $clusters = ClusterTool::globCluster();
        $visibilities = array();

        foreach( $clusters as $cluster )
        {
            $visibilities[$cluster] = !ObjectVisibilityManager::isClusterLimited( $contentObjectId, $cluster );
        }

        return $visibilities;
    }
    /**
     * @param MMSelections[] $userSelection
     * @param int $offset
     * @return array
     */
    public function manageResults( $userSelection, $offset = 0 )
    {
        $limit  = $this->applicationObject->configurationContentService->attribute('nb_of_articles_per_page');
        $facets = array('applications' => null);
        $db     = eZDB::instance();
        $query  = "select id from ezcontentobject where remote_id = '%s'";
        $isRemoved = false;

        /** @var MMSelections $selection */
        foreach( $userSelection as $key => $selection )
        {
            $result = $db->arrayQuery(sprintf(
                $query,
                $selection->attribute("remote_id")
            ));

            if ( count($result) == 1 )
            {
                $objectId = $result[0]['id'];
                $isVisible = ObjectVisibilityManager::isVisible($objectId);

                if (!$isVisible)
                {
                    unset($userSelection[$key]);
                    $selection->remove();
                    $isRemoved = true;
                    continue;
                }
            }

            $applicationIdentifier = $selection->attribute('application');
            if( $applicationIdentifier != null )
            {
                if( (CacheApplicationTool::buildLocalizedApplicationByIdentifier( $applicationIdentifier ) instanceof ApplicationLocalized) ) {
                    if( !isset( $facets['applications'][$applicationIdentifier] ) )
                        $facets['applications'][$applicationIdentifier] = 1;
                    else
                        $facets['applications'][$applicationIdentifier]++;
                } else {
                    unset($userSelection[$key]);
                    $selection->remove();
                    $isRemoved = true;
                }
            }
        }
        if ( $isRemoved ) {
            MMSelections::setCookie();
        }

        $total = count( $userSelection );

        if( $offset != 0 )
            $userSelection = array_slice( $userSelection, $offset );

        uksort( $facets['applications'], function($a, $b){
            return strnatcasecmp( ezpI18n::tr('merck/application', $a), ezpI18n::tr('merck/application', $b) );
        });

        if( $total > $limit )
            $userSelection = array_slice( $userSelection, 0, $limit );

        return array( 'items' => $userSelection, 'total' => $total, 'facets' => $facets );
    }
    /**
     * Brightcove - update article visibility on media change
     * Called from Listener factory
     */
    static function bcCheckArticlesRelatedToMedia()
    {
        $args = func_get_args();

        if( empty($args[0]) || !isset( $args[0]['id'] ) )
            return;

        $id                 = $args[0]['id'];
        $eZBrightcoveObject = eZBrightcoveObject::fetch( array( 'id' => $id ) );

        if( !($eZBrightcoveObject instanceof eZBrightcoveObject) )
            return;
                
        $mediaContentObjectId = $eZBrightcoveObject->attribute('contentobject_id');

        if( empty( $mediaContentObjectId ) )
            return;
        

        $mediaContentObject = eZContentObject::fetch( $mediaContentObjectId );

        //Get related articles
        if( $mediaContentObject->reverseRelatedObjectCount( false, 0, array('AllRelations' => true ) ) == 0 )
            return;

        $relatedArticleContentObjects = $mediaContentObject->reverseRelatedObjectList( false, 0, false, array('AllRelations' => true ) );
        $relatedArticleContentObjects = array_merge($relatedArticleContentObjects, self::getRelatedCoreContentArticle($mediaContentObjectId));

        foreach( $relatedArticleContentObjects as $relatedArticleContentObject )
        {
            if( $relatedArticleContentObject instanceof eZContentObject )
                ObjectVisibilityManager::updateGlobalLimitation($relatedArticleContentObject);
        }
    }
    /**
     * @param array $accreditationList
     * @param int $offset
     *
     * @return array Sorted and filtered list of certificates.
     */
    public function manageResults( $accreditationList = null, $offset = 0 )
    {
        $wsResults = CertificatesWebservice::getCertificatesList();
        $facets = array(
            self::$noAccreditationKeyword => 0
        );

        foreach ( $wsResults as $k => $result )
        {
            $fetchResult = self::fetchNodeAndAppFromCourseId( $result['CourseID'] );

            if ( $result['CompletionDateTime'] != '' )
            {
                $tempDate = DateTime::createFromFormat( $this->dateFormat, $result['CompletionDateTime'] );
                if ( $tempDate instanceof DateTime )
                {
                    $wsResults[$k]['CompletionDateTime'] = $tempDate->getTimestamp();
                }
                else
                {
                    $wsResults[$k]['CompletionDateTime'] = '';
                }
            }

            if ( $fetchResult === false || (isset($fetchResult['node']) && !ObjectVisibilityManager::isVisible($fetchResult['node']->ContentObjectID)) )
            {
                $wsResults[$k]['SimpleView'] = true;
                $facets[self::$noAccreditationKeyword] += 1;
                if ( !self::isAccreditationSourceChosen( self::$noAccreditationKeyword, $accreditationList ) )
                {
                    unset( $wsResults[$k] );
                }
                continue;
            }
            /* @type $node eZContentObjectTreeNode */
            /* @type $dm eZContentObjectAttribute[] */
            $node           = $fetchResult['node'];
            $wsResults[$k]  = array_merge($wsResults[$k], $fetchResult);
            $dm             = $node->dataMap();
            $tags = array();
            if ( $dm['serialized_taxonomies'] instanceof eZContentObjectAttribute )
            {
                $serializedTaxonomies = $dm['serialized_taxonomies']->content();
                if ( isset( $serializedTaxonomies['accreditation_source'] ) )
                {
                    $tags = (array) $serializedTaxonomies['accreditation_source'];
                }
            }

            if ( count( $tags ) == 0 )
            {
                $wsResults[$k]['SimpleView'] = true;
                $facets[self::$noAccreditationKeyword] += 1;
                if ( !self::isAccreditationSourceChosen( self::$noAccreditationKeyword, $accreditationList ) )
                {
                    unset( $wsResults[$k] );
                }
                continue;
            }

            foreach ( $tags as $keyword )
            {
                if ( !isset( $facets[$keyword] ) )
                {
                    $facets[$keyword] = 0;
                }

                $facets[$keyword] += 1;

                if ( !self::isAccreditationSourceChosen( $keyword, $accreditationList ) )
                {
                    unset( $wsResults[$k] );
                }
            }
        }
        $articleTotal = count( $wsResults );

        return array(
            "items" => self::sortAndPaginate( $wsResults, $articleTotal, $offset ),
            "facets" => array(
                "accreditation_source" => $facets
            ),
            "total" => $articleTotal,
        );
    }
Esempio n. 7
0
                                if( $dates['daysLeft'] > 0 )
                                {
                                    $articleObject = $article->object();
                                    $relatedArticles[] = $articleObject;
                                }
                            }
                        }
                    }
                    else
                    {
                        foreach( $relatedObjects as $relatedObject )
                        {
                            /* @var $relatedObject eZContentObject */
                            if( $relatedObject->ClassIdentifier == 'article' )
                            {
                                $isVisible = ObjectVisibilityManager::isVisible($relatedObject->attribute('id'));

                                if( $isVisible )
                                {
                                    /* @type $articleDatamap eZContentObjectAttribute[] */
                                    $articleDatamap = $relatedObject->dataMap();

                                    if( isset($articleDatamap['online_date'])
                                        && $articleDatamap['online_date']->hasContent() )
                                    {
                                        /* @type $onlineDateContent eZDate */
                                        $onlineDateContent = $articleDatamap['online_date']->content();
                                        $onlineDate        = $onlineDateContent->timestamp();
                                        $dates             = SolrSafeOperatorHelper::getDatesPDFavailable($onlineDate,$expirationDuration);

                                        if( $dates['daysLeft'] > 0 )
    /**
     * 
     * @param string $nodePath
     * @param ApplicationDefault $app
     * @return null
     */
    static public function findNodeFromPath ($nodePath, $app )
    {
        $uri             = explode( '/', ltrim( $nodePath, '/' ) );
        $rootNodes       = array();
        $applicationName = $app->applicationName();

        if( count( $uri ) > 1 && is_numeric($uri[0]) )
        {
            $publisherFolderId = $uri[0];
            array_shift($uri);
            $uriArticle = implode ('/', $uri);
        }
        else
            $uriArticle = ltrim( $nodePath, '/' );
        
        $uriArticle = urldecode($uriArticle);

        if($applicationName)
        {
            $publishers = $app->applicationLocalized()->publisherFolders;

            /* @var $publisher PublisherFolder */
            foreach ($publishers as $publisher)
            {
                $pfids = PublisherFolderTool::getPathToIDMapping( $publisher->attribute('path') );

                // If PublisherFolderId is included in url, we only take care about this publisher folder
                if ( isset($publisherFolderId) && $pfids['pfid'] == $publisherFolderId )
                {
                    $rootNodes[] = eZContentObjectTreeNode::fetch($pfids['nid']);
                    $articlePath = $uriArticle;

                    break;
                }
                elseif( !isset($publisherFolderId) )
                {
                    $node = eZContentObjectTreeNode::fetch($pfids['nid']);
                    if($node) {
                        $rootNodes[] = $node;
                        $articlePath = $uriArticle;
                    }
                }
            }
        }

        if ( isset($publisherFolderId) != false && trim($uriArticle) == '' )
            return $app;
        
        if ( !isset($articlePath) || count($rootNodes) == 0 )
            return null;

        $node = self::getNodeFromPath ($articlePath, $rootNodes);

        if ( !$node )
            return null;
        
        $cluster   = $app->applicationLocalized()->attribute( 'cluster_identifier' );
        $isVisible = ObjectVisibilityManager::isVisible( $node->attribute('contentobject_id'), $cluster );

        if ( !$isVisible )
            return null;

        return $node;
    }
    /**
     * @param array $row
     */
    public static function updateNodeVisibility($row)
    {
        /* @type $node eZContentObjectTreeNode */
        $comment      = "";
        $db           = eZDB::instance();
        $pendingBased = !isset($row['manual']);
        $nodeId       = (int)$row['param'];
        $delete       = true;
        $nodeFetch    = eZContentObjectTreeNode::fetch( $nodeId );

        if ( !($nodeFetch instanceof eZContentObjectTreeNode) )
            $comment = "Not found in eZ Publish";
        else
        {
            $node = $nodeFetch->findMainNode($nodeFetch->attribute('contentobject_id'), true);

            if ($node)
            {
                if ($node->object()->ClassIdentifier == 'article')
                {
                    $toHideResults = self::nodeHasForbiddenWords($node, $row);

                    foreach ($toHideResults as $cluster => $toHideResult)
                    {
                        if ($toHideResult['toHide'])
                        {
                            ObjectVisibilityManager::updateClusterLimitation(
                                $node->attribute('contentobject_id'),
                                $cluster,
                                true
                            );
                        }
                        else
                        {
                            $parentIsInvisible = false;

                            if ($node->attribute('depth') > 4)
                            {
                                $parentNode        = $node->fetchParent();
                                $parentIsInvisible = ObjectVisibilityManager::isClusterLimited(
                                    $parentNode->attribute('contentobject_id'),
                                    $cluster
                                );
                            }

                            if ($parentIsInvisible)
                            {
                                ObjectVisibilityManager::updateClusterLimitation(
                                    $node->attribute('contentobject_id'),
                                    $cluster,
                                    false
                                );
                            }
                            else
                            {
                                ObjectVisibilityManager::removeClusterLimitation(
                                    $node->attribute('contentobject_id'),
                                    $cluster
                                );
                            }
                        }

                        if (!$toHideResult['toDelete'])
                        {
                            $delete = false;
                        }

                        $comment .= sprintf(";Cluster : %s - Message : %s", $cluster, $toHideResult['comment']);
                    }
                }
            }
            else
            {   // node does not exist in ez - we delete the pending row
                $comment = "Not found in eZ Publish";
            }
        }

        if( $delete && $pendingBased )
            $db->query( sprintf( "DELETE FROM ezpending_actions WHERE id = %d", $row['id'] ) );

        eZLog::write( "RowId : {$row['id']}; Node : $nodeId $comment", 'updatevisibility.log' );

        unset( $node );
        eZContentObject::clearCache();
    }
        if ( $i%100 == 0 )
            $cli->notice( "$i nodes have been treated." );

        $i++;

        if ( !isset($result) || !isset($result['contentobject_id']) )
        {
            $cli->warning("We somehow got an invalid MySQL entry");
            continue;
        }

        $contentObjectId = $result['contentobject_id'];
        $contentObject   = eZContentObject::fetch($contentObjectId);

        if ( $contentObject instanceof eZContentObject )
            ObjectVisibilityManager::updateGlobalLimitation ( $contentObject );
        else
        {
            $cli->warning("$contentObjectId is not a valid object.");
            continue;
        }

        unset($contentObject);
        eZContentObject::clearCache();
    }

    $offset+= $limit;
}

$cli->notice( "Treatment completed successfully; $i nodes treated." );
    /**
     * The modify method gets the current content object AND the list of
     * Solr Docs (for each available language version).
     *
     * @param eZContentObject $contentObject
     * @param eZSolrDoc[] $docList
     */
    public function modify( eZContentObject $contentObject, &$docList )
    {
        /* @var eZContentObjectTreeNode $contentMainNode */
        $contentMainNode        = $contentObject->mainNode();
        $contentObjectLanguages = $contentObject->allLanguages();
        $articleLanguageArray   = array_keys($contentObjectLanguages);
        $publisherFolderNodeId  = PublisherFolderTool::getPublisherNodeIdFromArticleNode($contentMainNode);
        $isMerckManualShowcase  = false;
        // Depth : 0 => father article, 1+ => child article
        $articleRelativeDepth   = $contentMainNode->attribute('depth') - 4;

        if ( is_null($publisherFolderNodeId) )
            return;

        $publisherFolderInfos = PublisherFolderTool::getPublisherFolderInfosFromNodeId($publisherFolderNodeId);
        
        if ( !$publisherFolderInfos )
            return;

        $publisherFolderRelations = PublisherFolderTool::getPublisherFolderRelations($publisherFolderInfos['path']);

        if ( !$publisherFolderRelations || count($publisherFolderRelations['clusters']) === 0 )
            return;

        // node remote
        $remote = $contentMainNode->attribute("remote_id");
        $this->addValueToDoc( $docList, 'attr_node_remote_s', $remote);
        $this->addValueToDoc( $docList, 'attr_relative_depth_i', $articleRelativeDepth);

        foreach ( $publisherFolderRelations['clusters'] as $cluster => $applications )
        {
            ClusterTool::setCurrentCluster( $cluster );
            
            $applicationIdentifier = $applications[0];

            /* @var $applicationLocalized ApplicationLocalized */
            $applicationLocalized = CacheApplicationTool::buildLocalizedApplicationByIdentifier( $applicationIdentifier );

            if ( !($applicationLocalized instanceof ApplicationLocalized) )
            {
                if (count($applications) == 1)
                {
                    unset($publisherFolderRelations['clusters'][$cluster]);
                    continue;
                }

                $applicationIdentifier = $applications[1];
                $applicationLocalized = CacheApplicationTool::buildLocalizedApplicationByIdentifier( $applicationIdentifier );

                if ( !($applicationLocalized instanceof ApplicationLocalized) )
                {
                    unset($publisherFolderRelations['clusters'][$cluster]);
                    continue;
                }
                
                $publisherFolderRelations['clusters'][$cluster] = array ($applicationIdentifier);
            }

            // visibility per cluster
            $isVisible = ObjectVisibilityManager::isVisible($contentMainNode->attribute('contentobject_id'), $cluster);

            $this->addValueToDoc( $docList, 'attr_is_invisible_' . $cluster . '_b', !$isVisible );

            if (!isset(self::$_applicationIdentifierToId[$applicationIdentifier]))
                self::$_applicationIdentifierToId[$applicationIdentifier] = $applicationLocalized->applicationObject()->attribute ('id');

            $publisherFolder              = $applicationLocalized->getPublisherFolderFromPath($publisherFolderInfos['path']);
            $publisherLanguages           = $publisherFolder->getLanguages();
            $publisherAndArticleLanguages = array_intersect($publisherLanguages, $articleLanguageArray);

            if ( count($publisherAndArticleLanguages) == 0 )
                continue;

            $primaryLanguage = reset($publisherAndArticleLanguages);
            $contentMainNode->setCurrentLanguage($primaryLanguage);

            // publisher folder languages
            $languageKey       = 'subattr_language_' . $cluster . '____s';
            $formatedLanguages = array_map(
                array('kezfSolrArticleIndex', 'languageCode') ,
                $publisherAndArticleLanguages
            );

            $indexLanguages = array_unique( $formatedLanguages );

            $this->addValueToDoc( $docList, $languageKey, $indexLanguages, true, false );
            
            // Meck manual sections
            if( $applicationIdentifier == MerckManualShowcase::mainApplicationIdentifier() )
                $isMerckManualShowcase = true;

            // url computation
            /* @var eZContentObjectAttribute[] $dataMap */
            $dataMap = $contentMainNode->dataMap();

            ClusterTool::setCurrentCluster( $cluster );

            if( $applicationIdentifier == MerckManualShowcase::mainApplicationIdentifier() )
            {
                $urlContent = preg_replace(
                    '#^([^/]+/){2}#',
                    '',
                    MerckManualFunctionCollection::getMerckManualNodeUrl(
                        $applicationIdentifier,
                        $contentMainNode,
                        $primaryLanguage
                    )
                );
            }
            else
                $urlContent = preg_replace( '#^([^/]+/){2}#', '', $contentMainNode->urlAlias() );

            $this->addValueToDoc( $docList, 'attr_' . $cluster . '_url_s', $urlContent);

            $hasImage = array();

            for ( $mediaCase = 0; $mediaCase<=2; $mediaCase++ )
            {
                $hasImage[$mediaCase] = NodeOperatorHelper::hasImageArticle($contentMainNode, $mediaCase);
            }

            self::addValueToDoc( $docList, 'attr_has_image_' . $cluster . '_bst', base64_encode(json_encode($hasImage)) );

            $db = MMDB::instance();

            // index rating
            $row = $db->arrayQuery(sprintf("SELECT * FROM mm_rating_remote WHERE cluster_identifier = '%s' AND remote_id = '%s'", $cluster, $contentObject->remoteID()));
            if(count($row) && $row[0]["counter"] > 5 )
            {
                self::addValueToDoc( $docList, 'attr_content_rating_'.$cluster.'_f', $row[0]["total"]/$row[0]["counter"] );
                //update to_reindex
                $db->query(sprintf("UPDATE mm_rating_remote SET to_reindex=0 WHERE cluster_identifier = '%s' AND remote_id = '%s'", $cluster, $contentObject->remoteID()));
            }

            // index views
            $row = $db->arrayQuery(sprintf("SELECT * FROM mm_readcount_remote WHERE cluster_identifier = '%s' AND remote_id = '%s'", $cluster, $contentObject->remoteID()));
            if(count($row) && $row[0]["count"] > 0 )
            {
                self::addValueToDoc( $docList, 'attr_view_counter_'.$cluster.'_i', $row[0]["count"] );
                //update to_reindex
                $db->query(sprintf("UPDATE mm_readcount_remote SET to_reindex=0 WHERE cluster_identifier = '%s' AND remote_id = '%s'", $cluster, $contentObject->remoteID()));
            }

            if( $dataMap && $dataMap['media_content']->hasContent() )
            {
                $mediaContent      = $dataMap['media_content']->content();
                $mediaRelationList = $mediaContent['relation_list'];
                $entries           = array();
                $firstLink         = true;
                $totalQuizzes      = 0;

                foreach ( $mediaRelationList as $mediaRelation )
                {
                    $mediaObjectId = $mediaRelation['contentobject_id'];
                    $mediaClass = $mediaRelation['contentclass_identifier'];

                    /*******************************************************************************
                     * TODO : Adapt after PF Refactor
                     *******************************************************************************/
                    if ( !in_array($mediaClass, array('image', 'quiz', 'link')) )
                        continue;

                    
                    if ( $mediaClass === 'image' )
                    {
                        if ( count( $entries ) >= 3 )
                            continue;

                        // Language is DEPRECATED, Fake Language instead
                        $entries[] = $mediaObjectId . ";dep-DP";
                        /*******************************************************************************
                         * TODO : End : Adapt after PF Refactor
                         *******************************************************************************/
                    }
                    elseif ( ( $mediaClass === 'link' && $firstLink ) || $mediaClass === 'quiz' )
                    {
                        $mediaObject = eZContentObject::fetch( $mediaObjectId );

                        if ( !$mediaObject )
                            continue;

                        /* @var eZContentObjectAttribute[] $mediaDatamap */
                        $mediaDatamap = $mediaObject->dataMap();

                        if ( !is_array($mediaDatamap) )
                            continue;

                        if ( $mediaClass === 'link' )
                        {
                            if (!$mediaDatamap['url']->hasContent())
                                continue;

                            $firstLink = false;

                            self::addValueToDoc( $docList, 'attr_media_content_link_' . $cluster . '____ms', $mediaDatamap['url']->content(), false );
                        }
                        elseif ( $mediaClass === 'quiz' )
                        {
                            if ( $mediaDatamap['replies']->hasContent() )
                            {
                                $quizReplies = $mediaDatamap['replies']->content();
                                $quizReplies = $quizReplies->attribute('columns');
                                $quizReplies = $quizReplies['sequential'][1]['rows'];

                                if ( count($quizReplies) > 0 )
                                    self::addValueToDoc( $docList, 'attr_media_content_quiz_replies_' . $cluster . '____ms', $quizReplies, true);
                            }

                            if ( !empty($mediaDatamap['question']->DataText) )
                            {
                                self::addValueToDoc( $docList, 'attr_media_content_quiz_question_' . $cluster . '_ms', trim(strip_tags($mediaDatamap['question']->DataText)), false );
                            }

                            if ( !$mediaDatamap['points']->hasContent() )
                                continue;

                            $totalQuizzes+= $mediaDatamap['points']->content();
                        }
                    }
                }

                $withMediaDuration    = true;
                $typeMedias           = NodeOperatorHelper::getPictosMedia( $contentMainNode, $withMediaDuration );
                $typeMediasSerialized = base64_encode( json_encode($typeMedias) );

                // getPictosMedia as solr field
                self::addValueToDoc( $docList, 'attr_media_content_types_' . $cluster . '_bst', $typeMediasSerialized, false );

                // getMediaCount as solr field
                $mediaCount = NodeOperatorHelper::getMediaCount($contentMainNode);
                self::addValueToDoc( $docList, 'attr_media_content_count_' . $cluster . '_i', $mediaCount, false );

                // Used only for Quizz
                if ( $totalQuizzes > 0 )
                    self::addValueToDoc( $docList, 'attr_media_content_quiz_points_' . $cluster . '_i', $totalQuizzes, false );
            }
            
            unset($isHidden);
        }

        ClusterTool::resetCurrentCluster();

        $concernedNode = $contentMainNode;
        $concernedNode->setCurrentLanguage($articleLanguageArray[0]);

        if ( $contentMainNode->attribute('depth') > 4 )
        {
            $concernedNode = $contentMainNode->fetchParent();
            $concernedNode->setCurrentLanguage($articleLanguageArray[0]);
        }

        /* @type $concernedDM eZContentObjectAttribute[] */
        $concernedDM = $concernedNode->dataMap();
        $tags        = $concernedDM['tags'];

        $MerckManualAboutSectionId = eZIni::instance('merck.ini')->variable('MerckManualAboutSettings', 'SectionSourceId');
        $taxonomiesAttribute       = $concernedDM['serialized_taxonomies'];

        if( $taxonomiesAttribute instanceof eZContentObjectAttribute && $taxonomiesAttribute->hasContent() )
        {
            $taxonomies = $taxonomiesAttribute->content();

            foreach( array_keys($publisherFolderRelations['clusters']) as $cluster )
            {
                self::addValueToDoc(
                    $docList,
                    "attr_exclude_from_search_{$cluster}_b",
                    $MerckManualAboutSectionId && in_array($MerckManualAboutSectionId, $taxonomies['section']),
                    false
                );
            }
        }

        if( $tags instanceof eZContentObjectAttribute && $tags->hasContent() )
            self::addValueToDoc( $docList, 'subattr_tags____ms', explode("|", $tags->content()) );

        if ( $isMerckManualShowcase )
            $this->processSpecificMerckManual($docList, $concernedNode, $concernedDM, $publisherFolderRelations);

        foreach ( $publisherFolderRelations['clusters'] as $cluster => $applications )
        {
            ClusterTool::setCurrentCluster( $cluster );

            foreach( $applications as $key => $applicationIdentifier )
            {
                if ( !isset(self::$_applicationIdentifierToId[$applicationIdentifier]) )
                {
                    $applicationLocalized = CacheApplicationTool::buildLocalizedApplicationByIdentifier( $applicationIdentifier );

                    if( !($applicationLocalized instanceof ApplicationLocalized) )
                    {
                        eZDebug::writeError(
                            sprintf('Cluster: %s; Identifier: %s; ObjectId: %s', $cluster, $applicationIdentifier, $contentObject->attribute('id') ),
                            'Error getting application localized' );
                        unset( $publisherFolderRelations['clusters'][$cluster][$key] );
                    }
                    else
                        self::$_applicationIdentifierToId[$applicationIdentifier] = $applicationLocalized->applicationObject()->attribute('id');
                }
            }
        }

        ClusterTool::resetCurrentCluster();
        
        $applicationIds = array();

        foreach ( $publisherFolderRelations['clusters'] as $cluster => $applications )
            foreach( $applications as $applicationIdentifier )
                $applicationIds[] = self::$_applicationIdentifierToId[$applicationIdentifier];

        $uniqueApplicationIds = array_unique($applicationIds);

        foreach( $docList as $languageCode => $doc )
        {
            $dataMap               = $contentObject->fetchDataMap(false, $languageCode);
            $headline              = $dataMap['headline']->content();
            $headlineLowerCase     = mb_strtolower( StringTool::removeAccents($headline, 'utf-8', false), 'utf-8' );
            $unaccentedFirstLetter = mb_substr($headlineLowerCase, 0, 1, 'utf-8');

            $doc->addField( 'attr_headline_first_letter_lc_s', $unaccentedFirstLetter );
            $doc->addField( 'attr_headline_lc_s', $headlineLowerCase );

            foreach( $uniqueApplicationIds as $id )
            {
                $doc->addField( 'subattr_local_application___source_id____s', $id );
            }

            foreach( $publisherFolderRelations['clusters'] as $cluster => $applications )
            {
                foreach( $applications as $applicationIdentifier )
                {
                    $doc->addField('subattr_local_application___source_mixed____s', $cluster . '##unused##' . self::$_applicationIdentifierToId[$applicationIdentifier]);
                }
            }
        }
    }