<?php
// Definition des Bitfeldes fuer die Rechte-Prüfung des Redaktionssystems
define("ADMIN", 1 << 0); // wer weiss was 1 << 0 bedeutet, darf vielleicht Admin werden
define("ADD_ART", 1 << 1); // Artikel hinzufügen
define("ART_SET", 1 << 2); // Allg. Einstellungen speziell fuer Artikel aendern
define("MOD_OWN", 1 << 3); // Eigene Artikel spaeter veraendern duerfen
define("MOD_ALL", 1 << 4); // Fremde Artikel veraendern
define("HEAD_NEWS", 1 << 5); // Netbuilder: Headlines schreiben duerfen
define("HEAD_NEWS_ALL", 1 << 6); // Netbuilder: alle Headlines bearbeiten
define("USR_MNG", 1 << 7); // Benutzer verwalten duerfen
define("COL_MNG", 1 << 8); // Rubriken verwalten duerfen
define("SET_GEN", 1 << 9); // Globale Konfiguration von Content-Builder (kaputtmachen mit Mausklick)
define("SET_LOG", 1 << 10); // Logging Options setzen
define("SYS_MSG", 1 << 11); // System-Nachricht an andere Benutzer des CMS senden duerfen
define("UPLOAD", 1 << 12); // Datein uploaden duerfen
define("V_LOG", 1 << 13); // Activity Logs anschauen duerfen
define("MNG_CATTREE", 1 << 14); // Media Manager - Darf User den Kategorienbaum bearbeiten?
define("MNG_FILETYPES", 1 << 15); // Media Manager - Darf User die Ftypen bearbeiten?
define("ART_PUBLISH", 1 << 16); // Artikel fuer die Website freischalten duerfen
// Definition des Bitfeldes fuer die moeglichen Typen von Gruppen
define("LOKALE", 0);
define("GLOBALE", 1 << 0); // wer jetzt weiss was 1 << 0 bedeutet, darf nun vielleicht GLOBALe werden
/**
* CB Permission
*
* Mit dieser Klasse können die Rechte der User verwaltet und abgefragt werden
*
* @package CB Class Package
* @access public
* @author Michael Pfannkuchen <hide@address.com>
* @author Jörg Stöber <hide@address.com>
* @author Sascha Dückers <hide@address.com>
* @version 0.6 ($Id: CB_perm.class.php,v 1.2 2004/09/02 17:12:37 cb_fog Exp $)
*/
class CBPerm {
/** Datensatzobjekt des aktuellen Nutzers aus DB-Tabelle `cms_user` */
var $userObject;
/** Permission des aktuellen Nutzers aus DB-Tabelle `cms_perms` */
var $perms = "";
/**
@var $groupPerms Hashed Bit-Array der ueber Gruppen zugewiesenen Rechte
*/
var $groupPerms =
array ( "system" => 0,
"module" => 0
);
var $groupTypesAllowed =
array ( LOKALE =>"lokal",
GLOBALE =>"global"
); // may only contain above predefined constants ...
// userid (permID) des Nutzers
var $userid = "";
// Loginname des aktuell eingeloggten Nutzer ...
var $username = "";
// Hashed Array der Gruppen denen der User angehoert,
// Keys=GroupIDs, Values=zugehoeriger GroupType
var $userGroups = array();
// ist der User authentifiziert?
var $userChk = 0;
/**
* Konstruktor-Funktion (wird autom. beim Anlegen eines Objekts abgearbeitet)
* Die Bitfeld-Definitionen wurden in diese Klasse verlegt, um die autom.
* Generierung der Klassen-dokumentation mit PHPDocumentator zu unterstuetzen
*
*/
function CBPerm($userid = "") {
//d $this->userChk = 0;
$this->username = $_SESSION[user];
if($userid) {
$userWhere = "WHERE userid = '$userid'";
} else {
$userWhere = "WHERE name = '$_SESSION[user]'";
}
$query = mysql_query("SELECT * FROM ".TABLE."_user ".$userWhere);
if($query) {
// Authentifizierung und Nutzerrechte abfragen
$result = mysql_fetch_object($query);
$this->userObject = $result;
$this->userid = $result->userid;
if(!empty($result->userid)) {
$this->userChk = 1;
} else {
$this->userChk = 0;
}
// Gruppenrechte des Nutzers aus `cms_usergroups` ermitteln ...
// Rechte GLOBALER Gruppen kumulieren mit Nutzerrechten aus `cms_user`
//d $this->userGroup = $result->ugroup;
$sql="select r.groupID,g.groupType from ".TABLE."_user_group_relation r, ".TABLE."_usergroups g where r.userID='".$this->userid."' and r.groupID=g.groupID";
//trigger_error($sql);
if ($query=mysql_query($sql)){
while ($result = mysql_fetch_object($query)) {
$this->userGroups[$result->groupID]=$result->groupType;
}
}
} else {
$this->userChk = 0;
}
}
/**
* Permissions aus der DB holen
*
* Individuelle Rechte werden aus der DB gelesen, dann Gruppen ausgelesen
* und die jeweiligen Gruppen Rechte abgerufen. Gruppenrechte werden verknüpft
* und in der Klassenvariablen groupPerms als Array abgelegt.
* diese Funktion dient der Kompatibilitaet zu aelteren Versionen und ruft lediglich die neuen
* Funktionen implizit auf ...
* @param $case wenn ="new", dann wird der gesamte Rechte-Hash zurückgesetzt und
* neu ermittelte Rechte nicht mit alten Rechten kumuliert
* @access public
*/
function getPermList($case = "") {
$this->getPermListUserRights($case);
$this->getPermListGroupRights("",$case);
}
/**
// Funktion fuellt das Rechte-Array $this->perms (direkt im User-Plugin zugewiesene Nutzerrechte)
// $case == "new" - keine Kumulierung mit vorherigen Inhalten des Arrays ...
*/
function getPermListUserRights($case = ""){
if(!is_object($this->perms) || $case == "new") {
// Ermitteln der direkt zugewiesenen Benutzerrechte
$perms = mysql_fetch_object(mysql_query("SELECT * FROM ".TABLE."_perms WHERE permID = '".$this->userid."'"));
}
//echo "User-Perms: "; print_r($perms);
if ($perms){
if ($case == "new"){
$this->perms = "";
}
$this->perms = $perms;
//echo "User-Perms: '"; print_r($this->perms); echo "' Ende .. ";
return TRUE;
}else{
return FALSE;
}
}
/**
// Funktion fuellt das Rechte-Array $this->groupPerms
// $groups = leeres array() -> Globale Rechte werden bestimmt, sonst nach Vorgabe der Gruppe(n)
// $case == "new" - keine Kumulierung mit vorherigen Inhalten des Arrays ...
*/
function getPermListGroupRights($groups,$case = ""){
//if(!is_array($this->groupPerms) || $case == "new") {
if((! $this->groupPerms["system"]) || ($case == "new")) {
if ($case == "new") {$this->groupPerms = array();}
$tmpArr=array();
//echo "\$this->userGroups="; print_r( $this->userGroups );
// Schreiben der globalen Gruppenzugehörigkeiten (GroupIDs) in ein Array ..
if (($this->userid)&&($groups)){
$tmpArr=$groups;
//trigger_error("\$tmpArr =".implode(",",$tmpArr));
/*}elseif (count($this->userGroups)>0){
//trigger_error("hier..");
foreach ($this->userGroups as $keys => $values){
if ($values == GLOBALE) {
$tmpArr[]=$keys;
}
}*/
}else{
// per default nur globale Gruppen holen ...
$tmpStr=(string) constant("GLOBALE");
//trigger_error("\$tmpStr=".$tmpStr);
$tmpArr=$this->getUserGroup( $tmpStr );
}
// Ermitteln der Permission-IDs aus den vorher gefundenen GroupIDs
//trigger_error("\$tmpArr=".implode(",",$tmpArr));
if (count($tmpArr)>0){
$sql="select permID from ".TABLE."_usergroups where groupID in (". implode(",",$tmpArr) .")";
//trigger_error($sql);
$tmpArr=array();
if ($query=mysql_query($sql)){
while ($result = mysql_fetch_row($query)) {
$tmpArr[]="'".$result[0]."'";
}
// Letztendliches Kumulieren der (GLOBALEN) Gruppenrechte in $this->groupPerms
if (count($tmpArr)>0){
$sql="SELECT * FROM ".TABLE."_perms WHERE permID in (". implode(",",$tmpArr) .")";
//trigger_error($sql);
if ($query=mysql_query($sql)){
while ($result = mysql_fetch_object($query)) {
$this->groupPerms['system'] |= $result->system;
$this->groupPerms['module'] |= $result->module;
}
}
}
}
}
//print_r($this->groupPerms);
}
}
/**
* Hilfsfunktion zur Ermittlung von kumulierten Permissions über Gruppenrechte
* Permission Bitmuster an Aufrufer zurückgeben
* Funktion wird benutzt, um separate Rubrikrechte zu ermitteln ...
* diese Funktion dient dem Abpruefen der spezifischen Rechte in einer Rubrik
* aus Performance-Gruenden NICHT fuer das Abpruefen in Tree-Views benutzen ...
* @access private
* @param $groups array of groups allowed fuer geschuetzte Bereiche
* @return in Bitmuster
*/
function getLocalPerms($groups) {
$groupPerms=array();
if ((is_array($groups)) && (count($groups)>0)){
$sql="select p.* from ".TABLE."_perms p, ".TABLE."_usergroups u where u. groupID in (". implode(",",$tmpArr) .") and p.permID=u.permID";
if ($query=mysql_query($sql)){
while ($result = mysql_fetch_object($query)) {
$groupPerms['system'] |= $result->system;
$groupPerms['module'] |= $result->module;
}
return $groupPerms;
}
}
if (!is_array($this->groupPerms)){
$this->getPermList();
}
return $this->groupPerms;
}
/**
* Permission Bitmuster an Aufrufer zurückgeben
* ! diese Funktion veraendert / verbiegt die Permissions des Users,
* sodass der Code der Plugins nicht direkt angefasst werden muss ?
* Funktion muss VOR einem rubrik-related Permission-Check aufgerufen werden
* kumuliert User- und Gruppenrechte; verwendet dazu Hilfsfunktion
* function getLocalPerms($groups)
* poor performance, nicht fuer tree-views verwenden ..
* Beispiel aus dem Kopf von artAdd1.inc.php:
* $cbPerms=$cbUser->getColumnPerms($folder);
*
* @access public
* @param $column: die aktuelle Rubrik, fuer die Rechte geprueft werden sollen
* sind keine besonderen Rechte vergeben, werden einfach die
* globalen Rechte zurueckgegeben
* @return in Bitmuster
*/
function getColumnPerms($column) {
if ($column){
$sql="select usersallowed, groupsAllowed from ".TABLE."_columnID where fid='".$column."'";
if ($query=mysql_query($sql)){
if ($row=mysql_fetch_row($query)){
if (strlen($row[0])>0){
$flag=TRUE;
if (in_array($this->username,explode(",",$row[0]))){
$tmpPerms=$this->perms->{$patternName};
}
}
if (strlen($row[1])>0){
$flag=TRUE;
$perms=$this->getLocalPerms(explode(",",$row[1]));
$tmpPerms |= $perms["system"];
}
if ($flag){
return $tmpPerms;
}
}
}
}
return $this->getPattern();
}
/**
* Boolean "isAllowed" TRUE/FALSE an Aufrufer zurückgeben
* ! diese Funktion legt nur fest, ob der Nutzer die entsprechende
* Rubrik sehen kann und ist viel schneller als function getColumnPerms($column)
* globale Rechte werden nicht beruecksichtigt - sind die Aufrufparameter beide leer
* wird in jedem Fall FALSE zurueckgegeben (was meist nicht erwuenscht sein sollte)
* Diese Funktion sollte fuer das korrekte Aufbauen von Tree-Views verwendet werden
*
* @access public
* @param $userList: kommaseparierte Liste der erlaubten Nutzernamen
* @param $groupList: kommaseparierte Liste der erlaubten Gruppen
*
* @return boolean
*/
function isUserAllowed($userList,$groupList){
$isAllowed=FALSE;
if ($userList){
if (in_array($this->username,explode(",",$userList))){
$isAllowed=TRUE;
}
}
if (($isAllowed==FALSE)&&($groupList)){
//trigger_error("\$groupList=".$groupList);
$tmpGroups=$this->getUserGroup();
//trigger_error("\array_keys(\$this->userGroups)=".implode(",",array_keys($this->userGroups)));
if ((is_array($this->userGroups))&&($this->array_in_array(array_keys($this->userGroups),explode(",",$groupList)))){
//trigger_error("isAllowed=TRUE");
$isAllowed=TRUE;
}
}
return $isAllowed;
}
/**
* Permission Objekt an Aufrufer übergeben
* @access public
* @return object $perms Komplettes Query übergeben
*/
function getPerms() {
$this->getPermList();
return $this->perms;
}
/**
* Einzelne Pattern übergeben, gibt das Feld aus, welches angewählt wurde
* Kumuliert Benutzerrechte mit GLOBALEN Nutzerrechten
* @access public
* @ userPerms User-Objekt (direkte Rueckgabe von "select * from TABLE_user where userid='$userid'" )
* @ userGroup Group Array = Liste von IDs von Nutzergruppen
* @patternName Rechte fuer bestimmte Unterbereiche ... derzeit wird nur das DB-Feld "system" benutzt
* @return bigint $pattern Feld mit Rechten
*/
function getPattern($patternName = "system") {
$this->getPermList();
$patternPerms = $this->perms->{$patternName};
$patternPerms |= $this->groupPerms[$patternName];
//trigger_error("\$patternPerms=".$patternPerms);
return $patternPerms;
}
# boolean isMatchingUserRights(string $usersAllowed, array mixed $groupsAllowed); (Rechte der
# Rubrik im Column-Manager gegen Nutzerrechte des aktuellen Nutzers pruefen)
// Funktion kumuliert Rechte , wenn Benutzer sowohl in den erlaubten Benutzernamen aufgefuehrt wurde
// als auch einer erlaubten Gruppe angehoert
/* function getMatchingUserRights($usersAllowed="", $groupsAllowed=array(),$patternName = "system"){
if (($usersAllowed) && (ereg($this->username,$usersAllowed))) {
*/
function isAuthenticated() {
return $this->userChk;
}
function getUserID() {
return $this->userid;
}
/**
* Funktion gibt Liste aller globalen Gruppen zurueck der der aktuelle Benutzer angehoert
* kann auch leeres Array sein .....
*
*/
function getUserGroup($groupType="") {
//trigger_error("\$groupType=".$groupType);
$tmpArr=array();
if (count($this->userGroups)>0){
foreach ($this->userGroups as $keys => $values){
if ((! $groupType) || ($values == $groupType)) {
$tmpArr[]=$keys;
}
}
}
return $tmpArr;
}
function getUserGroups() {
return $this->userGroups;
}
//Alternative method to find an array within an array (if your version of php doesn't support array type $needles):
function array_in_array($needle, $haystack) {
//trigger_error(implode(",",$needle));
if (! is_array($needle)){
return false;
}
foreach ($haystack as $value) {
if (in_array($value,$needle)) return true;
}
return false;
}
}
?>