thesaurus.inc

<?php
require_once SQ_CORE_PACKAGE_PATH.'/page/page.inc';
require_once SQ_FUDGE_PATH.'/general/text.inc';
require_once SQ_FUDGE_PATH.'/general/file_system.inc';
require_once SQ_CORE_PACKAGE_PATH.'/interfaces/bridge/bridge.inc';

class Thesaurus extends Asset implements Bridge
{


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

    }//end constructor


    function delete($release_lock)
    {
        if (parent::delete($release_lock)) {
            $this->_deleteStoredContents();
            return TRUE;
        }

        return FALSE;

    }//end delete()


    function _createAdditional(&$link)
    {
        if (!parent::_createAdditional($link)) return FALSE;
        return create_directory($this->data_path);

    }//end _createAdditional()


//--        BUILT-IN RELATION SUPPORT       --//


    function getAbbreviations()
    {
        $abbreviation_attr = $this->getAttribute('abbreviation_rel');
        $abbreviation_rel = $abbreviation_attr->value;
        if (empty($abbreviation_rel)) {
            $abbreviation_rel = NULL;
        }

        $abbr_rows = $this->getRelatedTerms($abbreviation_rel);

        if (is_null($abbr_rows)) return Array();

        $result = Array();
        foreach ($abbr_rows as $abbr) {
            $result[$abbr['major']] = $abbr['minor'];
        }

        return $result;

    }//end getAbbreviations()


    function getSynonymsForTerm($term)
    {
        $termid = $this->getTermIdByName($term);

        if (empty($termid)) return Array();

        $synonym_attr = $this->getAttribute('synonym_rel');
        $synonym_rel = $synonym_attr->value;
        if (empty($synonym_rel)) $synonym_rel = NULL;

        $synonyms = $this->getChildTerms($termid, $synonym_rel);
        $result = Array();

        if (!empty($synonyms)) {
            foreach ($synonyms as $synonym) {
                $result[$synonym['term']] = $synonym['term'];
            }
        }

        return $result;

    }//end getSynonymsForTerm()


//--        CORE THESAURUS RELATIONAL ENGINE        --//


    function getChildTerms($termid, $relid=NULL)
    {

        $limit_relation = TRUE;
        if (is_null($relid)) $limit_relation = FALSE;

        $db = MatrixDAL::getDb();

        $sql = '
            SELECT
                linkid, term, termid, relid
            FROM
                sq_thes_term term
                INNER JOIN sq_thes_lnk link ON term.termid = link.minor
            WHERE
                term.thesid = :assetid_1
                AND
                link.thesid = :assetid_2
                AND
                major = :termid
        ';

        if ($limit_relation) {
            $sql .= '
                AND
                relid = :relid
            ';
        }

        $sql .= '
            ORDER BY
                term
        ';

        $query = MatrixDAL::preparePdoQuery($sql);
        MatrixDAL::bindValueToPdo($query, 'assetid_1', $this->id);
        MatrixDAL::bindValueToPdo($query, 'assetid_2', $this->id);
        MatrixDAL::bindValueToPdo($query, 'termid', $termid);
        if ($limit_relation) {
            MatrixDAL::bindValueToPdo($query, 'relid', $relid);
        }//end if

        try {
            $result = MatrixDAL::executePdoAll($query);
        } catch (Exception $e) {
            throw new Exception('Unable to get thesaurus child terms due to database error: '. $e->getMessage());
        }//end

        return $result;

    }//end getChildTerms()


    function countChildTerms($termid)
    {

        $db = MatrixDAL::getDb();

        $bind_vars = Array (
                        'assetid'   => $this->id,
                        'termid'    => $termid,
                    );

        try {
            $result = MatrixDAL::executeOne('thesaurus', 'countChildTerms', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to count thesaurus child terms due to database error: '. $e->getMessage());
        }//end

        return $result;

    }//end countChildTerms()


    function countTermLinks()
    {

        $db = MatrixDAL::getDb();

        $bind_vars['assetid'] = $this->id;

        try {
            $result = MatrixDAL::executeOne('thesaurus', 'countTermLinks', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to count thesaurus term links due to database error: '. $e->getMessage());
        }//end

        return $result;

    }//end countTermLinks()


    function countTerms()
    {

        $db = MatrixDAL::getDb();

        $bind_vars['assetid'] = $this->id;

        try {
            $result = MatrixDAL::executeOne('thesaurus', 'countTerms', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to count thesaurus terms due to database error: '. $e->getMessage());
        }//end


        return $result;

    }//end countTerms()


    function countParentTerms($termid)
    {

        $db = MatrixDAL::getDb();

        $bind_vars = Array (
                        'assetid'   => $this->id,
                        'termid'    => $termid,
                    );

        try {
            $result = MatrixDAL::executeOne('thesaurus', 'countParentTerms', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to count thesaurus parent terms due to database error: '. $e->getMessage());
        }//end


        return $result;

    }//end countParentTerms()


    function getChildRelationsForTerm($termid)
    {

        $db = MatrixDAL::getDb();

        $bind_vars = Array (
                        'assetid'   => $this->id,
                        'termid'    => $termid,
                    );

        try {
            $results = MatrixDAL::executeAssoc('thesaurus', 'getChildRelationsForTerm', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to get child relations for term due to database error: '. $e->getMessage());
        }//end
        if (!empty($results)) {
            $new_res = Array();
            foreach ($results as $result) {
                $new_res[$result['relid']] = $result['relation'];
            }//end foreach
            $results = $new_res;
        }//end if

        return $results;

    }//end getChildRelationsForTerm()


    function getParentRelationsForTerm($termid)
    {

        if (!isset($termid)) return NULL;

        $db = MatrixDAL::getDb();

        $bind_vars = Array (
                        'assetid'   => $this->id,
                        'termid'    => $termid,
                    );

        try {
            $result = MatrixDAL::executeAssoc('thesaurus', 'getParentRelationsForTerm', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to get parent relations for term due to database error: '. $e->getMessage());
        }//end

        return $result;

    }//end getParentRelationsForTerm()


    function getAllTerms()
    {
        $bind_vars  = Array();
        $bind_vars['assetid'] = $this->id;

        try {
            $result = MatrixDAL::executeAll('thesaurus', 'getAllTerms', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to get a list of all thesaurus terms due to database error: '. $e->getMessage());
        }//end

        return $result;

    }//end getAllTerms()


    function getParentTerms($termid, $relid=NULL)
    {

        $limit_relation = TRUE;
        if (is_null($relid)) $limit_relation = FALSE;

        $db = MatrixDAL::getDb();

        $sql = '
            SELECT
                linkid, term, termid, relid
            FROM
                sq_thes_term term
                INNER JOIN sq_thes_lnk link ON term.termid = link.major
            WHERE
                term.thesid = :thesid_1
                AND
                link.thesid = :thesid_2
                AND
                minor = :termid
        ';

        if ($limit_relation) {
            $sql .= '
                AND
                relid = :relid
            ';
        }

        $sql .= '
            ORDER BY
                term
        ';


        $query = MatrixDAL::preparePdoQuery($sql);
        MatrixDAL::bindValueToPdo($query, 'thesid_1', $this->id);
        MatrixDAL::bindValueToPdo($query, 'thesid_2', $this->id);
        MatrixDAL::bindValueToPdo($query, 'termid', $termid);
        if ($limit_relation) {
            MatrixDAL::bindValueToPdo($query, 'relid', $relid);
        }//end if

        try {
            $result = MatrixDAL::executePdoAll($query);
        } catch (Exception $e) {
            throw new Exception('Unable to get thesaurus parent terms due to database error: '. $e->getMessage());
        }//end

        return $result;

    }//end getParentTerms()


    function getRelatedTerms($relation_id='')
    {
        if (empty($relation_id)) return NULL;

        $db = MatrixDAL::getDb();

        $sql = '
            SELECT
                major.term      as major,
                major.termid    as majorid,
                minor.term      as minor,
                minor.termid    as minorid
            FROM
                sq_thes_term major
                INNER JOIN sq_thes_lnk link ON major.termid = link.major
                INNER JOIN sq_thes_term minor ON minor.termid = link.minor
            WHERE
                link.relid = :relid
                AND
                major.thesid = :major_thesid
                AND
                minor.thesid = :minor_thesid
                AND
                link.thesid = :link_thesid
        ';

        $query = MatrixDAL::preparePdoQuery($sql);
        MatrixDAL::bindValueToPdo($query, 'relid', $relation_id);
        MatrixDAL::bindValueToPdo($query, 'major_thesid', $this->id);
        MatrixDAL::bindValueToPdo($query, 'minor_thesid', $this->id);
        MatrixDAL::bindValueToPdo($query, 'link_thesid',  $this->id);
        $result = MatrixDAL::executePdoAll($query);

        return $result;

    }//end getRelatedTerms()


    function _addTerm($term)
    {
        if (!isset($term) || $term == '') {
            return NULL;
        }
        
        // remove leading and trailing spaces   
        $term = trim($term);

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

        $termid = MatrixDAL::executeOne('core', 'seqNextVal', Array('seqName' => 'sq_thes_term_seq'));
        $bind_vars = Array (
                        'thesid'    => $this->id,
                        'term'      => $term,
                        'termid'    => $termid,
                    );

        try {
            $result = MatrixDAL::executeQuery('thesaurus', 'insertTerm', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to insert a thesaurus term due to database error: '. $e->getMessage());
        }//end

        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

        return $termid;

    }//end _addTerm()


    function addTerm($term)
    {
        $termid = $this->getTermIdByName($term);
        if (!is_null($termid)) return $termid;

        return $this->_addTerm($term);

    }//end addTerm()


    function addTermNote($termid, $note_name, $note_value)
    {
        // before adding the Term Note we need to check if the note hasnt been added
        // if the term note is already in the table we will throw an error
        $db = MatrixDAL::getDb();
        $sql = 'SELECT a.termid, a.name, a.value, a.thesid, b.term
                FROM sq_thes_term_note a, sq_thes_term b
                WHERE a.termid = '.MatrixDAL::quote($termid).' AND
                    a.name = '.MatrixDAL::quote($note_name).' AND
                    a.value = '.MatrixDAL::quote($note_value).' AND
                    a.thesid = '.MatrixDAL::quote($this->id).' AND
                    b.thesid = a.thesid AND b.termid = a.termid
                    ';
        $result = NULL;
            try {
            $query = MatrixDAL::preparePdoQuery($sql);
            $result = MatrixDAL::executePdoAssoc($query);
        } catch (Exception $e) {
            throw new Exception($e->getMessage());
        }

        if (!empty($result)) {
            // throw an error and return TRUE
            trigger_localised_error('CORE0282', E_USER_WARNING, $note_name.":".$note_value, $result[0]['term']);
            return TRUE;
        }

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


        $bind_vars = Array (
                        'thesid'    => $this->id,
                        'termid'    => $termid,
                        'name'      => $note_name,
                        'value'     => $note_value,
                    );

        try {
            $result = MatrixDAL::executeQuery('thesaurus', 'insertTermNote', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to insert a thesaurus term note due to database error: '. $e->getMessage());
        }//end

        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

        return TRUE;

    }//end addTermNote()


    function getTermNotes($termid)
    {

        $db = MatrixDAL::getDb();

        $bind_vars = Array (
                        'assetid'   => $this->id,
                        'termid'    => $termid,
                    );

        try {
            $result = MatrixDAL::executeAssoc('thesaurus', 'getTermNotes', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to get thesaurus term note due to database error: '. $e->getMessage());
        }//end

        return $result;

    }//end getTermNotes()


    function deleteTermNotes($termid)
    {
        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');

        $db = MatrixDAL::getDb();

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

        $bind_vars = Array (
                        'thesid'    => $this->id,
                        'termid'    => $termid,
                    );

        try {
            $result = MatrixDAL::executeQuery('thesaurus', 'deleteTermNotes', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to delete a thesaurus term note due to database error: '. $e->getMessage());
        }//end


        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

        return TRUE;

    }//end deleteTermNotes()


    function linkTerms($minorid, $majorid, $relid)
    {
        $term_linkid = $this->_linkTerms($minorid, $majorid, $relid);

        if (is_null($term_linkid)) {
            $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
            return NULL;
        }

        if ($this->attr('enforce_reflection')) {
            $ref_relid = $this->getReflectionForRelation($relid);
            if ($ref_relid) {
                $this->_linkTerms($majorid, $minorid, $ref_relid);
            }
        }

        return $term_linkid;

    }//end linkTerms()


    function _linkTerms($minorid, $majorid, $relation_id=NULL)
    {
        if (is_null($minorid) || is_null($majorid)) {
            return NULL;
        }

        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
        $db = MatrixDAL::getDb();

        $bind_vars = Array (
                        'thesid'    => $this->id,
                        'major'     => $majorid,
                        'minor'     => $minorid,
                        'relation'  => $relation_id,
                     );

        try {
            $result = MatrixDAL::executeOne('thesaurus', 'getLinkId', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to get thesaurus linkid due to database error: '. $e->getMessage());
        }//end


        // if the terms are already linked using this relation, just return the ID
        if (!empty($result)) return $result;

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

        // inserting a term link is the easiest thing ever
        try {
            $linkid = MatrixDAL::executeOne('core', 'seqNextVal', Array('seqName' => 'sq_thes_lnk_seq'));
            $bind_vars['linkid']    = $linkid;
            $result = MatrixDAL::executeQuery('thesaurus', 'insertLink', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to link a thesaurus term due to database error: '. $e->getMessage());
        }//end


        $em = $GLOBALS['SQ_SYSTEM']->getEventManager();
        $major = $this->getAsset($majorid);
        $em->broadcastEvent($major, 'CreateLink', Array());

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

    }//end _linkTerms()


    function updateTerm($termid, $name)
    {

        $term = $this->getTermById($termid);
        
        // remove leading and trailing spaces   
        $name = trim($name);

        // if nothing has changed, no need to do any work
        if ($term['term'] == $name) return TRUE;

        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
        $db = MatrixDAL::getDb();


        // if the new name is being used by another term, do not update
        // updating the name if it is used by another term is hard as we don't know what to do with the children
        // do we merge this term's children with the others' or do we only use our children or theirs?
        if ($this->isTerm($name, $termid)) {
            trigger_localised_error('CORE0239', E_USER_WARNING);
            return FALSE;
        }


        // if the term has only one parent and the name is not used anywhere else - it is safe to update it
        $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');
        // update the term itself

        $bind_vars = Array (
                        'assetid'   => $this->id,
                        'termid'    => $termid,
                        'name'      => $name,
                     );

        try {
            $result = MatrixDAL::executeQuery('thesaurus', 'updateTerm', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to update a thesaurus term due to database error: '. $e->getMessage());
        }//end


        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
        return TRUE;

    }//end updateTerm()


    function renameRelation($relation_id, $new_name)
    {
        if ($new_name == '') $new_name = NULL;

        // IMPORTANT: Ensure the new name is not already in use
        $relid = $this->getRelationIdByName($new_name);
        if (!is_null($relid)) return NULL;

        if (array_search($new_name, $this->getActiveRelations())!== FALSE) {
            // can't rename an existing relation
            $this->_tmp['error'][] = translate('thesaurus_new_relation_in_use');
            return FALSE;
        }

        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
        $db = MatrixDAL::getDb();
        $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');

        // Update relations

        $bind_vars = Array (
                        'assetid'   => $this->id,
                        'relid'     => $relation_id,
                        'relation'  => $new_name,
                     );

        try {
            $result = MatrixDAL::executeQuery('thesaurus', 'updateRelationName', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to update a thesaurus relation name due to database error: '. $e->getMessage());
        }//end

        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

        $this->markContentsChanged();
        return;

    }//end renameRelation()


    function getTermById($termid)
    {
        $db = MatrixDAL::getDb();

        $bind_vars = Array (
                        'assetid'   => $this->id,
                        'termid'    => $termid,
                    );

        try {
            $result = MatrixDAL::executeAll('thesaurus', 'getTermById', $bind_vars);
            if (!empty($result) && isset($result[0])) {
                $result = $result[0];
            }
        } catch (Exception $e) {
            throw new Exception('Unable to get a thesaurus term by id due to database error: '. $e->getMessage());
        }//end

        return $result;

    }//end getTermById()


    function getTermLinkById($linkid)
    {
        $db = MatrixDAL::getDb();

        $bind_vars = Array (
                        'assetid'   => $this->id,
                        'linkid'    => $linkid,
                     );

        try {
            $result = MatrixDAL::executeAll('thesaurus', 'getLinkById', $bind_vars);
            if (!empty($result) && isset($result[0])) {
                $result = $result[0];
            }
        } catch (Exception $e) {
            throw new Exception('Unable to get a thesaurus term link by id due to database error: '. $e->getMessage());
        }//end

        return $result;

    }//end getTermLinkById()


    function getRelationIdByName($name)
    {
        $db = MatrixDAL::getDb();

        $sql = '
            SELECT
                relid
            FROM
                sq_thes_rel
            WHERE
                relation '.(is_null($name)?'IS NULL':'= :name').'
                AND
                thesid = :assetid';

        $query = MatrixDAL::preparePdoQuery($sql);
        if (!is_null($name)) {
            MatrixDAL::bindValueToPdo($query, 'name', $name);
        }
        MatrixDAL::bindValueToPdo($query, 'assetid', $this->id);

        try {
            $result = MatrixDAL::executePdoOne($query);
        } catch (Exception $e) {
            throw new Exception('Unable to get thesaurus relation Id by name due to database error: '. $e->getMessage());
        }//end

        if (empty($result)) $result = NULL;

        return $result;

    }//end getRelationIdByName()


    function addRelation($name)
    {
        if ($name == '') $name = NULL;

        // IMPORTANT: Ensure the new name is not already in use
        $relid = $this->getRelationIdByName($name);
        if (!is_null($relid)) return $relid;

        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
        $db = MatrixDAL::getDb();

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

        $id = MatrixDAL::executeOne('core', 'seqNextVal', Array('seqName' => 'sq_thes_rel_seq'));
        $bind_vars = Array (
                        'thesid'    => $this->id,
                        'relation'  => $name,
                        'relid'     => $id,
                     );

        try {
            $result = MatrixDAL::executeQuery('thesaurus', 'insertRelation', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to add a thesaurus relation due to database error: '. $e->getMessage());
        }//end

        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

        return $id;

    }//end addRelation()


    function updateLinkRelation($linkid, $relid)
    {

        if (!isset($linkid) || !isset($relid)) {
            return FALSE;
        }

        $link_info = $this->getTermLinkById($linkid);
        $major = $link_info['major'];
        $minor = $link_info['minor'];
        $old_relid = $link_info['relid'];

        $this->deleteTermLink($linkid);
        $this->linkTerms($minor, $major, $relid);

        return TRUE;

    }//end updateLinkRelation()


    function getTermLinkByTermids($termid, $parentid, $relid=NULL)
    {

        $db = MatrixDAL::getDb();

        $bind_vars = Array (
                        'thesid'    => $this->id,
                        'relid'     => $relid,
                        'parentid'  => $parentid,
                        'termid'    => $termid,
                     );

        try {
            $result = MatrixDAL::executeAll('thesaurus', 'getTermLinkByTermIds', $bind_vars);
            if (!empty($result) && isset($result[0])) {
                $result = $result[0];
            }
        } catch (Exception $e) {
            throw new Exception('Unable to get a thesaurus term link by id due to database error: '. $e->getMessage());
        }//end

        return $result;

    }//end getTermLinkByTermids()


    function getTermIdByName($name)
    {
        $db = MatrixDAL::getDb();

        $name = strtolower($name);

        $sql = '
            SELECT
                termid
            FROM
                sq_thes_term
            WHERE
                lower(term) = :term
                AND
                thesid = :thesid
        ';

        try {
            $query = MatrixDAL::preparePdoQuery($sql);
            MatrixDAL::bindValueToPdo($query, 'term', $name);
            MatrixDAL::bindValueToPdo($query, 'thesid', $this->id);
            $result = MatrixDAL::executePdoOne($query);
        } catch (Exception $e) {
            throw new Exception('Unable to get thesaurus term id by name due to database error: '. $e->getMessage());
        }//end

        if (empty($result)) $result = NULL;

        return $result;

    }//end getTermIdByName()


    function getTermIdsByNames($names)
    {
        if (empty($names)) return Array();

        $db = MatrixDAL::getDb();

        $formatted_names = Array();
        foreach ($names as $name) {
            $formatted_names[] = strtolower($name);
        }

        $bind_vars = Array (
                        'names' => $formatted_names,
                        'theid' => $this->id,
                     );

        try {
            $result = MatrixDAL::executeAssoc('thesaurus', 'getTermIdByNames', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to get thesaurus term ids by names due to database error: '. $e->getMessage());
        }//end

        return $result;

    }//end getTermIdsByNames()


    function isTerm($term=NULL, $termid=0)
    {
        if (is_null($term)) return FALSE;

        $db = MAtrixDAL::getDb();

        $sql = '
            SELECT
                termid
            FROM
                sq_thes_term
            WHERE
                lower(term) = :term
                AND
                thesid = :thesid
        ';
        if ($termid != 0) {
            $sql .=     ' AND termid <> :termid';
        }

        $bind_vars = Array (
                        'term'  => strtolower($term),
                        'thesid' => $this->id,
                     );

        if ($termid != 0) {
            $bind_vars['termid'] = $termid;
        }

        try {
            $query  = MatrixDAL::preparePdoQuery($sql);
            MatrixDAL::bindValueToPdo($query, 'term', strtolower($term));
            MatrixDAL::bindValueToPdo($query, 'thesid', $this->id);
            if ($termid != 0) {
                MatrixDAL::bindValueToPdo($query, 'termid', $termid);
            }
            $result = MatrixDAL::executePdoOne($query);
        } catch (Exception $e) {
            throw new Exception('Unable to get thesaurus term id due to database error: '.$e->getMessage());
        }//end

        return !empty($result);

    }//end isTerm()


    function getActiveRelations()
    {
        $db = MatrixDAL::getDb();

        $bind_vars = Array (
                        'assetid' => $this->id,
                     );

        try {
            $results = MatrixDAL::executeAssoc('thesaurus', 'getActiveRelations', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to get thesaurus active relations due to database error: '. $e->getMessage());
        }//end

        if(!empty($results)) {
            $new_res = Array();
            foreach ($results as $result) {
                $new_res[$result['relid']] = $result['relation'];
            }//end foreach
            $results = $new_res;
        }//end if

        return $results;

    }//end getActiveRelations()


    function erase()
    {

        if (!$this->_deleteStoredContents()) return FALSE;

        $this->setAttrValue('relations', Array());
        $this->setAttrValue('reflections', Array());

        $this->markContentsChanged();

        return TRUE;

    }//end erase()


    function _deleteStoredContents()
    {

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

        $db = MatrixDAL::getDb();

        $bind_vars = Array (
                        'assetid'   => $this->id,
                     );

        try {
            $result = MatrixDAL::executeQuery('thesaurus', 'deleteAllTerms', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to delete all thesaurus terms due to database error: '. $e->getMessage());
        }//end

        try {
            $result = MatrixDAL::executeQuery('thesaurus', 'deleteAllLinks', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to delete all thesaurus links due to database error: '. $e->getMessage());
        }//end

        try {
            $result = MatrixDAL::executeQuery('thesaurus', 'deleteAllRelations', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to delete all thesaurus relations due to database error: '. $e->getMessage());
        }//end

        $bind_vars['assetid'] = $this->id.':%';

        try {
            $result = MatrixDAL::executeQuery('thesaurus', 'deleteAllShadowLinks', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to delete all shadow thesaurus links due to database error: '. $e->getMessage());
        }//end

        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

        return TRUE;

    }//end _deleteStoredContents()


    function getXmlFilePath()
    {
        return $this->data_path.'/content.xml';

    }//end getXmlFilePath()


    function _getName($short_name=FALSE, $contextid=NULL)
    {
        // No context specified, using the current context
        if ($contextid === NULL) {
            $contextid = $GLOBALS['SQ_SYSTEM']->getContextId();
        }//end if

        // Obtain the attribute value for Name from the specified Context
        $values = $GLOBALS['SQ_SYSTEM']->am->getAttributeValuesByName('name', $this->type(), Array($this->id), $contextid);
        if (empty($values) === TRUE) {
            return parent::_getName($short_name, $contextid);
        } else {
            return $values[$this->id];
        }

    }//end _getName()


    function getAbsoluteParentsInRelation($relation_id=NULL)
    {

        $db = MatrixDAL::getDb();

        if (!isset($relation_id)) return Array();

        $sql ='
            SELECT
                termid,
                term
            FROM
                sq_thes_term
            WHERE
                thesid = :thesid_1
                AND
                termid IN (
                    SELECT DISTINCT
                        major
                    FROM
                        sq_thes_lnk
                    WHERE
                        thesid = :thesid_2
                        AND
                        relid  = :relid_1
                        AND
                        major NOT IN (
                            SELECT DISTINCT
                                minor
                            FROM
                                sq_thes_lnk
                            WHERE
                                thesid = :thesid_3
                                AND
                                relid  = :relid_2
                        )
                )
            ORDER BY
                term
        ';

        $query = MatrixDAL::preparePdoQuery($sql);
        MatrixDAL::bindValueToPdo($query, 'thesid_1', $this->id);
        MatrixDAL::bindValueToPdo($query, 'thesid_2', $this->id);
        MatrixDAL::bindValueToPdo($query, 'thesid_3', $this->id);
        MatrixDAL::bindValueToPdo($query, 'relid_1', $relation_id);
        MatrixDAL::bindValueToPdo($query, 'relid_2', $relation_id);

        try {
            $result = MatrixDAL::executePdoAll($query);
        } catch (Exception $e) {
            throw new Exception('Unable to get absolute parent om relation due to database error: '. $e->getMessage());
        }//end

        return $result;

    }//end getAbsoluteParentsInRelation()


    function getLineagesForTerm($termid)
    {
        $result = Array();

        // this function is empty because lineages are hard to define and lookup for the general thesaurus
        // the only lineage that makes sense is the one using the hierarchy relations

        return $result;

    }//end getLineagesForTerm()


//--        BRIDGE FUNCTIONS        --//


    function getAsset($shadowid, $type_code='', $mute_errors=FALSE)
    {
        $asset = NULL;

        $id_parts = explode(':', $shadowid);
        if (!empty($id_parts[1])) {
            $id = $id_parts[1];

            $term = $this->getTermById($id);
            if (!empty($term)) {
                $GLOBALS['SQ_SYSTEM']->am->includeAsset('thesaurus_term');
                $asset = new Thesaurus_Term($shadowid);
            }
        }

        return $asset;

    }//end getAsset()


    function getAssetMapLinks()
    {
        return $this->_getTopTermsAssetMapLinks();

    }//end getAssetMapLinks()


    function _getShadowAssetMapLinks($parent_term_id=NULL)
    {
        $bridge_id = $this->id;

        $majorid = $bridge_id;
        if (!is_null($parent_term_id)) {
            $majorid .= ':'.$parent_term_id;
        }


        $active_relations = $this->getActiveRelations();
        $linked_terms = $this->getChildTerms($parent_term_id);

        $links = Array();

        foreach ($linked_terms as $term_link) {
            $link = Array();

            // mould it all to the asset map's liking
            $link['url'] = '';
            $link['path'] = '';
            $link['num_kids'] = -1;
            $link['accessible'] = 1;

            $link['majorid'] = $majorid;
            $link['minorid'] = $bridge_id.':'.$term_link['termid'];
            $link['assetid'] = $link['minorid'];
            $link['type_code'] = 'thesaurus_term';
            $link['minor_type_code'] = $link['type_code'];

            $link['linkid'] = $bridge_id.':'.$term_link['linkid'];
            // make name and short name the same
            $rel_name = array_get_index($active_relations, $term_link['relid']);
            $name_prefix = (empty($rel_name) ? '' : '('.$rel_name.') ');
            $link['name'] = $name_prefix.$term_link['term'];
            $link['short_name'] = $link['name'];

            $link['status'] = $this->status;
            $link['link_type'] = SQ_LINK_TYPE_1;
            $link['sort_order'] = 1;
            $link['is_dependant'] = 0;

            $links[] = $link;
        }

        return $links;

    }//end _getShadowAssetMapLinks()


    function _getTopTermsAssetMapLinks()
    {
        $terms = Array();

        $linkid_prefix = '';
        if ($this->attr('hierarchy_mode')) {
            $linkid_prefix = ':hierarchy';
            $terms = $this->getAbsoluteParentsInRelation($this->attr('hierarchy_rel'));
        } else {
            $linkid_prefix = ':atoz';
            $terms = $this->getAllTerms();
        }

        $bridge_id = $this->id;


        $links = Array();

        foreach ($terms as $one_term) {
            $link = Array();

            // mould it all to the asset map's liking
            $link['url'] = '';
            $link['path'] = '';
            $link['num_kids'] = -1;
            $link['accessible'] = 1;

            $link['majorid'] = $bridge_id;
            $link['minorid'] = $bridge_id.':'.$one_term['termid'];
            $link['assetid'] = $link['minorid'];
            $link['type_code'] = 'thesaurus_term';
            $link['minor_type_code'] = $link['type_code'];

            $link['linkid'] = $bridge_id.$linkid_prefix.':'.$one_term['termid'];

            // make name and short name the same
            $link['name'] = $one_term['term'];
            $link['short_name'] = $link['name'];

            $link['status'] = $this->status;
            $link['link_type'] = SQ_LINK_TYPE_2;
            $link['sort_order'] = 1;
            $link['is_dependant'] = 0;

            $links[] = $link;

        }//end foreach

        return $links;

    }//end _getTopTermsAssetMapLinks()


    function getAssetInfo($assetids, $type_code=Array(), $strict_type_code=TRUE, $field='')
    {
        $info_array = Array();

        foreach ($assetids as $id) {
            $id_parts = explode(':', $id);
            if (empty($id_parts[1])) continue;

            $term = $this->getTermById($id_parts[1]);
            if (empty($term)) continue;

            $info_array[$id]['assetid']     = $id;
            $info_array[$id]['name']        = $term['term'];
            $info_array[$id]['short_name']  = $term['term'];
            $info_array[$id]['version']     = $this->version;
            $info_array[$id]['status']      = $this->status;
            $info_array[$id]['type_code']   = 'thesaurus_term';
            $info_array[$id]['num_kids']    = $this->countChildTerms($term['termid']);
            $info_array[$id]['accessible']  = 1;
            $info_array[$id]['url']         = '';
            $info_array[$id]['web_path']    = '';

            if (!empty($field)) {
                $info_array[$id] = array_get_index($info_array[$id], $field);
            }

        }

        return $info_array;

    }//end getAssetInfo()


    function getAssetMapAssetInfo($assetid)
    {
        $asset_info = Array();
        $asset_info['assetid']      = $assetid;

        $id_parts = explode(':', $assetid);
        if (empty($id_parts[1])) return $asset_info;

        $term = $this->getTermById($id_parts[1]);
        if (empty($term)) return $asset_info;

        $asset_info['name']         = $term['term'];
        $asset_info['short_name']   = $term['term'];
        $asset_info['version']      = $this->version;
        $asset_info['status']       = $this->status;
        $asset_info['type_code']    = 'thesaurus_term';
        $asset_info['num_kids']     = $this->countChildTerms($term['termid']);
        $asset_info['accessible']   = 1;
        $asset_info['url']          = '';
        $asset_info['web_path']     = '';

        return $asset_info;

    }//end getAssetMapAssetInfo()


    function getLinks($assetid, $link_types, $type_code='', $strict_type_code=TRUE, $side_of_link='major', $sort_by=NULL)
    {
        return Array();

    }//end getLinks()


    function getLink($assetid, $link_type=NULL, $type_code='', $strict_type_code=TRUE, $value=NULL, $side_of_link='major', $exclusive=NULL)
    {
        return Array();

    }//end getLink()


    function getLinkByAsset($assetid, $other_assetid, $link_types=NULL, $value=NULL, $side_of_link='major', $force_array=FALSE, $dependant=NULL, $exclusive=NULL)
    {
        assert_valid_assetid($assetid);
        assert_valid_assetid($other_assetid);
        assert_false($side_of_link != 'major' && $side_of_link != 'minor', 'Unknown Side of Link "'.$side_of_link.'"');

        if ($side_of_link == 'major') {
            $major_assetid = $assetid;
            $minor_assetid = $other_assetid;
        } else {
            $major_assetid = $other_assetid;
            $minor_assetid = $assetid;
        }

        $major_parts = explode(':', $major_assetid);
        $majorid = array_get_index($major_parts, 1, NULL);

        $minor_parts = explode(':', $minor_assetid);
        $minorid = array_get_index($minor_parts, 1, NULL);
        if (empty($minorid)) return Array();

        $link_info = $this->getTermLinkByTermids($minorid, $majorid, $value);

        if (empty($link_info)) return Array();

        // construct template
        $link = Array(
                    'majorid'           => $major_assetid,
                    'minorid'           => $minor_assetid,
                    'link_type'         => SQ_LINK_TYPE_2,
                    'major_type_code'   => '',
                    'minor_type_code'   => 'thesaurus_term',
                    'value'             => $value,
                    'linkid'            => $this->id.':'.$link_info['linkid'],
                    'is_dependant'      => 0,
                    'is_exclusive'      => 0,
                    'locked'            => 0,
                );

        return $link;

    }//end getLinkByAsset()


    function getLinkById($linkid, $assetid=0, $side_of_link='major')
    {
        $link_parts = explode(':', $linkid);

        $majorid = $this->id;

        if (isset($link_parts[2])) {
            // the major is the thesaurus
            $term_id = array_get_index($link_parts, 2);
            $minorid = $term_id;
            $value = NULL;
            $major_type_code = 'thesaurus';

        } else {
            $term_linkid = array_get_index($link_parts, 1);
            if (is_null($term_linkid)) {
                trigger_error('Invalid Link ID', E_USER_ERROR);
            }
            $link_info = $this->getTermLinkById($term_linkid);
            $minorid = array_get_index($link_info, 'minorid');
            $majorid .= ':'.array_get_index($link_info, 'major');
            $value = array_get_index($link_info, 'relation');
            $major_type_code = 'thesaurus_term';
        }

        // construct template
        $link = Array(
                    'majorid'           => $majorid,
                    'minorid'           => $this->id.':'.$minorid,
                    'link_type'         => SQ_LINK_TYPE_2,
                    'major_type_code'   => $major_type_code,
                    'minor_type_code'   => 'thesaurus_term',
                    'value'             => $value,
                    'linkid'            => $linkid,
                    'is_dependant'      => 0,
                    'is_exclusive'      => 0,
                    'sort_order'        => NULL,
                    'locked'            => 0,
                );

        return $link;

    }//end getLinkById()


    function _getAllowedLinks()
    {
        return Array(
                SQ_LINK_TYPE_1  => Array(
                                    'thesaurus_term'    => Array(
                                                            'card'      => 'M',
                                                            'exclusive' => FALSE,
                                                           ),
                                   ),
                SQ_LINK_TYPE_2  => Array(
                                    'thesaurus_term'    => Array(
                                                            'card'      => 'M',
                                                            'exclusive' => FALSE,
                                                           ),
                                   ),
                SQ_LINK_TYPE_3  => Array(),
               );

    }//end _getAllowedLinks()


    function getChildren($assetid, $type_code='thesaurus_term', $strict_type_code=TRUE, $dependant=TRUE, $sort_by=NULL)
    {
        $result = Array();
        $id_parts = explode(':', $assetid);
        if ($type_code == 'thesaurus_term' || (is_array($type_code) && in_array('thesaurus_term', $type_code))) {
            // will return all terms, regardless of what param you pass in
            $terms = Array();
            if (isset($id_parts[1]) && $id_parts[0] == $this->id) {
                // if we are only looking for children terms underneath a term
                $terms = $this->getChildTerms($id_parts[1]);
            } else {
                $terms = $this->getAllTerms();
            }

            foreach ($terms as $term_info) {
                $result[$this->id.':'.$term_info['termid']] = Array(Array('type_code' => 'thesaurus_term'));
            }
        }

        return $result;

    }//end getChildren()


    function getParents($assetid, $type_code='', $strict_type_code=TRUE)
    {
        if (strpos($assetid, ':') !== FALSE) {
            list($realid, $shadowid) = explode(':', $assetid);
            $parents = Array($realid => $this->type());
            $parents += $GLOBALS['SQ_SYSTEM']->am->getParents($realid, $type_code, $strict_type_code);
            return $parents;
        }

        return Array();

    }//end getParents()


    function createAssetLink(&$major, &$minor, $link_type, $value='', $sort_order=NULL, $dependant='0', $exclusive='0', $moving=FALSE)
    {
        if ($major->id == $this->id) {
            // cannot link a term to a thesaurus
            // terms can only be linked to themselves
            // this term already exists; its appearance as the top term is controlled by the 'hierarchy' set of options
            trigger_error('Cannot link term to thesaurus. Term already exists in thesaurus. Its appearance as a top-level term is governed by the HIERARCHY options of the thesaurus and cannot be forced.', E_USER_ERROR);
            return 0;
        }

        $major_parts = explode(':',$major->id);
        $majorid = array_get_index($major_parts, 1);

        $minor_parts = explode(':',$minor->id);
        $minorid = array_get_index($minor_parts, 1);
        if (empty($minorid)) return NULL;

        $relid = empty($value) ? NULL : $value;
        $minor_term = NULL;
        $major_term = NULL;

        // can only link terms which belong to this thesaurus
        if (($minor_parts[0] != $this->id) || ($major_parts[0] != $this->id)) {
            return 0;
        }

        $minor_term = $minor->name;

        if (isset($major_parts[1])) {
            $major_term = $major->name;
        }

        if ($moving) {
            $link_info = $this->getTermLinkByTermids($minorid, $majorid, $relid);
            if (!is_null($link_info)) {
                trigger_localised_error('CORE0240');
                return FALSE;
            }
        } else {
            // if it's a new link, we use the default relation
            $relid = $this->attr('default_rel');
        }

        $term_linkid = $this->linkTerms($minorid, $majorid, $relid);

        if (is_null($term_linkid)) return FALSE;

        return $this->id.':'.$term_linkid;

    }//end createAssetLink()


    function getPermission($assetid, $permission, $granted=NULL, $and_greater=TRUE, $expand_groups=FALSE, $all_info=FALSE)
    {
        // All thesaurus terms inherit permissions of thesaurus.
        return $GLOBALS['SQ_SYSTEM']->am->getPermission($this->id, $permission, $granted, $and_greater, $expand_groups, $all_info);

    }//end getPermission()


    function markContentsChanged()
    {
        if ($this->attr('contents_changed')) return;

        $GLOBALS['SQ_SYSTEM']->setRunLevel(SQ_RUN_LEVEL_FORCED);
        $this->setAttrValue('contents_changed',TRUE);
        $this->saveAttributes();
        $GLOBALS['SQ_SYSTEM']->restoreRunLevel();

        return;

    }//end markContentsChanged()


    function countLinks($assetid, $side_of_link='major', $link_types=0, $type_code='', $strict_type_code=TRUE, $ignore_linkid=0)
    {

        $id_parts = explode(':', $assetid);

        $termid = array_get_index($id_parts, 1);
        if (is_null($termid)) return -1;

        $relations = Array();

        if ($side_of_link == 'major') {
            $keyword = 'Child';
        } else {
            $keyword = 'Parent';
        }
        $get_term_function = 'count'.$keyword.'Terms';
        return $this->$get_term_function($termid);

    }//end countLinks()


    function deleteAssetLink($linkid, $moving=FALSE)
    {
        $link_parts = explode(':', $linkid);

        if (isset($link_parts[1])) {
            if (isset($link_parts[2])) {
                if ($link_parts[1] == 'atoz') {
                    // delete term (in A-to-Z mode)
                    $this->deleteTerm($link_parts[2]);
                }
            } else {
                $this->deleteTermLink($link_parts[1]);
            }
        }
        return TRUE;

    }//end deleteAssetLink()


    function deleteTermLink($linkid)
    {
        if (empty($linkid)) return FALSE;

        // reflection support
        $link_info = $this->getTermLinkById($linkid);
        $major = $link_info['major'];
        $minor = $link_info['minor'];
        $relid = $link_info['relid'];

        $this->_deleteTermLink($linkid);

        if ($this->attr('enforce_reflection')) {
            $ref_relid = $this->getReflectionForRelation($relid);
            if (!is_null($ref_relid)) {
                $reflect_link = $this->getTermLinkByTermids($major, $minor, $ref_relid);
                if (!empty($reflect_link)) {
                    $this->_deleteTermLink($reflect_link['linkid']);
                }
            }
        }
        return TRUE;

    }//end deleteTermLink()


    function _deleteTermLink($linkid)
    {
        if (empty($linkid)) return FALSE;

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

        try {
            $bind_vars  = Array (
                            'linkid'    => $linkid,
                            'assetid'   => $this->id,
                          );
            $result = MatrixDAL::executeQuery('thesaurus', 'deleteLink', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to delete thesaurus term link due to the following database error:'.$e->getMessage());
        }//end try catch

        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

        return TRUE;

    }//end _deleteTermLink()


    function deleteTerm($termid)
    {
        if (empty($termid)) return FALSE;

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

        // delete the term
        try {
            $bind_vars  = Array (
                            'assetid'   => $this->id,
                            'termid'    => $termid,
                          );
            $result = MatrixDAL::executeQuery('thesaurus', 'deleteTerm', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to delete thesaurus term due to the following database error:'.$e->getMessage());
        }//end try catch

        try {
            $bind_vars  = Array (
                            'termid'    => $termid,
                            'assetid'   => $this->id,
                          );
            $result = MatrixDAL::executeQuery('thesaurus', 'deleteThesaurusLinksContainingTerm', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to delete thesaurus links containing term due to the following database error:'.$e->getMessage());
        }//end try catch

        try {
            $bind_vars  = Array (
                            'assetid'   => $this->id.':'.$termid,
                          );
            $result = MatrixDAL::executeQuery('thesaurus', 'deleteAllShadowLinks', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to delete shadow links due to the following database error:'.$e->getMessage());
        }//end try catch

        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

        return TRUE;

    }//end deleteTerm()


    function deleteRelation($relid)
    {
        if (empty($relid)) return FALSE;

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

        // delete the term
        try {
            $bind_vars  = Array (
                            'relation'  => $relid,
                            'assetid'   => $this->id,
                          );
            $result = MatrixDAL::executeQuery('thesaurus', 'deleteRelation', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to delete thesaurus terms relation due to the following database error:'.$e->getMessage());
        }//end try catch

        try {
            $bind_vars  = Array (
                            'relation'  => $relid,
                            'assetid'   => $this->id,
                          );
            $result = MatrixDAL::executeQuery('thesaurus', 'deleteLinksContainingRelation', $bind_vars);
        } catch (Exception $e) {
            throw new Exception('Unable to delete links containing relation due to the following database error:'.$e->getMessage());
        }//end try catch

        // cleanup the reflections
        // NOTE: In the future it might be necessary to wipe the reflective relation as well - Reflection Integrity
        $this->deleteReflection($relid);

        // make sure any settings we have do not use this relation id
        $synonym_rel = $this->attr('synonym_rel');
        if ($synonym_rel == $relid) {
            $this->setAttrValue('synonym_rel', NULL);
        }

        $abbreviation_rel = $this->attr('abbreviation_rel');
        if ($abbreviation_rel == $relid) {
            $this->setAttrValue('abbreviation_rel', NULL);
        }

        $default_rel = $this->attr('default_rel');
        if ($default_rel == $relid) {
            $this->setAttrValue('default_rel', NULL);
        }


        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();


        return TRUE;

    }//end deleteRelation()


    function moveLink($linkid, $to_parentid, $link_type, $to_parent_pos)
    {

    }//end moveLink()


    function updateLink($linkid, $link_type=NULL, $value=NULL, $new_sort_order=NULL)
    {
        $linkid_parts = explode(':', $linkid);
        if (!isset($linkid_parts[1]) || ($linkid_parts[0] != $this->id)) {
            return FALSE;
        }

        return TRUE;

    }//end updateLink()


    function assetExists($assetids)
    {

        $shadows = Array();
        $shadow_asset_ids = Array();

        // number of assetids
        $count = count($assetids);

        $is_array = is_array($assetids);
        $is_empty = empty($assetids);

        // assert assetid format
        if ($is_array && !$is_empty) {
            foreach ($assetids as $key => $value) {
                assert_valid_assetid($value);
            }
        } else if (!$is_empty) {
            assert_valid_assetid($assetids);
        }

        $db = MatrixDAL::getDb();
        $sql = 'SELECT termid, thesid
                FROM '.SQ_TABLE_RUNNING_PREFIX.'thes_term ';

        // single asset id
        if (!$is_array) {
            if ($is_empty) return FALSE;
            $id_parts = explode(':', $assetids);

            $where = 'termid = :termid AND thesid = :thesid';
            $where = $GLOBALS['SQ_SYSTEM']->constructRollbackWhereClause($where);

            $query = MatrixDAL::preparePdoQuery($sql.$where);
            MatrixDAL::bindValueToPdo($query, 'thesid', $id_parts[0]);
            MatrixDAL::bindValueToPdo($query, 'termid', $id_parts[1]);
            $db_assetids = MatrixDAL::executePdoOne($query);

            return ($db_assetids == $assetids);
        }

        // array of asset ids
        $existing_asset_ids = Array();
        if (!$is_empty) {
            $in = 'termid IN (';
            $thesid_array = Array();
            for ($i=0; $i<count($assetids); $i++) {
                $id_parts = explode(':', $assetids[$i]);
                // build an array of thesids for each termid
                $thesid_array[$id_parts[1]] = $id_parts[0];
                $in .= MatrixDAL::quote($id_parts[1]).(($i == count($assetids) - 1) ? ')' : ',');
            }

            $where = $GLOBALS['SQ_SYSTEM']->constructRollbackWhereClause($in);
            $db_assetids = MatrixDAL::executeSqlAll($sql.$where);

            foreach ($db_assetids as $db_id) {
                if ($db_id['thesid'] == $thesid_array[$db_id['termid']]) {
                    $existing_asset_ids[] = $db_id['thesid'].':'.$db_id['termid'];
                }
            }
        }

        return $existing_asset_ids;

    }//end assetExists()


    function getReflections()
    {
        return $this->attr('reflections');

    }//end getReflections()


    function getReflectionForRelation($start)
    {
        $reflections = $this->getReflections();
        return array_get_index($reflections, $start);

    }//end getReflectionForRelation()


    function addReflection($start, $end)
    {
        $reflections = $this->getReflections();

        if (isset($relfections[$start]) || isset($reflections[$end])) {
            return FALSE;
        }

        $reflections[$start] = $end;
        $reflections[$end] = $start;

        $this->setReflections($reflections);

    }//end addReflection()


    function deleteReflection($start)
    {
        $reflections = $this->getReflections();

        $end = array_get_index($reflections, $start);
        if (is_null($end)) return FALSE;

        unset($reflections[$start]);
        unset($reflections[$end]);

        $this->setReflections($reflections);

    }//end deleteReflection()


    function setReflections($ref_array)
    {
        $this->setAttrValue('reflections', $ref_array);
        return TRUE;

    }//end setReflections()


    function canClone()
    {
        return FALSE;

    }//end canClone()


    function getLineageFromURL($assetid, $protocol, $url)
    {
        return Array();

    }//end getLineageFromURL()


}//end class
?>