mirror/php-e107
1
0
Fork 0
mirror of https://github.com/e107inc/e107.git synced 2025-01-18 05:09:05 +01:00
Code Issues Releases Wiki Activity
php-e107/e107_handlers/userclass_class.php
CaMer0n db3a16fdc6 Install fixes and notice removal
2009-09-17 00:13:40 +00:00

1429 lines
45 KiB
PHP
Raw Blame History

<?php
/*
+ ----------------------------------------------------------------------------+
| e107 website system
|
| <20>Steve Dunstan 2001-2002
| http://e107.org
| jalist@e107.org
|
| Released under the terms and conditions of the
| GNU General Public License (http://gnu.org).
|
| $Source: /cvs_backup/e107_0.8/e107_handlers/userclass_class.php,v $
| $Revision: 1.42 $
| $Date: 2009-09-17 00:13:40 $
| $Author: e107coders $
+----------------------------------------------------------------------------+
*/
/*
This class handles everything a user needs. Admin functions inherit from it.
*/
if (!defined('e107_INIT')) { exit; }
require_once(e_HANDLER.'arraystorage_class.php');
include_lan(e_LANGUAGEDIR.e_LANGUAGE.'/lan_userclass.php');
/*
For info:
define("e_UC_PUBLIC", 0);
define("e_UC_MAINADMIN", 250);
define("e_UC_READONLY", 251);
define("e_UC_GUEST", 252);
define("e_UC_MEMBER", 253);
define("e_UC_ADMIN", 254);
define("e_UC_NOBODY", 255);
*/
define('e_UC_ADMINMOD',249);
define('e_UC_MODS',248);
define('e_UC_NEWUSER',247); // Users in 'probationary' period
define('e_UC_SPECIAL_BASE',245); // Assign class IDs 245 and above for fixed/special purposes
define('e_UC_SPECIAL_END',255); // Highest 'special' class
// define('UC_CLASS_ICON_DIR','userclasses/'); // Directory for userclass icons - deprecated - the icon will be saved with the full path. {e_IMAGE} or {e_PLUGIN} / images/ etc.
define('UC_ICON_DIR',e_IMAGE.'generic/'); // Directory for the icons used in the admin tree displays
define('e_UC_BLANK','-1');
define('UC_TYPE_STD', '0');
define('UC_TYPE_GROUP', '1');
define('UC_CACHE_TAG', 'nomd5_classtree');
class user_class
{
var $class_tree; // Simple array, filled with current tree. Additional field class_children is an array of child user classes (by ID)
var $class_parents; // Array of class IDs of 'parent' (i.e. top level) classes
var $fixed_classes = array(); // The 'predefined' classes of 0.7
var $text_class_link = array(); // List of 'core' user classes and the related constants
var $sql_r; // We'll use our own DB to avoid interactions
var $isAdmin; // Set true if we're an instance of user_class_admin
// Constructor
function user_class()
{
$this->sql_r = e107::getDb('sql_r');
$this->isAdmin = FALSE;
$this->fixed_classes = array(e_UC_PUBLIC => UC_LAN_0,
e_UC_GUEST => UC_LAN_1,
e_UC_NOBODY => UC_LAN_2,
e_UC_MEMBER => UC_LAN_3,
e_UC_ADMIN => UC_LAN_5,
e_UC_MAINADMIN => UC_LAN_6,
e_UC_READONLY => UC_LAN_4,
e_UC_NEWUSER => UC_LAN_9
);
$this->text_class_link = array('public' => e_UC_PUBLIC, 'guest' => e_UC_GUEST, 'nobody' => e_UC_NOBODY, 'member' => e_UC_MEMBER,
'admin' => e_UC_ADMIN, 'main' => e_UC_MAINADMIN, 'readonly' => e_UC_READONLY, 'new' => e_UC_NEWUSER);
$this->readTree(TRUE); // Initialise the classes on entry
}
/*
Ensure the tree of userclass data is stored in our object.
Only read if its either not present, or the $force flag is set
*/
protected function readTree($force = FALSE)
{
if (isset($this->class_tree) && count($this->class_tree) && !$force) return $this->class_tree;
global $e107;
$this->class_tree = array();
$this->class_parents = array();
$array = new ArrayData;
if ($temp = $e107->ecache->retrieve_sys(UC_CACHE_TAG))
{
$this->class_tree = $array->ReadArray($temp);
unset($temp);
}
else
{
$this->sql_r->db_Select("userclass_classes", '*', "ORDER BY userclass_parent", 'nowhere'); // The order statement should give a consistent return
while ($row = $this->sql_r->db_Fetch(MYSQL_ASSOC))
{
$this->class_tree[$row['userclass_id']] = $row;
$this->class_tree[$row['userclass_id']]['class_children'] = array(); // Create the child array in case needed
}
// Add in any fixed classes that aren't already defined
foreach ($this->fixed_classes as $c => $d)
{
// if (!isset($this->class_tree[$c]) && ($c != e_UC_PUBLIC))
if (!isset($this->class_tree[$c]))
{
switch ($c)
{
case e_UC_ADMIN :
case e_UC_MAINADMIN :
$this->class_tree[$c]['userclass_parent'] = e_UC_NOBODY;
break;
case e_UC_NEWUSER :
$this->class_tree[$c]['userclass_parent'] = e_UC_MEMBER;
break;
default :
$this->class_tree[$c]['userclass_parent'] = e_UC_PUBLIC;
}
$this->class_tree[$c]['userclass_id'] = $c;
$this->class_tree[$c]['userclass_name'] = $d;
$this->class_tree[$c]['userclass_description'] = 'Fixed class';
$this->class_tree[$c]['userclass_visibility'] = e_UC_PUBLIC;
$this->class_tree[$c]['userclass_editclass'] = e_UC_MAINADMIN;
$this->class_tree[$c]['userclass_accum'] = $c;
$this->class_tree[$c]['userclass_type'] = UC_TYPE_STD;
}
}
$userCache = $array->WriteArray($this->class_tree, FALSE);
$e107->ecache->set_sys(UC_CACHE_TAG,$userCache);
unset($userCache);
}
// Now build the tree.
// There are just two top-level classes - 'Everybody' and 'Nobody'
$this->class_parents[e_UC_PUBLIC] = e_UC_PUBLIC;
$this->class_parents[e_UC_NOBODY] = e_UC_NOBODY;
foreach ($this->class_tree as $uc)
{
/*
if ($uc['userclass_parent'] == e_UC_PUBLIC)
{ // Note parent (top level) classes
$this->class_parents[$uc['userclass_id']] = $uc['userclass_id'];
}
else
*/
if (($uc['userclass_id'] != e_UC_PUBLIC) && ($uc['userclass_id'] != e_UC_NOBODY))
{
// if (!array_key_exists($uc['userclass_parent'],$this->class_tree))
if (!isset($this->class_tree[$uc['userclass_parent']]))
{
echo "Orphaned class record: ID=".$uc['userclass_id']." Name=".$uc['userclass_name']." Parent=".$uc['userclass_parent']."<br />";
}
else
{ // Add to array
$this->class_tree[$uc['userclass_parent']]['class_children'][] = $uc['userclass_id'];
}
}
}
}
// Given the list of 'base' classes a user belongs to, returns a comma separated list including ancestors. Duplicates stripped
public function get_all_user_classes($start_list)
{
$is = array();
$start_array = explode(',', $start_list);
foreach ($start_array as $sa)
{ // Merge in latest values - should eliminate duplicates as it goes
if (isset($this->class_tree[$sa]))
{
$is = array_merge($is,explode(',',$this->class_tree[$sa]['userclass_accum']));
}
}
return implode(',',array_unique($is));
}
// Returns a list of user classes which can be edited by the specified classlist (defaults to current user's classes)
public function get_editable_classes($class_list = USERCLASS_LIST, $asArray = FALSE)
{
$ret = array();
$blockers = array(e_UC_PUBLIC => 1, e_UC_READONLY => 1, e_UC_MEMBER => 1, e_UC_NOBODY => 1, e_UC_GUEST => 1, e_UC_NEWUSER => 1);
$possibles = array_flip(explode(',',$class_list));
unset($possibles[e_UC_READONLY]);
foreach ($this->class_tree as $uc => $uv)
{
if (!isset($blockers[$uc]))
{
$ec = $uv['userclass_editclass'];
if (isset($possibles[$ec]))
{
// echo $uc." {$ec} {$uv['userclass_description']}<br />";
$ret[] = $uc;
}
}
}
if ($asArray) { return $ret; }
return implode(',',$ret);
}
// Combines the selected editable classes into the main class list for a user.
// $combined - the complete list of current class memberships
// $possible - the classes which are being edited
// $actual - the actual membership of the editable classes
// All classes may be passed as comma-separated lists or arrays
public function mergeClassLists($combined, $possible, $actual, $asArray = FALSE)
{
if (!is_array($combined)) { $combined = explode(',',$combined); }
if (!is_array($possible)) { $possible = explode(',',$possible); }
if (!is_array($actual)) { $actual = explode(',',$actual); }
$combined = array_flip($combined);
foreach ($possible as $p)
{
if (in_array($p,$actual))
{ // Class must be in final array
$combined[$p] = 1;
}
else
{
unset($combined[$p]);
}
}
$combined = array_keys($combined);
if ($asArray) { return $combined; }
return implode(',', $combined);
}
public function stripFixedClasses($inClasses)
{
$asArray = TRUE;
if (!is_array($inClasses))
{
$asArray = FALSE;
$inClasses = explode(',',$inClasses);
}
$inClasses = array_flip($inClasses);
foreach ($this->fixed_classes as $k => $v)
{
if (isset($inClasses[$k])) { unset($inClasses[$k]); }
}
$inClasses = array_keys($inClasses);
if ($asArray) { return ($inClasses); }
return implode(',',$inClasses);
}
// Given a comma separated list, returns the minimum number of class memberships required to achieve this (i.e. strips classes 'above' another in the tree)
// Requires the class tree to have been initialised
public function normalise_classes($class_list)
{
$drop_classes = array();
$old_classes = explode(',',$class_list);
foreach ($old_classes as $c)
{ // Look at our parents (which are in 'userclass_accum') - if any of them are contained in old_classes, we can drop them.
$tc = array_flip(explode(',',$this->class_tree[$c]['userclass_accum']));
unset($tc[$c]); // Current class should be in $tc anyway
foreach ($tc as $tc_c => $v)
{
if (in_array($tc_c,$old_classes))
{
$drop_classes[] = $tc_c;
}
}
}
$new_classes = array_diff($old_classes,$drop_classes);
return implode(',',$new_classes);
}
/* Generate a dropdown list of user classes from which to select - virtually as r_userclass()
$optlist allows selection of the classes to be shown in the dropdown. All or none can be included, separated by comma. Valid options are:
public
guest
nobody
member
readonly
admin
main - main admin
new - new users
classes - shows all classes
matchclass - if 'classes' is set, this option will only show the classes that the user is a member of
language - list of languages.
blank - puts an empty option at the top of select dropdowns
filter - only show those classes where member is in a class permitted to view them - i.e. as the new 'visible to' field - added for 0.8
force - show all classes (subject to the other options, including matchclass) - added for 0.8
$extra_js - can add JS handlers (e.g. 'onclick', 'onchange') if required
[ $mode parameter of r_userclass() removed - $optlist is more flexible) ]
*/
public function uc_dropdown($fieldname, $curval = 0, $optlist = "", $extra_js = '')
{
global $pref;
$show_classes = self::uc_required_class_list($optlist);
$text = '';
foreach ($show_classes as $k => $v)
{
if ($k == e_UC_BLANK)
{
$text .= "<option value=''>&nbsp;</option>\n";
}
else
{
$s = ($curval == $k && $curval !== '') ? "selected='selected'" : "";
$text .= "<option class='uc-select' value='".$k."' ".$s.">".$v."</option>\n";
}
}
// Inverted Classes
if(strpos($optlist, "no-excludes") !== TRUE)
{
$text .= "\n<optgroup label=\"".UC_LAN_INVERTLABEL."\">\n";
foreach ($show_classes as $k => $v)
{
if($k != '0' && $k!=255 && $k !=251) // remove everyone, nobody and readonly from list.
{
$s = ($curval == ('-'.$k) && $curval !== '') ? "selected='selected'" : "";
$text .= "<option class='uc-select-inverted' value='-".$k."' ".$s.">".str_replace("--CLASS--", $v, UC_LAN_INVERT)."</option>\n";
}
}
$text .= "</optgroup>\n";
}
if (strpos($optlist, "language") !== FALSE && $pref['multilanguage'])
{
$text .= "<optgroup label=' ------ ' />\n";
$tmpl = explode(",",e_LANLIST);
foreach($tmpl as $lang)
{
$s = ($curval == $lang) ? " selected='selected'" : "";
$text .= "<option value='$lang' ".$s.">".$lang."</option>\n";
}
}
// Only return the select box if we've ended up with some options
if ($text) $text = "\n<select class='tbox select' name='{$fieldname}' {$extra_js}>\n".$text."</select>\n";
return $text.$curVal;
}
/*
Generate an ordered array classid=>classname - used for dropdown and check box lists
If $just_ids is TRUE, array value is just '1'
*/
public function uc_required_class_list($optlist = '', $just_ids = FALSE)
{
$ret = array();
if (!$optlist) $optlist = 'public,guest,nobody,member,classes'; // Set defaults to simplify ongoing processing
if ($optlist == 'editable')
{
$temp = array_flip(explode(',',$this->get_editable_classes()));
if ($just_ids) return $temp;
foreach ($temp as $c => $t)
{
$temp[$c] = $this->class_tree[$c]['userclass_name'];
}
return $temp;
}
$opt_arr = explode(',',$optlist);
foreach ($opt_arr as $k => $v)
{
$opt_arr[$k] = trim($v);
}
$opt_arr = array_flip($opt_arr); // This also eliminates duplicates which could arise from applying the other options, although shouldn't matter
if (isset($opt_arr['force'])) unset($opt_arr['filter']);
if (isset($opt_arr['blank']))
{
$ret[e_UC_BLANK] = 1;
}
// Do the 'fixed' classes next
foreach ($this->text_class_link as $k => $v)
{
// if (isset($opt_arr[$k]) || isset($opt_arr['force']))
if (isset($opt_arr[$k]))
{
$ret[$v] = $just_ids ? '1' : $this->fixed_classes[$v];
}
}
// Now do the user-defined classes
if (isset($opt_arr['classes']) || isset($opt_arr['force']))
{ // Display those classes the user is allowed to:
// Main admin always sees the lot
// a) Mask the 'fixed' user classes which have already been processed
// b) Apply the visibility option field ('userclass_visibility')
// c) Apply the matchclass option if appropriate
foreach($this->class_tree as $uc_id => $row)
{
if (!array_key_exists($uc_id,$this->fixed_classes)
&& ( getperms("0")
|| (
(!isset($optlist["matchclass"]) || check_class($uc_id))
&& (!isset($optlist["filter"]) || check_class($row['userclass_visibility']))
)
)
)
{
$ret[$uc_id] = $just_ids ? '1' : $this->class_tree[$uc_id]['userclass_name'];
}
}
}
/* Above loop slightly changes the display order of earlier code versions.
If readonly must be last (after language), delete it from the $text_class_link array, and uncomment the following code
if (isset($opt_arr['readonly']))
{
$ret[e_UC_READONLY] = $this->class_tree[e_UC_READONLY]['userclass_description'];
}
*/
return $ret;
}
/*
Very similar to r_userclass, but returns a list of check boxes. Doesn't encapsulate it.
$fieldname is the name for the array of checkboxes
$curval is a comma separated list of class IDs for boxes which are checked.
$optlist as for uc_dropdown
if $showdescription is TRUE, appends the class description in brackets
*/
public function uc_checkboxes($fieldname, $curval='', $optlist = '', $showdescription = FALSE)
{
global $pref;
$show_classes = $this->uc_required_class_list($optlist);
$curArray = explode(",", $curval); // Array of current values
$ret = "";
foreach ($show_classes as $k => $v)
{
if ($k != e_UC_BLANK)
{
$c = (in_array($k,$curArray)) ? " checked='checked'" : "";
if ($showdescription) $v .= " (".$this->uc_get_classdescription($k).")";
$ret .= "<div class='field-spacer'><input type='checkbox' class='checkbox' name='{$fieldname}[{$k}]' id='{$fieldname}-{$k}' value='{$k}'{$c} /><label for='{$fieldname}-{$k}'>".$v."</label></div>\n";
}
}
if (strpos($optlist, "language") !== FALSE && $pref['multilanguage'])
{
$ret .= "<div class='separator'><!-- --></div>\n";
$tmpl = explode(",",e_LANLIST);
foreach($tmpl as $lang)
{
$c = (in_array($lang, $curArray)) ? " checked='checked' " : "";
$ret .= "<div class='field-spacer'><input type='checkbox' class='checkbox' name='{$fieldname}[{$lang}]' id='{$fieldname}-{$lang}' value='1'{$c} /><label for='{$fieldname}-{$lang}'>{$lang}</label></div>";
}
}
return $ret;
}
/*
Next two routines create an indented tree - for example within a select box or a list of check boxes.
For each displayed element, the callback routine is called
$treename is the name given to the elements where required
$callback is a routine used to generate each element; there are two implemented within this class:
select (the default) - generates the option list. Text requires to be encapsulated in a <select......./select> tag set
- can also be used with multi-select boxes
checkbox - generates a set of checkboxes
Alternative callbacks can be used to achieve different layouts/styles
$current_value is a single class number for single-select dropdown; comma separated array of class numbers for checkbox list or multi-select
$optlist works the same as for other class displays
*/
protected function vetted_sub_tree($treename, $callback,$listnum,$nest_level,$current_value, $perms, $opt_options)
{
$ret = '';
$nest_level++;
if(isset($this->class_tree[$listnum]['class_children']))
{
foreach ($this->class_tree[$listnum]['class_children'] as $p)
{
// Looks like we don't need to differentiate between function and class calls
if (isset($perms[$p]))
{
$ret .= call_user_func($callback,$treename, $p,$current_value,$nest_level, $opt_options);
}
$ret .= $this->vetted_sub_tree($treename, $callback,$p,$nest_level,$current_value, $perms, $opt_options);
}
}
return $ret;
}
public function vetted_tree($treename, $callback='', $current_value='', $optlist = '',$opt_options = '')
{
$ret = '';
if (!$callback) $callback=array($this,'select');
$current_value = str_replace(' ','',$current_value); // Simplifies parameter passing for the tidy-minded
$perms = $this->uc_required_class_list($optlist,TRUE); // List of classes which we can display
if (isset($perms[e_UC_BLANK]))
{
$ret .= call_user_func($callback,$treename, e_UC_BLANK, $current_value,0, $opt_options);
}
foreach ($this->class_parents as $p)
{
if (isset($perms[$p]))
{
$ret .= call_user_func($callback,$treename, $p,$current_value,0, $opt_options);
}
$ret .= $this->vetted_sub_tree($treename, $callback,$p,0, $current_value, $perms, $opt_options);
}
return $ret;
}
// Callback for vetted_tree - Creates the option list for a selection box
public function select($treename, $classnum, $current_value, $nest_level)
{
if ($classnum == e_UC_BLANK) return "<option value=''>&nbsp;</option>\n";
// echo "Display: {$classnum}, {$current_value}, {$nest_level}<br />";
$tmp = explode(',',$current_value);
$sel = in_array($classnum,$tmp) ? " selected='selected'" : '';
if ($nest_level == 0)
{
$prefix = '';
$style = " style='font-weight:bold; font-style: italic;'";
}
elseif ($nest_level == 1)
{
$prefix = '&nbsp;&nbsp;';
$style = " style='font-weight:bold'";
}
else
{
$prefix = '&nbsp;&nbsp;'.str_repeat('--',$nest_level-1).'>';
$style = '';
}
return "<option value='{$classnum}'{$sel}{$style}>".$prefix.$this->class_tree[$classnum]['userclass_name']."</option>\n";
}
// Callback for vetted_tree - displays indented checkboxes with class name only
public function checkbox($treename, $classnum, $current_value, $nest_level)
{
if ($classnum == e_UC_BLANK) return '';
$tmp = explode(',',$current_value);
$chk = in_array($classnum, $tmp) ? " checked='checked'" : '';
if ($nest_level == 0)
{
$style = " style='font-weight:bold'";
}
else
{
$style = " style='text-indent:".(1.2*$nest_level)."em'";
}
return "<div {$style}><input type='checkbox' class='checkbox' name='{$treename}[]' id='{$treename}_{$classnum}' value='{$classnum}'{$chk} />".$this->class_tree[$classnum]['userclass_name']."</div>\n";
}
// Callback for vetted_tree - displays indented checkboxes with class name, and description in brackets
public function checkbox_desc($treename, $classnum, $current_value, $nest_level)
{
if ($classnum == e_UC_BLANK) return '';
$tmp = explode(',',$current_value);
$chk = in_array($classnum, $tmp) ? " checked='checked'" : '';
if ($nest_level == 0)
{
$style = " style='font-weight:bold'";
}
else
{
$style = " style='text-indent:".(1.2*$nest_level)."em'";
}
return "<div {$style}><input type='checkbox' class='checkbox' name='{$treename}[]' id='{$treename}_{$classnum}' value='{$classnum}'{$chk} />".$this->class_tree[$classnum]['userclass_name'].' ('.$this->class_tree[$classnum]['userclass_description'].")</div>\n";
}
/*
Return array of all classes, limited according to membership of the userclass_visibility field if $filter is set.
Index field - userclass_id
Data fields - userclass_name, userclass_description, userclass_editclass
*/
public function uc_get_classlist($filter = FALSE)
{
$ret = array();
$this->readTree(FALSE); // Make sure we have data
foreach ($this->class_tree as $k => $v)
{
if (!$filter || check_class($filter))
{
$ret[$k] = array('userclass_name' => $v, 'userclass_description' => $v['userclass_description'], 'userclass_editclass' => $v['userclass_editclass']);
}
}
return $ret;
}
// Return class name for given class ID
public function uc_get_classname($id)
{
if (isset($this->class_tree[$id]))
{
return $this->class_tree[$id]['userclass_name'];
}
if (isset($this->fixed_classes[$id]))
{
return $this->fixed_classes[$id];
}
if($id < 0)
{
$val = abs($id);
$name = isset($this->class_tree[$val]['userclass_name']) ? $this->class_tree[$val]['userclass_name'] : $this->fixed_classes[$val];
return str_replace("--CLASS--", $name, UC_LAN_INVERT);
}
return '';
}
public function uc_get_classdescription($id)
{
if (isset($this->class_tree[$id]))
{
return $this->class_tree[$id]['userclass_description'];
}
if (isset($this->fixed_classes[$id]))
{
return $this->fixed_classes[$id]; // Name and description the same for fixed classes
}
return '';
}
public function uc_get_classicon($id)
{
if (isset($this->class_tree[$id]))
{
return $this->class_tree[$id]['userclass_icon'];
}
return '';
}
// Given a class name, look up the ID. Return FALSE if not found
public function ucGetClassIDFromName($name)
{
$this->readTree();
// We have all the info - can just search the array
foreach ($this->class_tree as $uc => $info)
{
if ($info['userclass_name'] == $name)
{
return $uc;
}
}
return FALSE; // not found
}
// Utility to remove a specified class ID from the default comma-separated list
public function ucRemove($classID, $from, $asArray = FALSE)
{
$tmp = array_flip(explode(',',$from));
if (isset($tmp[$classID]))
{
unset($tmp[$classID]);
}
$tmp = array_keys($tmp);
if ($asArray) { return $tmp; }
if (count($tmp) == 0) { return ''; }
return implode(',',$tmp);
}
// Utility to add a specified class ID to the default comma-separated list
public function ucAdd($classID, $to, $asArray = FALSE)
{
$tmp = array_flip(explode(',',$to));
$tmp[$classID] = 1;
$tmp = array_keys($tmp);
if ($asArray) { return $tmp; }
return implode(',',$tmp);
}
// See if a class can be edited (in the sense of the class ID not being fixed) - return TRUE if permitted.
public function isEditableClass($classID)
{
if (($classID >= e_UC_SPECIAL_BASE) && ($classID <= e_UC_SPECIAL_END)) return FALSE; // Don't allow deletion of fixed classes
if (isset($this->fixed_classes[$class_id])) return FALSE; // This picks up classes such as e_UC_PUBLIC outside the main range which can't be deleted
return TRUE;
}
/*
Return all users in a particular class or set of classes.
$classlist is a comma separated list of classes - if the 'predefined' classes are required, they must be included. No spaces allowed
$field_list is used to select the returned fields ($user_id is the primary index)
****** Can be verrrrryyyy slow - has to scan the whole user database at present ******
********* NOT TESTED **********
***** NOT SURE WHETHER THIS IS REALLY A USER OR A USER CLASS FUNCTION *****
*/
public function get_users_in_class($classlist, $field_list = 'user_name, user_loginname', $include_ancestors = FALSE, $order_by = 'user_id')
{
$ret = array();
if ($include_ancestors) $classlist = $this->get_all_user_classes($classlist);
$class_regex = "(^|,)(".str_replace(' ','',str_replace(",", "|", $classlist)).")(,|$)";
$qry = "SELECT 'user_id,{$field_list}' FROM `user` WHERE user_class REGEXP '{$class_regex}' ORDER BY '{$order_by}'";
if ($this->sql_r->db_Select_gen($qry))
{
while ($row = $this->sql_r->db_Fetch(MYSQL_ASSOC))
{
$ret[$row['user_id']] = $row;
}
}
return $ret;
}
}
//========================================================================
// Functions from previous userclass_class handler
//========================================================================
// Implemented for backwards compatibility/convenience.
// ************** DEPRECATED - use new class-based functions
/*
With $optlist you can now specify which classes are shown in the dropdown.
All or none can be included, separated by comma (or whatever).
Valid options are:
public
guest
nobody
member
readonly
admin
main - main admin
classes - shows all classes
matchclass - if 'classes' is set, this option will only show the classes that the user is a member of
language - list of languages.
filter - only show those classes where member is in a class permitted to view them - i.e. as the new 'visible to' field
force - show all classes (subject to the other options, including matchclass)
$mode = 'off' turns off listing of admin/main admin classes unless enabled in $optlist (can probably be deprecated - barely used)
*/
function r_userclass($fieldname, $curval = 0, $mode = "off", $optlist = "")
{
// echo "Call r_userclass{$fieldname}, CV: {$curval} opts: {$optlist}<br />";
global $e_userclass;
if ($mode != 'off')
{ // Handle legacy code
if ($optlist) $optlist .= ',';
$optlist .= 'admin,main';
if ($mode != 'admin') $optlist .= ',readonly';
}
if (!is_object($e_userclass)) $e_userclass = new user_class;
return $e_userclass->uc_dropdown($fieldname,$curval,$optlist);
}
// Very similar to r_userclass, but returns a list of check boxes. (currently only used in newspost.php)
// $curval is a comma separated list of class IDs for boxes which are checked.
function r_userclass_check($fieldname, $curval = '', $optlist = "")
{
// echo "Call r_userclass_check: {$curval}<br />";
global $e_userclass;
if (!is_object($e_userclass)) $e_userclass = new user_class;
$ret = $e_userclass->uc_checkboxes($fieldname,$curval,$optlist);
if ($ret) $ret = "<div class='check-block'>".$ret."</div>";
return $ret;
}
function get_userclass_list()
{
// echo "Call get_userclass_list<br />";
global $e_userclass;
if (!is_object($e_userclass)) $e_userclass = new user_class;
return $e_userclass->uc_get_classlist();
}
function r_userclass_name($id)
{
// echo "Call r_userclass_name<br />";
global $e_userclass;
if (!is_object($e_userclass)) $e_userclass = new user_class;
return $e_userclass->uc_get_classname($id);
}
// Deprecated functions to hopefully be removed
function r_userclass_radio($fieldname, $curval = '')
{
echo "Deprecated function r_userclass_radio not used in core - mutter if you'd like it implemented<br />";
}
//========================================================================
// Admin Class handler - could go into separate file later
//========================================================================
class user_class_admin extends user_class
{
var $field_list = array('userclass_name' => "varchar(100) NOT NULL default ''",
'userclass_description' => "varchar(250) NOT NULL default ''",
'userclass_editclass' => "tinyint(3) unsigned NOT NULL default '0'",
'userclass_parent' => "tinyint(3) unsigned NOT NULL default '0'",
'userclass_accum' => "varchar(250) NOT NULL default ''",
'userclass_visibility' => "tinyint(3) unsigned NOT NULL default '0'",
'userclass_type' =>"tinyint(1) unsigned NOT NULL default '0'",
'userclass_icon' => "varchar(250) NOT NULL default ''"
); // Note - 'userclass_id' intentionally not in this list
// Icons to use for graphical tree display
// First index - no children, children
// Second index - not last item, last item
// Third index - closed tree, open tree
var $tree_icons = array( );
var $graph_debug = FALSE; // Shows extra info on graphical tree when TRUE
function user_class_admin()
{
parent::user_class(); // Call constructor from ancestor class
$this->isAdmin = TRUE;
// Have to initialise the images this way - PHP4 won't take a nested array assignment in the variable list
$this->tree_icons = array(
FALSE => array( // No children
FALSE => array( // Not last item
FALSE => '', // Closed tree - don't display
TRUE => 'branch.gif'
)
,
TRUE => array( // Last item
FALSE => '', // Closed tree - don't display
TRUE => 'branchbottom.gif'
)
),
TRUE => array( // children
FALSE => array( // Not last item
FALSE => 'plus.gif', // Closed tree - option to expand
TRUE => 'minus.gif'
)
,
TRUE => array( // Last item
FALSE => 'plusbottom.gif', // Closed tree - option to expand
TRUE => 'minusbottom.gif'
))
);
}
/*
Next three routines are used to update the database after adding/deleting a class
*/
public function calc_tree()
{
// echo "Calc Tree<br />";
$this->readTree(TRUE); // Make sure we have accurate data
foreach ($this->class_parents as $cp)
{
$rights = array();
$this->rebuild_tree($cp,$rights); // increasing rights going down the tree
}
}
// Internal function, called recursively to rebuild the permissions tree where rights increase going down the tree
// $parent is the class number being processed.
// $rights is the array of rights accumulated so far in the walk down the tree
protected function rebuild_tree($parent, $rights)
{
if ($this->class_tree[$parent]['userclass_parent'] == e_UC_NOBODY)
{
$this->topdown_tree($parent);
return;
}
// echo "Bottom up: {$parent}<br />";
if ($this->class_tree[$parent]['userclass_type'] == UC_TYPE_GROUP)
{
// echo "Bottom up - skip: {$parent}<br />";
return; // Probably just stop here for a group class
}
$rights[] = $parent;
$imp_rights = implode(',',$rights);
if ($this->class_tree[$parent]['userclass_accum'] != $imp_rights)
{
$this->class_tree[$parent]['userclass_accum'] = $imp_rights;
if (!isset($this->class_tree[$cp]['change_flag'])) $this->class_tree[$parent]['change_flag'] = 'UPDATE';
}
foreach ($this->class_tree[$parent]['class_children'] as $cc)
{
$this->rebuild_tree($cc,$rights); // Recursive call
}
}
// Internal function, called recursively to rebuild the permissions tree where rights increase going up the tree
// Returns an array
protected function topdown_tree($our_class)
{
$rights = array($our_class); // Accumulator always has rights to its own class
if ($this->class_tree[$our_class]['userclass_type'] == UC_TYPE_GROUP) return array_merge($rights, explode(',',$this->class_tree[$our_class]['userclass_accum'])); // Stop rights accumulation at a group
foreach ($this->class_tree[$our_class]['class_children'] as $cc)
{
$rights = array_merge($rights,$this->topdown_tree($cc)); // Recursive call
}
$rights = array_unique($rights);
$imp_rights = implode(',',$rights);
// echo "Class: {$our_class} Rights: {$imp_rights}<br />";
if ($this->class_tree[$our_class]['userclass_accum'] != $imp_rights)
{
$this->class_tree[$our_class]['userclass_accum'] = $imp_rights;
$this->class_tree[$our_class]['change_flag'] = 'UPDATE';
}
return $rights;
}
public function save_tree()
{
foreach ($this->class_tree as $tree)
{
if (isset($tree['change_flag']))
{
switch ($tree['change_flag'])
{
case 'INSERT' :
$this->add_new_class($tree);
break;
case 'UPDATE' :
$this->save_edited_class($tree);
break;
default :
continue;
}
}
}
}
/*
Next two routines show a text-based tree with markers to indicate the hierarchy.
*/
protected function show_sub_tree($listnum,$marker, $add_class = FALSE)
{
$ret = '';
$marker = '--'.$marker;
foreach ($this->class_tree[$listnum]['class_children'] as $p)
{
$ret .= $marker.$this->class_tree[$p]['userclass_id'].':'.$this->class_tree[$p]['userclass_name'];
if ($add_class) $ret .= " (".$this->class_tree[$p]['userclass_accum'].")";
$ret .= " Children: ".count($this->class_tree[$p]['class_children']);
$ret .= "<br />";
$ret .= $this->show_sub_tree($p,$marker, $add_class);
}
return $ret;
}
public function show_tree($add_class = FALSE)
{
$ret = '';
foreach ($this->class_parents as $p)
{
$ret .= $this->class_tree[$p]['userclass_id'].':'.$this->class_tree[$p]['userclass_name'];
if ($add_class) $ret .= " (".$this->class_tree[$p]['userclass_accum'].")";
$ret .= " Children: ".count($this->class_tree[$p]['class_children']);
$ret .= "<br />";
$ret .= $this->show_sub_tree($p,'>', $add_class);
}
return $ret;
}
/*
Next two routines generate a graphical tree, including option to open/close branches
*/
protected function show_graphical_subtree($listnum, $indent_images, $is_last = FALSE)
{
$num_children = count($this->class_tree[$listnum]['class_children']);
$is_open = TRUE;
$tag_name = 'uclass_tree_'.$listnum;
$ret = "<div class='uclass_tree' style='height: 20px'>\n";
foreach ($indent_images as $im)
{
$ret .= "<img src='".UC_ICON_DIR.$im."' alt='class icon' />";
}
// If this link has children, wrap the next image in a link and an expand/hide option
if ($num_children)
{
$ret .= "<span onclick=\"javascript: expandit('{$tag_name}'); expandit('{$tag_name}_p'); expandit('{$tag_name}_m')\"><img src='".UC_ICON_DIR.$this->tree_icons[TRUE][$is_last][TRUE]."' alt='class icon' id='{$tag_name}_m' />";
$ret .= "<img src='".UC_ICON_DIR.$this->tree_icons[TRUE][$is_last][FALSE]."' style='display:none' id='{$tag_name}_p' alt='class icon' /></span>\n";
}
else
{
$ret .= "<img src='".UC_ICON_DIR.$this->tree_icons[FALSE][$is_last][$is_open]."' alt='class icon' />\n";
}
$name_line = '';
if ($this->graph_debug) { $name_line = $this->class_tree[$listnum]['userclass_id'].":"; }
// if ($this->graph_debug) { $name_line = varset($this->class_tree[$listnum]['userclass_id'], 'XXX').":"; }
if ($this->class_tree[$listnum]['userclass_type'] == UC_TYPE_GROUP)
{
$name_line .= '<b>'.$this->class_tree[$listnum]['userclass_name'].'</b> '.UCSLAN_84; // Highlight groups
}
else
{
$name_line .= $this->class_tree[$listnum]['userclass_name'];
}
if ($this->graph_debug) $name_line .= "[vis:".$this->class_tree[$listnum]['userclass_visibility'].", edit:".$this->class_tree[$listnum]['userclass_editclass']."] = ".$this->class_tree[$listnum]['userclass_accum']." Children: ".implode(',',$this->class_tree[$listnum]['class_children']);
// Next (commented out) line gives a 'conventional' link
$ret .= "<img src='".UC_ICON_DIR."topicon.png' alt='class icon' /><a style='text-decoration: none' class='userclass_edit' href='".e_ADMIN_ABS."userclass2.php?config.edit.{$this->class_tree[$listnum]['userclass_id']}'>".$name_line."</a></div>";
// $ret .= "<img src='".UC_ICON_DIR."topicon.png' alt='class icon' /><a style='text-decoration: none' class='userclass_edit' href='".e_ADMIN_ABS."userclass2.php?config.edit.{$this->class_tree[$listnum]['userclass_id']}'>".$this->class_tree[$listnum]['userclass_name']."</a></div>";
//$ret .= "<img src='".UC_ICON_DIR."topicon.png' alt='class icon' />
//<span style='cursor:pointer; vertical-align: bottom' onclick=\"javascript: document.location.href='".e_ADMIN."userclass2.php?config.edit.{$this->class_tree[$listnum]['userclass_id']}'\">".$name_line."</span></div>";
// vertical-align: middle doesn't work! Nor does text-top
if ($num_children)
{
$ret .= "<div class='uclass_tree' id='{$tag_name}'>\n";
$image_level = count($indent_images);
if ($is_last)
{
$indent_images[] = 'linebottom.gif';
}
else
{
$indent_images[] = 'line.gif';
}
foreach ($this->class_tree[$listnum]['class_children'] as $p)
{
$num_children--;
if ($num_children)
{ // Use icon indicating more below
$ret .= $this->show_graphical_subtree($p, $indent_images, FALSE);
}
else
{ // else last entry on this tree
$ret .= $this->show_graphical_subtree($p, $indent_images, TRUE);
}
}
$ret .= "</div>";
}
return $ret;
}
public function show_graphical_tree($show_debug=FALSE)
{
$this->graph_debug = $show_debug;
$indent_images = array();
$ret = "<div class='uclass_tree' style='height:16px'>
<img src='".UC_ICON_DIR."topicon.png' alt='class icon' style='vertical-align: bottom' />
<span style='top:3px'></span>
</div>"; // Just a generic icon here to provide a visual anchor
$num_parents = count($this->class_parents);
foreach ($this->class_parents as $p)
{
$num_parents--;
$ret .= $this->show_graphical_subtree($p, $indent_images, ($num_parents == 0));
}
return $ret;
}
// Creates an array which contains only DB fields (i.e. strips the added status)
protected function copy_rec($classrec, $inc_id = FALSE)
{
$ret = array();
if ($inc_id && isset($classrec['userclass_id'])) $ret['userclass_id'] = $classrec['userclass_id'];
foreach ($this->field_list as $fl => $val)
{
if (isset($classrec[$fl])) $ret[$fl] = $classrec[$fl];
}
return $ret;
}
// Return an unused class ID - FALSE if none spare. Misses the predefined classes.
public function findNewClassID()
{
$i = 1;
// Start by allocating a new class with a number higher than any previously allocated
foreach ($this->class_tree as $id => $r)
{
if ($id < e_UC_SPECIAL_BASE)
{
$i = max($i,$id);
}
}
$i++;
if ($i < e_UC_SPECIAL_BASE) return $i;
// Looks like we've had a lot of activity in classes - try and find a gap.
for ($i = 1; ($i < e_UC_SPECIAL_BASE); $i++)
{
if (!isset($this->class_tree[$i])) return $i;
}
// Big system!! Assign a class in the 0.8-only block above 255
for ($i = e_UC_SPECIAL_END+1; ($i < 32767); $i++)
{
if (!isset($this->class_tree[$i])) return $i;
}
return FALSE; // Just in case all classes assigned!
}
// Add new class. Class ID must be in the passed record.
// Return TRUE on success, FALSE on failure
public function add_new_class($classrec)
{
if (!isset($classrec['userclass_id']))
{
return FALSE;
}
if ($classrec['userclass_type'] == UC_TYPE_GROUP)
{ // Need to make sure our ID is in the accumulation array
$temp = explode(',',$classrec['userclass_accum']);
if (!in_array($classrec['userclass_id'], $temp))
{
$temp[] = $classrec['userclass_id'];
$classrec['userclass_accum'] = implode(',',$temp);
}
}
if ($this->sql_r->db_Insert('userclass_classes',$this->copy_rec($classrec, TRUE)) === FALSE)
{
return FALSE;
}
$this->clearCache();
return TRUE;
}
public function save_edited_class($classrec)
{
if (!$classrec['userclass_id'])
{
echo "Programming bungle on save<br />";
return FALSE;
}
$qry = '';
$spacer = '';
if ($classrec['userclass_type'] == UC_TYPE_GROUP)
{ // Need to make sure our ID is in the accumulation array
$temp = explode(',',$classrec['userclass_accum']);
if (!in_array($classrec['userclass_id'], $temp))
{
$temp[] = $classrec['userclass_id'];
$classrec['userclass_accum'] = implode(',',$temp);
}
}
foreach ($this->field_list as $fl => $val)
{
if (isset($classrec[$fl]))
{
$qry .= $spacer."`".$fl."` = '".$classrec[$fl]."'";
$spacer = ", ";
}
}
if ($this->sql_r->db_Update('userclass_classes', $qry." WHERE `userclass_id`='{$classrec['userclass_id']}'") === FALSE)
{
return FALSE;
}
$this->clearCache();
return TRUE;
}
public function queryCanDeleteClass($classID)
{
if (($classID >= e_UC_SPECIAL_BASE) && ($classID <= e_UC_SPECIAL_END)) return FALSE; // Don't allow deletion of fixed classes
if (isset($this->fixed_classes[$class_id])) return FALSE; // This picks up classes such as e_UC_PUBLIC outside the main range which can't be deleted
if (!isset($this->class_tree[$class_id])) return FALSE;
if (count($this->class_tree[$class_id]['class_children'])) return FALSE; // Can't delete class with descendants
foreach ($this->class_tree as $c)
{
if ($c['userclass_editclass'] == $classID) return FALSE;
if ($c['userclass_visibility'] == $classID) return FALSE;
}
return TRUE;
}
// Delete a class
// Return TRUE on success, FALSE on error
public function delete_class($classID)
{
if (self::queryCanDeleteClass($classID) === FALSE) return FALSE;
if ($this->sql_r->db_Delete('userclass_classes', "`userclass_id`='{$classID}'") === FALSE) return FALSE;
$this->clearCache();
$this->readTree(TRUE); // Re-read the class tree
return TRUE;
}
// Delete a class, and all users who are members of that class.
// Return TRUE on success, FALSE on error
public function deleteClassAndUsers($classID)
{
if (self::delete_class($classID) === TRUE)
{
if ($this->sql_r->db_Select('user', 'user_id, user_class', "user_class REGEXP '(^|,){$classID}(,|$)'"))
{
$sql2 = new db;
while ($row = $this->sql_r->db_Fetch())
{
$newClass = self::ucRemove($classID,$row['user_class']);
$sql2->db_Update('user', "user_class = '{$newClass}' WHERE user_id = {$row['user_id']}");
}
}
return TRUE;
}
return FALSE;
}
// Moved in from e_userclass class
// $uinfoArray is array(uid=>user_class)
// Adds all users in list to class $ci
public function class_add($cid, $uinfoArray)
{
$e107 = e107::getInstance();
$uc_sql = new db;
foreach($uinfoArray as $uid => $curclass)
{
if ($curclass)
{
$newarray = array_unique(array_merge(explode(',', $curclass), array($cid)));
$new_userclass = implode(',', $newarray);
}
else
{
$new_userclass = $cid;
}
$uc_sql->db_Update('user', "user_class='".$e107->tp->toDB($new_userclass, true)."' WHERE user_id=".intval($uid));
}
}
// Moved in from e_userclass class
// $uinfoArray is array(uid=>user_class)
// Removes all users in list from class $ci
public function class_remove($cid, $uinfoArray)
{
$e107 = e107::getInstance();
$uc_sql = new db;
foreach($uinfoArray as $uid => $curclass)
{
$newarray = array_diff(explode(',', $curclass), array('', $cid));
$new_userclass = implode(',', $newarray);
$uc_sql->db_Update('user', "user_class='".$e107->tp->toDB($new_userclass, true)."' WHERE user_id=".intval($uid));
}
}
// Certain fields on admin records have constraints on their values.
// Checks the passed array, and updates any values which are unacceptable.
// Returns TRUE if nothing changed, FALSE if changes made
public function checkAdminInfo(&$data, $id)
{
$ret = TRUE;
if (($id < e_UC_SPECIAL_BASE) || ($id > e_UC_SPECIAL_END)) return TRUE;
if (isset($data['userclass_parent']))
{
if (($data['userclass_parent'] < e_UC_SPECIAL_BASE) || ($data['userclass_parent'] > e_UC_SPECIAL_END))
{
$data['userclass_parent'] = e_UC_NOBODY;
$ret = FALSE;
}
}
if (isset($data['userclass_editclass']))
{
if ($id == e_UC_MAINADMIN)
{
if ($data['userclass_editclass'] < e_UC_MAINADMIN)
{
$data['userclass_editclass'] = e_UC_MAINADMIN;
$ret = FALSE;
}
}
elseif (($data['userclass_editclass'] < e_UC_SPECIAL_BASE) || ($data['userclass_editclass'] > e_UC_SPECIAL_END))
{
$data['userclass_editclass'] = e_UC_MAINADMIN;
$ret = FALSE;
}
}
return $ret;
}
// Set default tree structure
public function set_default_structure()
{
// If they don't exist, we need to create class records for the 'standard' user classes
$init_list = array(
array('userclass_id' => e_UC_MEMBER, 'userclass_name' => UC_LAN_3,
'userclass_description' => UCSLAN_75,
'userclass_editclass' => e_UC_MAINADMIN,
'userclass_parent' => e_UC_PUBLIC,
'userclass_visibility' => e_UC_MEMBER
),
array('userclass_id' => e_UC_ADMINMOD, 'userclass_name' => UC_LAN_8,
'userclass_description' => UCSLAN_74,
'userclass_editclass' => e_UC_MAINADMIN,
'userclass_parent' => e_UC_MAINADMIN,
'userclass_visibility' => e_UC_MEMBER
),
array('userclass_id' => e_UC_ADMIN, 'userclass_name' => UC_LAN_5,
'userclass_description' => UCSLAN_76,
'userclass_editclass' => e_UC_MAINADMIN,
'userclass_parent' => e_UC_ADMINMOD,
'userclass_visibility' => e_UC_MEMBER
),
array('userclass_id' => e_UC_MAINADMIN, 'userclass_name' => UC_LAN_6,
'userclass_description' => UCSLAN_77,
'userclass_editclass' => e_UC_MAINADMIN,
'userclass_parent' => e_UC_NOBODY,
'userclass_visibility' => e_UC_MEMBER
),
array('userclass_id' => e_UC_MODS, 'userclass_name' => UC_LAN_7,
'userclass_description' => UCSLAN_78,
'userclass_editclass' => e_UC_MAINADMIN,
'userclass_parent' => e_UC_ADMINMOD,
'userclass_visibility' => e_UC_MEMBER
),
array('userclass_id' => e_UC_NEWUSER, 'userclass_name' => UC_LAN_9,
'userclass_description' => UCSLAN_87,
'userclass_editclass' => e_UC_MAINADMIN,
'userclass_parent' => e_UC_MEMBER,
'userclass_visibility' => e_UC_ADMIN
)
);
foreach ($init_list as $entry)
{
if ($this->sql_r->db_Select('userclass_classes','*',"userclass_id='".$entry['userclass_id']."' "))
{
$this->sql_r->db_Update('userclass_classes', "userclass_parent='".$entry['userclass_parent']."', userclass_visibility='".$entry['userclass_visibility']."' WHERE userclass_id='".$entry['userclass_id']."'");
}
else
{
$this->add_new_class($entry);
}
}
}
public function clearCache()
{
$e107 = e107::getInstance();
$e107->ecache->clear_sys(UC_CACHE_TAG);
}
}
?>
Reference in New Issue View Git Blame Copy Permalink