xml_user_bridge.inc

<?php
require_once SQ_INCLUDE_PATH.'/asset.inc';
require_once SQ_CORE_PACKAGE_PATH.'/interfaces/bridge/bridge.inc';
require_once SQ_FUDGE_PATH.'/general/file_system.inc';


class XML_User_Bridge extends Asset implements Bridge
{

    public $groups = NULL;
    public $group_members = NULL;
    public $user_memberships = NULL;


    function __construct($assetid=0)
    {
        $res = parent::__construct($assetid);
        $this->loadFromFile();
        return $res;

    }//end constructor


    protected 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 loadFromFile()
    {
        #require_once 'XML/Tree.php';
        require_once SQ_INCLUDE_PATH.'/general_occasional.inc';

        $filename = $this->data_path.'/contents.xml';

        if (!file_exists($filename) || (filemtime($filename) < strtotime('-'.$this->attr('refresh_time').' seconds'))) {
            @unlink($filename);
            if ($this->attr('data_url')) {
                $xml = @file_get_contents($this->attr('data_url'));
                if ($xml) {
                    if (!is_dir($this->data_path)) {
                        create_directory($this->data_path);
                    }
                    string_to_file($xml, $filename);
                }
            }
        }
        if (!file_exists($filename)) return;

        $root = @simplexml_load_file($filename);
        if (empty($root)) {
            return;
        }

        $this->groups = Array();
        $this->group_members = Array();
        $this->user_memberships = Array();
        foreach ($root->children() as $group_node) {
            if ($group_node->getName() != 'group') continue;
            $groupid = (int)$group_node->attributes()->id;
            $this->groups[$groupid] = (string)$group_node->attributes()->name;
            foreach ($group_node->children() as $member_node) {
                $_attributes = Array();
                foreach ($member_node->attributes() as $k => $v) {
                    $_attributes[$k] = (string)$v;
                }
                $this->group_members[$groupid][((int)$member_node->attributes()->id)] = $_attributes;
                $this->user_memberships[(int)$member_node->attributes()->id][] = $groupid;
            }
        }
        

    }//end loadFromFile()


    function getAsset($assetid, $type_code='', $mute_errors=FALSE)
    {
        $bits = explode(':', $assetid);
        switch (count($bits)) {
            case 1:
                return $GLOBALS['SQ_SYSTEM']->am->getAsset($assetid, $type_code, $mute_errors);
            case 2:
                $GLOBALS['SQ_SYSTEM']->am->includeAsset('user_group');
                $shadowid = $bits[1];
                $ug = new User_Group();
                $ug->id = $assetid;
                $ug->name = $this->groups[$shadowid];
                $ug->short_name = $this->groups[$shadowid];
                $ug->status = $this->status;
                $ug->setAttrValue('name', $this->groups[$shadowid]);
                return $ug;
            case 3:
                $groupid = $bits[1];
                $personid = $bits[2];
                $user_type = $this->attr('user_type');
                $GLOBALS['SQ_SYSTEM']->am->includeAsset($user_type);
                $user = new $user_type();
                $user->id = $assetid;
                $user->status = $this->status;
                if (isset($this->group_members[$groupid][$personid])) {
                    foreach ($this->group_members[$groupid][$personid] as $field => $val) {
                        if (isset($user->vars[$field])) {
                            $user->setAttrValue($field, $val);
                        }
                    }
                }
                $user->name = $user->_getName();
                $user->short_name = $user->_getName(TRUE);
                return $user;
        }//end switch

    }//end getAsset()


    function getLinks($assetid, $link_types, $type_code='', $strict_type_code=TRUE, $side_of_link='major', $sort_by=NULL, $dependant=NULL, $exclusive=NULL)
    {
        // We don't have any dependant or exclusive links
        if ($dependant || $exclusive) {
            return Array();
        }

        // We only have type 1 links
        if (! $link_types && SQ_LINK_TYPE_1) {
            return Array();
        }

        // We only can return links for descendants of User and User Group
        $user_type_codes = array_diff($GLOBALS['SQ_SYSTEM']->am->getTypeDescendants(Array('user', 'user_group'), TRUE), Array('root_user'));
        if (!empty($type_code) && !in_array($type_code, $user_type_codes)) {
            return Array();
        }

        $bits = explode(':', $assetid);
        switch (count($bits)) {
            case 1:
                if (($assetid == $this->id) && ($side_of_link == 'major')) {
                    // Get the groups under this asset
                    $sample = Array(
                                'majorid'           => $this->id,
                                'link_type'         => SQ_LINK_TYPE_1,
                                'major_type_code'   => 'xml_user_bridge',
                                'minor_type_code'   => 'user_group',
                                'value'             => '',
                                'linkid'            => 0,
                                'sort_order'        => -1,
                                'is_dependant'      => 1,
                              );
                    $res = Array();
                    foreach ($this->groups as $id => $name) {
                        $sample['minorid'] = $this->id.':'.$id;
                        $res[] = $sample;
                    }
                    return $res;
                } else {
                    return $GLOBALS['SQ_SYSTEM']->am->getLinks($assetid, $link_types, $type_code, $strict_type_code, $side_of_link, $sort_by, $dependant, $exclusive);
                }
            break;
            case 2:
                if ($side_of_link == 'major') {
                    // Get the users under this group
                    $sample = Array(
                                'majorid'           => $assetid,
                                'link_type'         => SQ_LINK_TYPE_1,
                                'major_type_code'   => 'user_group',
                                'minor_type_code'   => $this->attr('user_type'),
                                'value'             => '',
                                'linkid'            => 0,
                                'sort_order'        => -1,
                                'is_dependant'      => 1,
                              );
                    $res = Array();
                    foreach ($this->group_members[$bits[1]] as $userid => $details) {
                        $sample['minorid'] = $assetid.':'.$userid;
                        $res[] = $sample;
                    }
                    return $res;

                } else {
                    // Just this
                    $res = Array(
                            'minorid'           => $assetid,
                            'majorid'           => $this->id,
                            'link_type'         => SQ_LINK_TYPE_1,
                            'major_type_code'   => 'xml_user_bridge',
                            'minor_type_code'   => 'user_group',
                            'value'             => '',
                            'linkid'            => 0,
                            'sort_order'        => -1,
                            'is_dependant'      => 1,
                           );
                    return Array($res);
                }
            break;
            case 3:
                if ($side_of_link == 'major') {
                    return Array();
                } else {
                    // Get the groups this user belongs to
                    $sample = Array(
                                'minorid'           => $assetid,
                                'link_type'         => SQ_LINK_TYPE_1,
                                'major_type_code'   => 'user_group',
                                'minor_type_code'   => $this->attr('user_type'),
                                'value'             => '',
                                'linkid'            => 0,
                                'sort_order'        => -1,
                                'is_dependant'      => 1,
                              );
                    $res = Array();
                    foreach ($this->user_memberships[$bits[2]] as $groupid) {
                        $sample['majorid'] = $this->id.':'.$groupid;
                        $res[] = $sample;
                    }
                    return $res;
                }
            break;
        }//end switch


    }//end getLinks()


    function getParents($assetid, $type_code='', $strict_type_code=TRUE)
    {
        $bits = explode(':', $assetid);
        $res = Array();
        switch (count($bits)) {
            case 1:
                $res = $GLOBALS['SQ_SYSTEM']->am->getParents($assetid, $type_code, $strict_type_code);
            break;
            case 2:
                if (empty($type_code) || ($type_code == 'xml_user_bridge') || (!$strict_type_code && ($type_code == 'bridge'))) {
                    $res = Array($this->id => 'xml_user_bridge');
                }
            break;
            case 3:
                if (empty($type_code) || ($type_code == 'user_group') || (!$strict_type_code && ($type_code == 'folder'))) {
                    foreach ($this->user_memberships[$bits[2]] as $groupid) {
                        $res[$groupid] = 'user_group';
                    }
                }
            break;
        }
        return $res;

    }//end getParents()


    function getChildren($assetid, $type_code='', $strict_type_code=TRUE, $dependant=NULL, $sort_by=NULL)
    {
        $bits = explode(':', $assetid);
        $res = Array();
        switch (count($bits)) {
            case 1:
                if ($assetid == $this->id) {
                    foreach ($this->group_members as $groupid => $members) {
                        $res[$this->id.':'.$groupid] = Array(Array('type_code' => 'user_group'));
                    }
                    return $res;
                } else {
                    return $GLOBALS['SQ_SYSTEM']->am->getChildren($assetid, $type_code='', $strict_type_code=TRUE, $dependant=NULL, $sort_by=NULL);
                }
            break;
            case 2:
                $res = Array();
                foreach (array_get_index($this->group_members, $bits[1], Array()) as $memberid => $details) {
                    $res[$assetid.':'.$memberid] = Array(Array('type_code' => 'bulkmail_user'));
                }
                return $res;
            break;
            case 3:
                return Array();
            break;
        }

    }//end getChildren()


    function getLink($assetid, $link_type=NULL, $type_code='', $strict_type_code=TRUE, $value=NULL, $side_of_link='major', $exclusive=NULL)
    {
        // There are no individual links of note in this sytem
        return NULL;

    }//end getLink()


    function getLinkById($linkid, $assetid=0, $side_of_link='major')
    {
        return Array();

    }//end getLinkById()


    function canCreateLink(&$minor, $link_type, $exclusive)
    {
        return FALSE;

    }//end canCreateLink()


    function getAssetInfo($assetids, $type_code=Array(), $strict_type_code=TRUE, $field='')
    {
        assert_type($assetids, 'array');
        if (empty($assetids)) return Array();
        if (!is_array($type_code)) {
            $type_code = Array($type_code);
        }
        $template = reset($GLOBALS['SQ_SYSTEM']->am->getAssetInfo($this->id));

        $res = Array();
        $available_types = $GLOBALS['SQ_SYSTEM']->am->getTypeAncestors($this->attr('user_type'));
        $available_types[] = $this->attr('user_type');
        if (empty($type_code) || array_intersect($available_types, $type_code)) {
            // Look through the users
            foreach ($assetids as $assetid) {
                $asset =& $this->getAsset($assetid, $this->attr('user_type'));
                if (empty($field)) {
                    $entry = $template;
                    foreach ($template as $i => $v) {
                        if ($i == 'type_code') continue;
                        $entry[$i] = $asset->$i;
                    }
                } else {
                    $entry = $asset->$field;
                }
                $res[$assetid] = $entry;
            }
        }

        if (empty($type_code) || in_array('user_group', $type_code)) {
            // Look through the groups
            foreach ($assetids as $id) {
                $bits = explode(':', $id);
                if (count($bits) == 2) {
                    $name = array_get_index($this->groups, $bits[1]);
                    if ($name) {
                        $entry = $template;
                        $entry['name'] = $name;
                        $entry['short_name'] = $name;
                        $entry['type_code'] = 'user_group';
                        if (empty($field)) {
                            $res[$id] = $entry;
                        } else {
                            $res[$id] = array_get_index($entry, $field);
                        }
                    }
                }
            }
        }

        return $res;

    }//end getAssetInfo()


    function assetExists($assetids)
    {
        if (!is_array($assetids)) {
            $my_assetids = Array($assetids);
        } else {
            $my_assetids = $assetids;
        }
        foreach ($my_assetids as $assetid) {
            $bits = explode(':', $assetid);
            switch (count($bits)) {
                case 1:
                    $res[$assetid] = ($assetid == $this->id);
                break;
                case 2:
                    $res[$assetid] = isset($this->groups[$bits[1]]);
                break;
                case 3:
                    $res[$assetid] = isset($this->groups[$bits[1]]) && isset($this->group_members[$bits[1]][$bits[2]]);
                break;
            }
        }
        return (is_array($assetids)) ? $res : $res[$assetids];

    }//end assetExists()


    function getPermission($assetid, $permission, $granted=null, $and_greater=true, $expand_groups=false, $all_info=false)
    {
        return $GLOBALS['SQ_SYSTEM']->am->getPermission($this->id, $permission, $granted, $and_greater, $expand_groups, $all_info);

    }//end getPermission()


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

    }//end getLineageFromURL()


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

    }//end countLinks()


    public function deleteAssetLink($linkid, $moving=FALSE)
    {
        return FALSE;

    }//end deleteAssetLink()


    public function getAssetMapAssetInfo($assetid)
    {
        return Array();

    }//end getAssetMapAssetInfo()


}//end class
?>