Location: PHPKode > projects > Content*Builder > contentbuilder/lib/CB_perm.class.php
<?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;
    }
	
	
}

?>
Return current item: Content*Builder