tag_manager.inc

<?php
require_once SQ_INCLUDE_PATH.'/asset.inc';


class Tag_Manager extends Asset
{


    function Tag_Manager($assetid=0)
    {
        $this->_ser_attrs = TRUE;
        $this->Asset($assetid);

    }//end constructor


    function create(&$link)
    {
        require_once SQ_CORE_PACKAGE_PATH.'/system/system_asset_fns.inc';
        if (!system_asset_fns_create_pre_check($this)) {
            return FALSE;
        }

        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
        $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');

        if ($linkid = parent::create($link)) {
            if (!system_asset_fns_create_cleanup($this)) {
                $linkid = FALSE;
            }
        }

        if ($linkid) {
            $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        } else {
            $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
        }

        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
        return $linkid;

    }//end create()


    function _getName($short_name=FALSE)
    {
        return $GLOBALS['SQ_SYSTEM']->am->getTypeInfo($this->type(), 'name');

    }//end _getName()


    function canClone()
    {
        return FALSE;

    }//end canClone()


    function getTagLinks($assetid, $thesaurus_filter_ids=Array())
    {

        $tag_links = Array();
        $notice_links = $GLOBALS['SQ_SYSTEM']->am->getLinks($assetid, SQ_LINK_NOTICE);
        foreach ($notice_links as $notice_link) {
            $id_parts = explode(':', $notice_link['minorid']);
            if (!empty($id_parts[1])) {
                $thes_id = $id_parts[0];
                if (empty($thesaurus_filter_ids) || in_array($thes_id, $thesaurus_filter_ids)) {
                    $thes = $GLOBALS['SQ_SYSTEM']->am->getAsset($thes_id, 'thesaurus', TRUE);
                    if (!is_null($thes)) {
                        $tag_term_exists = $GLOBALS['SQ_SYSTEM']->am->getAsset($notice_link['minorid'], 'thesaurus_term', FALSE);
                        if (!is_null($tag_term_exists)) {
                            $tag_links[] = $notice_link;
                        }
                    }
                }
            }
        }

        return $tag_links;

    }//end getTagLinks()


    function isAssetTaggedWith($assetid, $tagids, $strict=FALSE)
    {
        if (!is_array($tagids)) $tagids = Array($tagids);

        $tag_link = $this->getAssetTagLinks($assetid, $tagids);
        if (!$strict) {
            return !empty($tag_link);
        } else {
            $array_keys = array_keys($tag_link);
            $result = array_diff($tagids, $array_keys);
            return empty($result);
        }

    }//end isAssetTaggedWith()


    function getAssetTagLinks($assetid, $tagids)
    {
        $tag_links = $GLOBALS['SQ_SYSTEM']->am->getLinkByAsset($assetid, $tagids, SQ_LINK_NOTICE);
        if (isset($tag_links['minorid'])) {
            $tag_links = Array($tag_links);
        }

        $links = Array();

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

        return $links;

    }//end getAssetTagLinks()


    function getAssetLinksByTag($tagid)
    {
        // get a list of links to assets from these tags

        if (!is_array($tagid)) {
            $tagids = Array($tagid);
        } else {
            $tagids = $tagid;
        }

        $links = Array();
        $asset_links = $GLOBALS['SQ_SYSTEM']->am->getLinks($tagids, SQ_LINK_NOTICE, NULL, FALSE, 'minor');

        return $asset_links;

    }//end getAssetLinksByTag()


    function getRelatedAssets($relator_id, $thesaurus_filter_ids=Array())
    {
        // Get the tag links for all the relators then all the asset links these tags have.
        // we need to iterate through the relator's tag links to build the array for getting the tags' assets, so
        // build another array of link values.

        if (!is_array($relator_id)) {
            $relator_ids = Array($relator_id);
        } else {
            $relator_ids = $relator_id;
        }


        $relator_weightings = Array();
        foreach ($relator_ids as $relator_id) {
            $tag_links = $this->getTagLinks($relator_id, $thesaurus_filter_ids);
            foreach ($tag_links as $tag_link) {
                $tag_id =  $tag_link['minorid'];
                $current_value = array_get_index($relator_weightings, $tag_id, 0);
                $relator_weightings[$tag_id] = $current_value + $tag_link['value'];
            }
        }


        // related_asset_links are links from the relatees to the relator's tags
        $all_related_asset_links = $this->getAssetLinksByTag(array_keys($relator_weightings));


        $related_ids = Array();
        // loop through relateds and check relators for each
        foreach ($all_related_asset_links as $tag_id => $related_asset_links) {
            $multiplier = array_get_index($relator_weightings, $tag_id);

            if (is_null($multiplier)) continue;

            foreach ($related_asset_links as $one_related_link) {
                $related_assetid = $one_related_link['majorid'];
                $current_value = array_get_index($related_ids, $related_assetid, 0);
                $related_ids[$related_assetid] = $current_value + $multiplier * $one_related_link['value'];
            }
        }

        arsort($related_ids);


        return $related_ids;

    }//end getRelatedAssets()


    function isSetTaggingScreen($assetid)
    {
        $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset((int) $assetid);
        if (is_null($asset)) return TRUE;
        $edit_fns = $asset->getEditFns();
        return isset($edit_fns->static_screens['tagging']);

    }//end isSetTaggingScreen()
    
    
    function setTag($assetid, $tagids, $weight)
    {
        $has_error = FALSE;
        
        if ($this->isSetTaggingScreen($assetid)) {
            
            if (!is_array($tagids)) $tagids = Array($tagids);
    
            $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($assetid);
            if (is_null($asset)) return 0;
    
            
            foreach ($tagids as $tagid) {
                if (!$this->isFromTaggingThesaurus($tagid)) {
                    // this tag is not in the required thesaurus
                    trigger_localised_error('CORE0274', E_USER_WARNING);
                    $has_error = TRUE;
                    continue;
                }
    
                $new_tag_object = $GLOBALS['SQ_SYSTEM']->am->getAsset($tagid);
                if (is_null($new_tag_object)) {
                    trigger_localised_error('SYS0087', E_USER_WARNING, $tagid);
                    $has_error = TRUE;
                    continue;
                }
    
                // see if the asset is already tagged with this tag
                $tag_links = $this->getTagLinks($assetid);
                $already_tagged = FALSE;
                foreach ($tag_links as $link) {
                    if ($tagid == $link['minorid']) {
                        $already_tagged = TRUE;
                        if ($weight == $link['value']) {
                            // already tagged with the same weighting
                            continue;
                        } else {
                            // already tagged, but with a different weighting; scream and shout
                            trigger_localised_error('CORE0275', E_USER_WARNING, $assetid, $weight);
                            $has_error = TRUE;
                            break;
                        }
                    }
                }//end foreach existing tag link
                
                if (!$already_tagged) {
                    if (!$GLOBALS['SQ_SYSTEM']->am->createAssetLink($asset, $new_tag_object, SQ_LINK_NOTICE, $weight)) {
                        $has_error = TRUE;
                    }
                }
    
            }//end foreach tag id

        }
        
        return ($has_error) ? 0 : 1;

    }//end setTag()


    function deleteTag($assetid, $tagids)
    {
        $has_error = FALSE;
        
        if ($this->isSetTaggingScreen($assetid)) {
        
            if (!is_array($tagids)) $tagids = Array($tagids);
        
            foreach ($tagids as $tag) {
                
                $link = $GLOBALS['SQ_SYSTEM']->am->getLinkByAsset($assetid, $tag, SQ_LINK_NOTICE);
                if (empty($link)) {
                    trigger_localised_error('CORE0277', E_USER_WARNING, $tag, $assetid);
                    $has_error = TRUE;
                    continue;
                }
                if (!$GLOBALS['SQ_SYSTEM']->am->deleteAssetLink($link['linkid'])) {
                    trigger_localised_error('CORE0278', E_USER_WARNING, $tag, $assetid, $link['linkid']);
                    $has_error = TRUE;
                }
            }
        }
        
        return ($has_error) ? 0 : 1;

    }//end deleteTag()


    function setTagByName($assetid, $tag, $weight)
    {
        $thes  = $this->getTagThesaurus();
        $tagid =  $thes->getTermIdByName($tag);
        return $this->setTag($assetid, $tagid, $weight);

    }//end setTagByName()


    function &getTagThesaurus()
    {
        $thes = NULL;
        if ($this->attr('thesaurus')) {
            $thes = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->attr('thesaurus'));
        }
        return $thes;

    }//end getTagThesaurus()


    function setTagWeight($linkid, $weight)
    {
        $success = $GLOBALS['SQ_SYSTEM']->am->updateLink($linkid, SQ_LINK_NOTICE, $weight);
        return $success;

    }//end setTagWeight()


    function isFromTaggingThesaurus($tagid)
    {
        // are tags restricted to one thesaurus asset?
        if ($this->isTagSourceRestricted()) {
            $id_parts = explode(':', $tagid);
            if ($this->attr('thesaurus') != $id_parts[0]) {
                // this tag is not in the required thesaurus
                return FALSE;
            }
        }

        return TRUE;

    }//end isFromTaggingThesaurus()


    function isTagSourceRestricted()
    {
        return $this->attr('restrict_tag_source');

    }//end isTagSourceRestricted()


}//end class
?>