page_tag_listing.inc

<?php
require_once SQ_PACKAGES_PATH.'/cms/page_templates/page_asset_listing/page_asset_listing.inc';

class Page_Tag_Listing extends Page_Asset_Listing
{

    function __construct($assetid=0)
    {
        parent::__construct($assetid);

    }//end constructor


    public function create(Array &$link)
    {
        $this->setAttrValue('types', Array('thesaurus_term' => '1'));
        return parent::create($link);

    }//end constructor


    public function getAssetList()
    {
        $this->_tmp['tag_freq'] = Array();

        $assets_to_list = Array();

        // get all the children
        $min_depth = $this->attr('min_depth');
        if ($min_depth == '') $min_depth = NULL;
        $max_depth = $this->attr('max_depth');
        if ($max_depth == '') $max_depth = NULL;

        $query_links = '';
        $bind_vars = Array();

        $root_asset_ids = $this->getRootNodes();
        
        foreach ($root_asset_ids as $root_asset_id) {
            $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($root_asset_id);

            // must have read and effective access on the children
            $query_links = $GLOBALS['SQ_SYSTEM']->am->generateGetChildrenQuery($asset, '', FALSE, NULL, NULL, SQ_PERMISSION_READ, TRUE, TRUE, $min_depth, $max_depth, TRUE, NULL);
            // ok, confession time: this is not nice, we cover up a bug in generateGetChildrenQuery() which adds a random AND at the end of the weher clause
            // need to be fixed properly later
            $query_links['sql_array']['where'] = preg_replace('/AND\s*$/', '', $query_links['sql_array']['where']);
            $rows = array();

            $bind_vars = $query_links['bind_vars'];

            $query_links['sql_array']['select'] = '(SELECT DISTINCT l.minorid ';

            // remove shadow children from this search as the query would be too complex and slower         
            $query_links['sql_array']['union_select'] = '';
            $query_links['sql_array']['union_from'] = '';
            $query_links['sql_array']['union_where'] = '';
            
            if (isset($bind_vars['gc_union_majorid'])) {
                unset($bind_vars['gc_union_majorid']);
            }

            $query_links = implode(' ', $query_links['sql_array']);
            
            // no support for multiple root nodes; only the first one is processed
            break;
        }

        // thesaurus filtering
        $thesaurus_filters = $this->_getThesaurusFilters();
        
        $thesaurus_filter_clause = '';
        if (!empty($thesaurus_filters)) {
            // assume there is only filtering thesaurus
            $thesaurus_filter_clause = ' AND (te.thesid = :thesaurusid) ';
            $bind_vars['thesaurusid'] = $thesaurus_filters[0];
        }

        // include root node is required
        $where_root_node = '';
        if (!$min_depth) {
            $where_root_node = ' OR (sl2.majorid = :root_nodeid) ';
            $bind_vars['root_nodeid'] = $root_asset_ids[0];
        }

        // build and execute the query
        $query = '
                    SELECT
                        sl2.minorid,
                        count(sl2.minorid) as score
                    FROM
                        sq_shdw_ast_lnk sl2
                        JOIN sq_thes_term te
                            ON (te.thesid || \':\' || te.termid)= sl2.minorid
                    WHERE
                        (sl2.majorid IN ('.$query_links.')
                        '.$where_root_node.' )
                        '.$thesaurus_filter_clause.'
                    GROUP BY
                        sl2.minorid
                    ORDER BY
                        score DESC
                ';

        try  {          
            $query = MatrixDAL::preparePdoQuery($query);
            foreach ($bind_vars as $bind_var => $bind_value) {
                MatrixDAL::bindValueToPdo($query, $bind_var, $bind_value);
            }
            $rows = MatrixDAL::executePdoAll($query);
        } catch (Exception $e) {
            throw new Exception('Unable to get children for asset: '.join(', ', $root_asset_ids).' due to database error: '.$e->getMessage());
        }
        // scoop the result
        // TODO: limit the select instead, that would be faster.
        $query_limit = $this->_getQueryLimit();
        if ($query_limit != -1) {
            $rows = array_slice($rows, 0, $query_limit);
        }

        // store the scores
        foreach ($rows as $row) {
            // save the weight of all the tagids
            $this->_tmp['tag_freq'][$row['minorid']] = $row['score'];
            $assets_to_list[$row['minorid']] = Array(Array('type_code' => 'thesaurus_term'));
        }
        
        return $assets_to_list;

    }//end getAssetList()


    protected function _getQueryLimit()
    {
        $ret = -1;

        if ($this->attr('first_page_only')) {
            $si = $this->getSortInfo();
            if (empty($si['type'])) {
                $ret = $this->attr('num_per_page');
                if ($ret == 0) $ret = -1;
            }
        }

        return $ret;

    }//end _getQueryLimit()


    protected function _getThesaurusFilters()
    {
        $ret = Array();

        $links = $GLOBALS['SQ_SYSTEM']->am->getLinks($this->id, SQ_LINK_NOTICE, 'thesaurus', FALSE);

        foreach ($links as $link) {
            $ret[] = $link['minorid'];
        }

        return $ret;

    }//end _getThesaurusFilters()


    public function _getShadowAssetKeywordReplacements($assetid, $bc_keywords)
    {
        $keywords = Array();
        $shadow_asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($assetid);

        foreach ($bc_keywords as $key => $keyword) {
            if ($keyword == 'tag_count') {
                $keywords[$keyword] = array_get_index($this->_tmp['tag_freq'], $assetid, 1);
            } else if ($keyword == 'tag_size') {
                $keywords[$keyword] = ceil(array_get_index($this->_tmp['tag_freq'], $assetid, 1) / $this->_getTagMaxCount() * $this->Attr('tag_max_size'));
            } else {
                $keywords[$keyword] = $shadow_asset->getKeywordReplacement($keyword);
            }
        }
        return $keywords;

    }//end _getShadowAssetKeywordReplacements()


    protected function _getTagMaxCount()
    {
        $ret = 1;

        if (count($this->_tmp['tag_freq'])) {
            $ret = array_values($this->_tmp['tag_freq']);
            $ret = $ret[0];
        }

        return $ret;

    }//end _getTagMaxCount()


    public function _getAdditionalSingleAssetFormatKeywords()
    {
        $ret = parent::_getAdditionalSingleAssetFormatKeywords();

        $ret['tag_count'] = translate('page_tag_listing_keyword_tag_count');
        $ret['tag_size'] = translate('page_tag_listing_keyword_tag_size');

        return $ret;

    }//end _getAdditionalSingleAssetFormatKeywords()


    function _getCacheKey()
    {
        $cache_key = parent::_getCacheKey();

        // add the thesaurusid we use for filtering
        $cache_key .= ';THES='.join(',', $this->_getThesaurusFilters());
        // add the maximum tag size
        $cache_key .= ';MTS='.$this->Attr('tag_max_size');
        // add the "first page only"
        $cache_key .= ';FPO='.($this->attr('first_page_only') ? '1' : '0');

        return $cache_key;

    }//end _getCacheKey()


}//end class

?>