file_bridge.inc

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

class File_Bridge extends Asset implements Bridge
{


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

    }//end constructor


    protected function _getName($short_name=FALSE)
    {
        return $this->attr('name');

    }//end _getName()


    protected function _createAdditional(Array &$link)
    {
        if (!parent::_createAdditional($link)) return FALSE;

        return $this->makeAndSaveInitialWebPath(strtolower($this->attr('name')), $link);

    }//end _createAdditional()


    private function _listFiles($path)
    {

        $list = Array();

        $dirs  = list_dirs($path, TRUE, Array('CVS', '.svn'));
        $files = list_files($path, TRUE);

        sort($dirs);
        sort($files);

        $temp = array_merge($dirs, $files);
        $list = Array();

        // Cleanup by removing hidden files
        foreach ($temp as $element) {
            $filename = basename($element);
            if (strpos($filename, '.') !== 0) {
                $list[] = $element;
            }//end if
        }//end foreach
        
        return $list;

    }//end _listFiles()


    private function _isValidFile($path)
    {
        if (file_exists($path) && is_readable($path)) {
            return TRUE;
        }//end if

        return FALSE;

    }//end _isValidFile()


//--        BRIDGE INTERFACE        --//


    function getAsset($assetid, $type_code='', $mute_errors=FALSE)
    {
        $asset = NULL;
        $id_parts = explode(':', $assetid);

        if (isset($id_parts[1])) {
            $shadowid = $id_parts[1];
        } else {
            return $asset;
        }

        // The shadow id is the path from the location of the bridge
        require_once (SQ_DATA_PATH.'/private/conf/file_bridge.inc');
        $location = FILE_BRIDGE_PATH;
        $location = rtrim($location, '/');
        if ($this->_isValidFile($location.'/'.$shadowid)) {
            if (is_dir($location.'/'.$shadowid)) {
                $GLOBALS['SQ_SYSTEM']->am->includeAsset('physical_folder');
                $asset = new Physical_Folder($this->id.':'.$shadowid);
            } else {
                $GLOBALS['SQ_SYSTEM']->am->includeAsset('physical_file');
                $asset = new Physical_File($this->id.':'.$shadowid);
            }//end if
        }//end if

        return $asset;

    }//end getAsset()


    function getLinks($assetid, $link_types, $type_code='', $strict_type_code=TRUE, $side_of_link='major', $sort_by=NULL)
    {
        // only TYPE_2 links are ever returned
        if (!($link_types & SQ_LINK_TYPE_2)) {
            return Array();
        }

        if (!is_array($type_code)) {
            if (empty($type_code)) {
                $type_code = Array();
            } else {
                $type_code = Array($type_code);
            }
        }

        if (!isset($this->_tmp['getLinks'][$assetid][$side_of_link])) {

            $links = Array();
            // if we are looking from this asset and not a shadow asset
            if ($this->id == $assetid) {
                if ($side_of_link == 'minor') {
                    // should never happen...but anyway
                    trigger_localised_error('CORE0089', E_USER_ERROR);

                } else {
                    require_once (SQ_DATA_PATH.'/private/conf/file_bridge.inc');
                    $location = FILE_BRIDGE_PATH;
                    $location = rtrim($location, '/');
                    $files = $this->_listFiles($location);
                    $i = 0;
                    foreach ($files as $file) {
                        $varid = str_replace($location.'/', '', $file);
                        $type_code = (is_dir($file)) ? 'physical_folder' : 'physical_file';
                        $links[] = Array(
                                    'linkid'            => 0,
                                    'minorid'           => $this->id.':'.$varid,
                                    'minor_type_code'   => $type_code,
                                    'majorid'           => $this->id,
                                    'value'             => '',
                                    'link_type'         => SQ_LINK_TYPE_2,
                                    'is_dependant'      => FALSE,
                                    'is_exclusive'      => FALSE,
                                    'sort_order'        => $i,
                                   );
                        $i++;
                    }// end foreach

                }// endif


            // looking from shadow asset
            } else {
                list($bridgeid,$shadowid) = explode(':', $assetid);
                require_once (SQ_DATA_PATH.'/private/conf/file_bridge.inc');
                $location = FILE_BRIDGE_PATH;
                $location = rtrim($location, '/');

                // The file is invalid why proceed?
                if (!$this->_isValidFile($location.'/'.$shadowid)) {
                    return Array();
                }//end if

                // because the varieties are only ever going to be one level down
                // if we are looking up the tree all we can see is this bridge asset
                if ($side_of_link == 'minor') {
                    $links[] = Array(
                                'linkid'            => 0,
                                'majorid'           => $this->id,
                                'major_type_code'   => $this->type(),
                                'value'             => '',
                                'link_type'         => SQ_LINK_TYPE_2,
                                'is_dependant'      => TRUE,
                                'is_exclusive'      => TRUE,
                                'sort_order'        => 0,
                               );
                } else {
                    // Looking down the tree
                    if (is_dir($location.'/'.$shadowid)) {
                        $files = $this->_listFiles($location.'/'.$shadowid);
                        $i = 0;
                        foreach ($files as $file) {
                            $varid = str_replace($location.'/', '', $file);
                            $type_code = (is_dir($file)) ? 'physical_folder' : 'physical_file';
                            $links[] = Array(
                                        'linkid'            => 0,
                                        'minorid'           => $this->id.':'.$varid,
                                        'minor_type_code'   => $type_code,
                                        'majorid'           => $this->id,
                                        'value'             => '',
                                        'link_type'         => SQ_LINK_TYPE_2,
                                        'is_dependant'      => TRUE,
                                        'is_exclusive'      => TRUE,
                                        'sort_order'        => $i,
                                       );
                            $i++;
                        }// end foreach
                    } else {
                        // Just a file, nothing underneath
                        return Array();
                    }//end if
                }//endif

            }//end else - looking from shadow asset

            if (!is_null($sort_by)) {
                uasort($links, create_function('$a,$b', 'return $a["'.$sort_by.'"] < $b["'.$sort_by.'"];'));
            }

            $this->_tmp['getLinks'][$assetid][$side_of_link] = $links;

        }//end if

        return $this->_tmp['getLinks'][$assetid][$side_of_link];

    }//end getLinks()


    public function getChildren($assetid, $type_code='', $strict_type_code=TRUE, $dependant=NULL, $sort_by=NULL)
    {
        // now that we have an array in the format we wanted (sorted or not)
        // we can go through and construct our children array
        $children = Array();
        $links = $this->getLinks($assetid, SQ_LINK_TYPE_2, $type_code, $strict_type_code, 'major', NULL);
        if (!empty($links)) {
            foreach ($links as $link) {
                $children[$link['minorid']][0]['type_code'] = $link['minor_type_code'];
            }
        }
        return $children;

    }//end getChildren()

    
    function getParents($assetid, $type_code='', $strict_type_code=TRUE)
    {
        $id_parts = explode(':', $assetid);
        $parents = $GLOBALS['SQ_SYSTEM']->am->getParents($id_parts[0]);
        // after getting its own parent, the bridge adds itself as a parent into the array as the shadow asset is its child
        $parents[$this->id] = $this->type();
        return $parents;

    }//end getParents()


    function printBody()
    {

    }//end printBody()


    function getAvailableKeywords()
    {
        $keywords = parent::getAvailableKeywords();

        return $keywords;

    }//end getAvailableKeywords()


    function getKeywordReplacement($keyword)
    {
        return parent::getKeywordReplacement($keyword);

    }//end getKeywordReplacement()


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

    }//end getLineageFromURL()


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

    }//end getPermission()


    function setPermission($assetid, $userid, $permission, $granted)
    {
        return FALSE;

    }//end setPermission()


    function deletePermission($assetid, $userid, $permission)
    {
        return FALSE;

    }//end deletePermission()


    function getAssetInfo($assetids, $type_code=Array(), $strict_type_code=TRUE, $field='')
    {
        $info = Array();
        foreach ($assetids as $assetid) {
            $asset = $this->getAsset($assetid);

            if (!empty($field)) {
                if ($field == 'assetid') {
                    $info[$assetid] = $assetid;
                } else if ($field == 'type_code') {
                    $info[$assetid] = $asset->type();
                } else if (in_array($field , Array('version', 'name', 'short_name', 'status'))) {
                    $info[$assetid] = $asset->$field;
                } else {
                    $info[$assetid] = $this->$field;
                }
            } else {
                $info[$assetid] = Array(
                                    'assetid'               => $assetid,
                                    'type_code'             => $asset->type(),
                                    'version'               => $asset->version,
                                    'name'                  => $asset->name,
                                    'short_name'            => $asset->short_name,
                                    'status'                => $asset->status,
                                    'languages'             => $asset->languages,
                                    'charset'               => $asset->charset,
                                    'force_secure'          => $this->force_secure,
                                    'created'               => $asset->created,
                                    'created_userid'        => $asset->created_userid,
                                    'updated'               => $asset->updated,
                                    'updated_userid'        => $asset->updated_userid,
                                    'published'             => $asset->published,
                                    'published_userid'      => $asset->published_userid,
                                    'status_changed'        => $asset->status_changed,
                                    'status_changed_userid' => $asset->status_changed_userid,
                                  );
            }

        }//end foreach

        return $info;

    }//end getAssetInfo()


    function assetExists($assetids)
    {
        return FALSE;

    }//end assetExists()


    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 getLinkById($linkid, $assetid=0, $side_of_link='major')
    {
        return Array();

    }//end getLinkById()


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

    }//end countLinks()


    function getLinkByAsset($assetid, $other_assetid, $link_types=NULL, $value=NULL, $side_of_link='major', $force_array=FALSE, $dependant=NULL, $exclusive=NULL)
    {
        return Array();

    }//end getLinkByAsset()


    function getAllChildLinks($assetid, $link_type=0)
    {
        return Array();

    }//end getAllChildLinks()


    function updateLink($linkid, $link_type=NULL, $value=NULL, $sort_order=NULL)
    {
        return FALSE;

    }//end updateLink()


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

    }//end deleteAssetLink()


    function createAssetLink(&$major, &$minor, $link_type, $value='', $sort_order=NULL, $dependant='0', $exclusive='0', $moving=FALSE)
    {
        return 0;

    }//end createAssetLink()


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

    }//end getAssetMapAssetInfo()


}//end class

?>