Ticket #132: usergroup.php

<?php
/**
* Habari UserGroup Class
* @package Habari
**/
class UserGroup extends QueryRecord
{
    /**
     * Static storage for this group's info
    **/
    // these first three hold the original values as fetched from the DB
    private $db_member_ids= null;
    private $db_permissions_granted= null;
    private $db_permissons_denied= null;

    // these next three hold changes before they're committed to the DB
    private $member_ids= null;
    private $permissions_granted= null;
    private $permissons_denied= null;
    private $permissions_revoked= null;

    /**
     * get default fields for this record
     * @return array an array of the fields used in the UserGroup table
    **/
    public static function default_fields()
    {
        return array(
            'id' => '',
            'name' => ''
        );
    }

    /**
     * Constructor for the UserGroup class
     * @param array $paramarray an associative array of UserGroup fields
    **/
    public function __construct( $paramarray= array() )
    {
        $this->fields= array_merge(
            self::default_fields(),
            $this->fields );
        parent::__construct( $paramarray );
        $this->exclude_fields('id');
        $this->permissions_revoked= array();
        $this->db_member_ids= array();
        $this->db_permissions_granted= array();
        $this->db_permissions_denied= array();
        
        // if we have an ID, load this UserGroup's members & permissions
        if ( $this->id ) {
            $result= DB::get_column( 'SELECT user_id FROM {users_groups} WHERE group_id= ?', array( $this->id ) );
            if ( $result ) {
                foreach( $result as $id ) {
                    $this->db_member_ids[ $id ]= $id;
                }
            }

            $result= DB::get_column( 'SELECT permission_id FROM {groups_permissions} WHERE group_id=? AND denied=0 ', array( $this->id ) );
            if ( $result ) {
                foreach ( $result as $granted ) {
                    $this->db_permissions_granted[ $granted ]= $granted;
                }
            }

            $result= DB::get_column( 'SELECT permission_id FROM {groups_permissions} WHERE group_id=? AND denied=1', array( $this->id ) );
            if ( $result ) {
                foreach( $result as $denied ) {
                    $this->permissions_denied[ $denied ]= $denied;
                }
            }
        }

        // set the temporary variables to hold the initial values from the DB, if any
        $this->member_ids= $this->db_member_ids;
        $this->permissions_granted= $this->db_permissions_granted;
        $this->permissions_denied= $this->db_permissions_denied;
    }

    /**
     * Create a new UserGroup object and save it to the database
     * @param array An associative array of UserGroup fields
     * @return UserGroup the UserGroup that was created
    **/
    public static function create( $paramarray )
    {
        $usergroup= new UserGroup( $paramarray );
        $usergroup->insert();
        return $usergroup;
    }

    /**
     * Save a new UserGroup to the UserGroup table
    **/
    public function insert()
    {
        $allow= true;
        $allow= Plugins::filter('usergroup_insert_allow', $allow, $this);
        if ( ! $allow ) {
            return;
        }
        Plugins::act('usergroup_insert_before', $this);
        $this->exclude_fields('id');
        $result= parent::insertRecord( DB::table('users') );
        $this->fields['id']= DB::last_insert_id();
        EventLog::log('New group created: ' . $this->name, 'info', 'default', 'habari');
        Plugins::act('usergroup_insert_after', $this);
        return $result;
    }

    /**
     * Updates an existing UserGroup in the DB
    **/
    public function update()
    {
        $allow= true;
        $allow= Plugins::filter('usergroup_update_allow', $allow, $this);
        if ( ! $allow ) {
            return;
        }
        Plugins::act('usergroup_update_before', $this);
        // figure out what needs to be changed
        if ( $this->member_ids != $this->db_member_ids ) {
            $added= array_diff_assoc( $this->member_ids, $this->db_member_ids);
            if ( count( $added ) > 0 ) {
                foreach ( $added as $id ) 
                    DB::query('INSERT INTO {users_groups} (user_id, group_id) VALUES (?, ?)', array( $id, $this->id) );
                }
            }
            $removed= array_diff_assoc( $this->db_member_ids, $this->member_ids );
            if ( count( $removed ) > 0 ) {
                foreach ( $removed as $id ) {
                    DB::query('DELETE FROM {users_groups} WHERE user_id=? AND group_id=?', array( $id, $this->id ) );
                }
            }
        }
        if ( $this->permissions_granted != $this->db_permissions_granted ) {
            $granted= array_diff_assoc( $this->permissions_granted, $this->db_permissions_granted );
            if ( count( $granted ) > 0 ) {
                foreach( $granted as $perm ) {
                    DB::query('INSERT INTO {groups_permissions} (group_id, permission_id, denied ) VALUES (?, ?, 0)', array( $this->id, $perm) );
                }
            }
        }
        if ( $this->permissions_denied != $this->db_permissions_denied ) {
            $denied= array_diff_assoc( $this->permissions_denied, $this->db_permissions_denied );
            if ( count( $denied ) > 0 ) {
                foreach( $denied as $perm ) {
                    DB::query('INSERT INTO {groups_permissions} (group_id, permission_id, denied) VAlUED (?, ? 1)', array( $this->id, $perm ) );
                }
            }
        }
        if ( count( $this->permissions_revoked ) > 0 ) {
            foreach ( $this->permissions_revoked as $perm ) {
                DB::query( 'DELETE FROM {users_groups} WHERE group_id=? AND permission_id=?', array( $this->id, $perm ) );
            }
        }
        Plugins::act('usergroup_update_after', $this);
    }

    /**
     * Delete a UserGroup
    **/
    public function delete()
    {
        $allow= true;
        $allow= Plugins::filter('usergroup_delete_allow', $allow, $this);
         if ( ! $allow ) {
             return;
        }
        Plugins::act('usergroup_delete_before', $this);
        // remove all this group's permissions
        $results= DB::query( 'DELETE FROM {groups_permissions} WHERE group_id=?', array( $this->id ) );
        // remove all this group's members
        $results= DB::query( 'DELETE FROM {users_groups} WHERE group_id=?', array( $this->id ) );
        // remove this group
        $result= parent::deleteRecord( DB::table('groups'), array( 'id' => $this->id ) );
        Plugins::act('usergroup_delete_after', $this);
        return $result;
    }

    /**
     * function members
     * returns an array of user IDs belogning to this UserGroup
     * @return array an array of user IDs
    **/
    public function members()
    {
        return $this->member_ids;
    }
    
    /**
     * Add a user to this group
     * @param int a user ID
    **/
    public function add( $id )
    {
        if ( in_array( $id, $self->member_ids ) ) {
            return false; 
        }
        $self->member_ids[$id]= $id;
        return true;
    }

    /**
     * Remove a user from this group
     * @param int a user ID
    **/
    public function remove( $id )
    {
        if ( ! in_array( $id, $self->member_ids ) ) {
            return false;
        }
        unset($self->member_ids[ $id ]);
        return true;
    }

    /**
     * Assign a new permission to this group
     * @param int A permission ID
    **/
    public function grant( $permission )
    {
        if ( ! in_array( $permisson, $this->permissions_granted ) ) {
            $this->permissions_granted[ $permission ]= $permission;
        }
        if ( in_array( $permission, $this->permissions_denied ) ) {
            unset( $this->permissions_denied[ $permission ] );
        }
    }

    /**
     * Deny a permission to this group
     * @param int The permission ID to be denied
    **/
    public function deny( $permission )
    {
        if ( ! in_array( $permission, $this->permissions_denied ) ) {
            $this->permissions_denied[ $permission ] = $permission;
        }
        if ( in_array( $permission, $this->permissions_granted ) ) {
            unset( $this->permissions_granted[ $permission ] );
        }
    }

    /**
     * Remove a permission from a group
     * @param int a permission ID
    **/
    public function revoke( $permission )
    {
        if ( in_array( $permisson, $this->permissons_granted ) ) {
            unset( $this->permissions_granted[ $permission ] );
        }
        if ( in_array( $permission, $this->permissions_denied ) ) {
            unset( $this->permissions_denied[ $permission] );
        }
        $this->permissions_revoked[ $permission ]= $permission;
    }

    /**
     * Determine whether members of a group can do something
     * @param string a text description of a permission
     * @return bool Whether the group can do the thing
    **/
    public function can( $permission )
    {
        if ( isset( $this->permissions_granted[ $permission ] ) ) {
            return true;
        }
        return false;
    }
}
?>