File Source for Nexus.php

<?php
/**
* Nexus base class
*
* @abstract
* @author xing <xing@synapse.plus.com>
* @version $Revision: 1.21 $
* @package nexus
*/
/**
* required setup
*/
require_once( NEXUS_PKG_PATH.'NexusSystem.php' );
/**
* @package nexus
* @subpackage Nexus
*/
class Nexus extends NexusSystem {
/**
* Primary key for the menu
*/
var $mMenuId;
/**
* Initialisation of this class
*/
function Nexus( $pMenuId=NULL ) {
NexusSystem::NexusSystem();
$this->mMenuId = $pMenuId;
// if the cache folder doesn't exist yet, create it
if( !is_dir( TEMP_PKG_PATH.NEXUS_PKG_NAME.'/modules' ) ) {
mkdir_p( TEMP_PKG_PATH.NEXUS_PKG_NAME.'/modules' );
}
}
/**
* Load the menu
*/
function load() {
if( @BitBase::verifyId( $this->mMenuId ) ) {
$this->mInfo = $this->getMenu( $this->mMenuId );
$this->mInfo['items'] = $this->getItemList( $this->mMenuId );
$this->mInfo['tree'] = $this->createMenuTree( $this->mInfo['items'] );
}
return( count( $this->mInfo ) );
}
/**
* Get menu information from database
* @param $pMenuId menu id of the menu we want information from
*/
function getMenu( $pMenuId=NULL ) {
$ret = array();
if( !@BitBase::verifyId( $pMenuId ) && $this->isValid() ) {
$pMenuId = $this->mMenuId;
}
$bindVars = array();
$query = 'SELECT nm.* FROM `'.BIT_DB_PREFIX.'nexus_menus` nm';
if( is_numeric( $pMenuId ) ) {
$query .= ' WHERE nm.`menu_id`=?';
$bindVars = array( $pMenuId );
}
if( $result = $this->mDb->query( $query, array( $bindVars ) ) ) {
$ret = $result->fields;
$ret['cache']['file'] = 'mod_'.preg_replace( "/ /", "_", $ret['title'] ).'_'.$pMenuId.'.tpl';
$ret['cache']['path'] = TEMP_PKG_PATH.NEXUS_PKG_NAME."/modules/".$ret['cache']['file'];
$ret['cache']['module'] = "bitpackage:temp/nexus/".$ret['cache']['file'];
}
return $ret;
}
/**
* Get menu information from database
* @param $pMenuId menu id of the menu we want information from
*/
function getMenuList( $pFindString=NULL, $pSortMode=NULL, $pOffset=NULL, $pMaxRows=NULL ) {
$bindVars = array();
$mid = '';
if( $pFindString ) {
$mid .= " WHERE UPPER(nm.`title`) LIKE ? ";
$bindVars[] = '%'.strtoupper( $pFindString ).'%';
}
if( $pSortMode ) {
$mid .= " ORDER BY ".$this->mDb->convertSortmode( $pSortMode )." ";
}
$query = 'SELECT nm.`menu_id` FROM `'.BIT_DB_PREFIX.'nexus_menus` nm'.$mid;
if( $pMaxRows && is_numeric( $pMaxRows ) ) {
$result = $this->mDb->query( $query, $bindVars, $pOffset, $pMaxRows );
} else {
$result = $this->mDb->query( $query, $bindVars );
}
$menuIds = $result->getRows();
$menus = array();
foreach( $menuIds as $menuId ) {
$tmpMenu = new Nexus( $menuId['menu_id'] );
$tmpMenu->load();
$menus[] = $tmpMenu->mInfo;
}
return $menus;
}
/**
* Create usable menu tree
* @param $pMenuHash full menu as supplied by '$this->getItemList( $pMenuId );'
* @param $pStripped if set to true, removes all permissions, user isn't part of
* @return menu with all menu items sorted with first and last items of each 'level' marked. items that contain siblings are marked with 'head' = TRUE;
*/
function createMenuTree( $pMenuHash, $pStripped=FALSE, $parent_id=0, $pForceBuild=FALSE ) {
$ret = array();
if( $pForceBuild || $this->isValid() && empty( $this->mInfo['tree'] )) {
if( $pStripped && $parent_id == 0 ) {
$pMenuHash = $this->checkUserPermission( $pMenuHash );
}
// get all child menu items for this item_id
$children = $this->getChildItems( $pMenuHash, $parent_id );
$pos = 1;
$row_max = count( $children );
foreach( $children as $item ) {
$aux = $item;
$aux['first'] = ( $pos == 1 );
$aux['last'] = FALSE;
$aux['head'] = FALSE;
$ret[] = $aux;
//Recursively add any children
$subs = $this->createMenuTree( $pMenuHash, $pStripped, $item['item_id'], TRUE );
if( !empty( $subs ) ) {
// mark items that have children
$row_last = count( $ret );
$ret[$row_last - 1]['head'] = TRUE;
$ret = array_merge( $ret, $subs );
}
if( $pos == $row_max ) {
if( @BitBase::verifyId( $item['parent_id'] ) ) {
$tmpItem = $this->getItemList( NULL, $item['parent_id'] );
$aux = $tmpItem[$item['parent_id']];
} else {
$aux['item_id'] = $item['item_id'];
}
$aux['first'] = FALSE;
$aux['last'] = TRUE;
$ret[] = $aux;
}
$pos++;
}
} else {
$ret = $this->mInfo['tree'];
}
return $ret;
}
/**
* Strip out all items a user doesn't have permission to view
* @param $pMenuHash full menu as supplied by '$this->getItemList( $pMenuId );'
* @return menu containing only items user is allowed to view
*/
function checkUserPermission( $pMenuHash ) {
global $gBitUser;
$ret = array();
foreach( $pMenuHash as $item ) {
if( !empty( $item['perm'] ) ) {
if( $gBitUser->hasPermission( $item['perm'] ) ) {
$ret[] = $item;
}
} else {
$ret[] = $item;
}
}
return $ret;
}
/**
* Get all items in $pMenuHash that have a given parent_id
* @param $pMenuHash full menu as supplied by '$this->getItemList( $pMenuId );'
* @return array of items with a given parent_id
*/
function getChildItems( $pMenuHash, $parent_id=0 ) {
$ret = array();
foreach( $pMenuHash as $item ) {
if( $item['parent_id'] == $parent_id ) {
$ret[] = $item;
}
}
return $ret;
}
/**
* Validate that a menu is being loaded and present
* @return TRUE if all is ok
*/
function isValid() {
return( BitBase::verifyId( $this->mMenuId ) );
}
/**
* Check if all required items are present for menu creation / insertion
* @return number of errors encountered
*/
function verifyMenu( &$pParamHash ) {
if( empty( $pParamHash['title'] ) ) {
$this->mErrors['verify_title'] = tra( 'Could not store menu because no title was given.' );
}
if( empty( $pParamHash['description'] ) ) {
$pParamHash['description'] = NULL;
}
// set the default plugin_guid to suckerfish menus
if( empty( $pParamHash['plugin_guid'] ) ) {
$pParamHash['plugin_guid'] = NEXUS_PLUGIN_GUID_SUCKERFISH;
}
$type_name = 'type_' . $pParamHash['plugin_guid'];
if ( empty( $pParamHash[$type_name] )) {
$pParamHash['menu_type'] = 'nor';
}
else {
$pParamHash['menu_type'] = $pParamHash[$type_name];
}
if( empty( $pParamHash['editable'][0] ) || !is_numeric( $pParamHash['editable'][0] ) ) {
$pParamHash['editable'][0] = 0;
}
$pParamHash['editable'] = $pParamHash['editable'][0];
return( count( $this->mErrors ) == 0 );
}
/**
* Store menu in db
* @param menu_id if set, will update given menu - if not set, we create a new entry in the db
* @param title title of menu
* @param description description of menu
* @param menu_type type of menu
* @param editable if menu is editable by other users - takes 0 or 1
* @return new menu menu_id or FALSE if not created
*/
function storeMenu( &$pParamHash ) {
$ret = FALSE;
if( $this->verifyMenu( $pParamHash ) ) {
if( !@BitBase::verifyId( $pParamHash['menu_id'] ) ) {
$query = "INSERT INTO `".BIT_DB_PREFIX."nexus_menus`( `title`,`description`,`menu_type`,`plugin_guid`,`editable` ) VALUES(?,?,?,?,?)";
$result = $this->mDb->query( $query, array( $pParamHash['title'], $pParamHash['description'], $pParamHash['menu_type'], $pParamHash['plugin_guid'], $pParamHash['editable'] ) );
$query = "SELECT MAX(`menu_id`) FROM `".BIT_DB_PREFIX."nexus_menus`";
$ret = $this->mDb->getOne( $query, array() );
} else {
$query = "UPDATE `".BIT_DB_PREFIX."nexus_menus` SET `title`=?,`description`=?,`menu_type`=?,`plugin_guid`=?,`editable`=? WHERE `".BIT_DB_PREFIX."nexus_menus`.`menu_id`=?";
$result = $this->mDb->query( $query, array( $pParamHash['title'], $pParamHash['description'], $pParamHash['menu_type'], $pParamHash['plugin_guid'], $pParamHash['editable'], $pParamHash['menu_id'] ) );
$ret = $pParamHash['menu_id'];
}
$this->writeMenuCache( $ret );
} else {
vd( $this->mErrors );
}
return $ret;
}
/**
* Delete menu and associated menu items from db
* @return number of errors encountered
*/
function expungeMenu( $pMenuId ) {
// first off, remove the menu from the layout
global $gBitThemes, $gBitSystem;
$menu = $this->getMenu( $this->mMenuId );
$gBitThemes->unassignModule( $menu['cache']['module'], ROOT_USER_ID );
// delete menu items
$query = "DELETE FROM `".BIT_DB_PREFIX."nexus_menu_items` WHERE `menu_id`=?";
$this->mDb->query( $query, array( $pMenuId ) );
// delete menu
$query = "DELETE FROM `".BIT_DB_PREFIX."nexus_menus` WHERE `menu_id`=?";
$this->mDb->query( $query, array( $pMenuId ) );
// rewrite the entire cache, just to make sure everything is in order
$this->rewriteMenuCache();
return( count( $this->mErrors ) == 0 );
}
/**
* Get menu items from the database
* @param $pItemId ID of menu item to get. if set, we only get this item.
* @param $pMenuId ID of menu to get
* @return all menu items with a given menu ID
*/
function getItemList( $pMenuId=NULL, $pItemId=NULL ) {
$bindVars = array();
$ret = array();
$query = 'SELECT nmi.* FROM `'.BIT_DB_PREFIX.'nexus_menu_items` nmi';
if( is_numeric( $pItemId ) ) {
$query .= ' WHERE nmi.`item_id`=?';
$bindVars = array( $pItemId );
} elseif( is_numeric( $pMenuId ) ) {
$query .= ' WHERE nmi.`menu_id`=?';
$bindVars = array( $pMenuId );
}
$query .= ' ORDER BY nmi.`pos`';
$result = $this->mDb->query( $query,array( $bindVars ) );
while( !$result->EOF ) {
$item = $result->fields;
$item['display_url'] = $this->printUrl( $item );
$ret[$item['item_id']] = $item;
$result->MoveNext();
}
// this version of the loop inserts the submenu at the point of choice
foreach( $ret as $item ) {
if( $item['rsrc_type'] == 'menu_id' ) {
$tmp = $this->getItemList( $item['rsrc'] );
foreach( $tmp as $i ) {
if( $i['parent_id'] == 0 ) {
$tmp[$i['item_id']]['parent_id'] = $item['item_id'];
}
// pass all items on to ret
$ret[$i['item_id']] = $tmp[$i['item_id']];
}
}
}
return $ret;
}
/**
* Create the correct url for a given item
* @param $pItemHash complete item hash
* @return url
*/
function printUrl( $pItemHash ) {
global $gLibertySystem, $gBitSystem;
$contentTypes = $gLibertySystem->mContentTypes;
$ret = NULL;
if( isset( $pItemHash['rsrc'] ) && isset( $pItemHash['rsrc_type'] )) {
switch( $pItemHash['rsrc_type'] ) {
case 'external':
case 'internal':
$ret .= $pItemHash['rsrc'];
break;
case 'content_id':
// create *one* object for each object *type* to call virtual methods.
$row = $this->mDb->getRow( "SELECT `title`,`content_id`,`content_type_guid` FROM `".BIT_DB_PREFIX."liberty_content` WHERE `content_id`=?", array( $pItemHash['rsrc'] ));
$type = &$contentTypes[$row['content_type_guid']];
if( empty( $type['content_object'] )) {
include_once( $gBitSystem->mPackages[$type['handler_package']]['path'].$type['handler_file'] );
$type['content_object'] = new $type['handler_class']();
}
$ret = $type['content_object']->getDisplayUrl( NULL, $row );
break;
case 'structure_id':
$ret .= BIT_ROOT_URL.'index.php?structure_id='.$pItemHash['rsrc'];
break;
}
}
return $ret;
}
/**
* Verify rsrc handed to us and specify what type it is
* @return fixed rsrc and corresponding rsrc_type
*/
function verifyRsrc( &$pParamHash ) {
$bit_root_pattern = "/^".preg_replace( "/\//", "\/", BIT_ROOT_URL )."/i";
if( preg_match( "/^(http:\/\/)/i", $pParamHash['rsrc'] ) ) {
$pParamHash['rsrc_type'] = 'external';
} elseif( is_numeric( $pParamHash['rsrc'] ) ) {
// if the resource type is numeric but we don't know what type it is, assume that it's a content_id
if( !isset( $pParamHash['rsrc_type'] ) ) {
$pParamHash['rsrc_type'] = 'content_id';
}
} elseif( preg_match( $bit_root_pattern, $pParamHash['rsrc'] ) ) {
// if BIT_ROOT_URL can be found at the beginning of the string, assume it's an internal link
// in most cases this will only be a '/' but hopefully that's enough
$pParamHash['rsrc_type'] = 'internal';
} else {
// if we haven't caught this resource yet, we just prepend it with BIT_ROOT_URL and hope for the best
$pParamHash['rsrc'] = BIT_ROOT_URL.$pParamHash['rsrc'];
$pParamHash['rsrc_type'] = 'internal';
}
}
/**
* Verify if a given menu item contains all required information and prepare menu_items table for item insertion.
* @return number of errors encountered
*/
function verifyItem( &$pParamHash ) {
if( empty( $pParamHash['hint'] ) ) { $pParamHash['hint'] = NULL; }
if( empty( $pParamHash['perm'] ) ) { $pParamHash['perm'] = NULL; }
if( empty( $pParamHash['title'] ) ) {
$this->mErrors['verify_item_title'] = tra( 'Could not store menu item. No item title was given.' );
}
if( !@BitBase::verifyId( $pParamHash['menu_id'] ) ) {
$this->mErrors['verify_menu_id'] = tra( 'Could not store menu item. Invalid menu id. Menu id ' ).': '.$pParamHash['menu_id'];
} else {
$this->mDb->StartTrans();
if( !@BitBase::verifyId( $pParamHash['parent_id'] ) ) {
$pParamHash['parent_id'] = 0;
// if no parent_id is not known, but we have an after_ref_id, we use that to work out the parent_id
if( @BitBase::verifyId( $pParamHash['after_ref_id'] ) ) {
$pParamHash['parent_id'] = $this->mDb->getOne("SELECT `parent_id` FROM `".BIT_DB_PREFIX."nexus_menu_items` WHERE `item_id`=?", array( (int)$pParamHash['after_ref_id'] ) );
}
}
$pParamHash['max'] = 0;

Source for file Nexus.php