Ticket #132: usergroup.2.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
    // These are associative arrays where the key and value are the same.
    // This allows us to use isset() for various checks, rather than
    // in_array(), and it allows us to avoid some array iterations
    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;
    private $toggle_permissions= 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');

        // set up default, empty properties
        $this->permissions_revoked= array();
        $this->db_member_ids= array();
        $this->db_permissions_granted= array();
        $this->db_permissions_denied= array();
        $this->toggle_permission['grant']= array();
        $this->toggle_permissions['deny']= array();
        
        // if we have an ID, load this UserGroup's members & permissions
        if ( $this->id ) {
            if ( $result= DB::get_column( 'SELECT user_id FROM {users_groups} WHERE group_id= ?', array( $this->id ) ) ) {
                foreach( $result as $id ) {
                    $this->db_member_ids[ $id ]= $id;
                }
            }

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

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

        // set the temporary variables to hold the initial values
        // as pulled 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 );
        if ( $usergroup->insert() ) {
            return $usergroup;
        } else {
            return $false;
        }
    }

    /**
     * Save a new UserGroup to the UserGroup table
    **/
    public function insert()
    {
        $allow= true;
        // plugins have the opportunity to prevent insertion
        $allow= Plugins::filter('usergroup_insert_allow', $allow, $this);
        if ( ! $allow ) {
            return false;
        }
        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;
        // plugins have the opportunity to prevent modification
        $allow= Plugins::filter('usergroup_update_allow', $allow, $this);
        if ( ! $allow ) {
            return false;
        }
        Plugins::act('usergroup_update_before', $this);
`
        // figure out what needs to be changed
        // we do this by comparing the various temporary arrays against
        // the arrays that hold the DB values
        if ( $this->member_ids != $this->db_member_ids ) {
            $added= array_diff_assoc( $this->member_ids, $this->db_member_ids);
            if ( count( $added ) > 0 ) {
                // one or more members added to this group
                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 ) {
                // one or more members removed from this group
                foreach ( $removed as $id ) {
                    DB::query('DELETE FROM {users_groups} WHERE user_id=? AND group_id=?', array( $id, $this->id ) );
                }
            }
        }

        // were any permissions toggled?  We do this to economize hits
        // to the DB: rather than execute separate DELETE then INSERT
        // commands, we can execute a single UPDATE
        if ( ! empty( $this->toggle_permissions['grant'] ) ) {
            // grant permissions previously denied
            $ids= implode( ',', $this->toggle_permissions['grant'];
            $results= DB::query( "UPDATE {groups_permissions} set denied=0 WHERE id IN ($ids)" );
            //update DB arrays, to prevent the next set of checks 
            // from trying to insert this permission
            foreach ( $this->toggle_permissions['grant'] as $id ) {
                $this->db_permissions_granted[ $id ]= $id;
                unset( $this->permissions_denied[$id] );
            }
        }
        if ( ! empty( $this->toggle_permissions['deny'] ) ) {
            $ids= implode( ',', $this->toggle_permissions['deny'];
            $results= DB::query( "UPDATE {groups_permissions} set denied=1 WHERE id IN ($ids)" );
            //update DB arrays again
            foreach ( $this->toggle_permissions['deny'] as $id ) {
                $this->db_permissions_denied[ $id ]= $id;
                 unset( $this->permissions_granted[$id] );
            }
        }

        // now, we compare the current list of granted permissions with
        // those currently in the DB.  If any new ones have been added,
        // update the DB to reflect this
        if ( $this->permissions_granted != $this->db_permissions_granted ) {
            $granted= array_diff_assoc( $this->permissions_granted, $this->db_permissions_granted );
            if ( count( $granted ) > 0 ) {
            // one or more permissions granted
                foreach( $granted as $perm ) {
                    DB::query('INSERT INTO {groups_permissions} (group_id, permission_id, denied ) VALUES (?, ?, 0)', array( $this->id, $perm) );
                }
            }
        }

        // and do the same for the denied permissions
        if ( $this->permissions_denied != $this->db_permissions_denied ) {
            $denied= array_diff_assoc( $this->permissions_denied, $this->db_permissions_denied );
            if ( count( $denied ) > 0 ) {
                // one or more permissions denied
                foreach( $denied as $perm ) {
                    DB::query('INSERT INTO {groups_permissions} (group_id, permission_id, denied) VAlUED (?, ? 1)', array( $this->id, $perm ) );
                }
            }
        }

        // finally, were any previously assigned permissions
        // (granted or denied) removed?  If so, take them out of the DB
        if ( count( $this->permissions_revoked ) > 0 ) {
            // one or more permissions revoked
            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);

        // *whew* We're all done!
    }

    /**
     * Delete a UserGroup
    **/
    public function delete()
    {
        $allow= true;
        // plugins have the opportunity to prevent deletion
        $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 mixed a user ID or name
    **/
    public function add( $id )
    {
        if ( ! is_int( $id ) ) {
            $user= User::get( $id );
            $id= $user->id;
        }
        if ( isset( $self->member_ids[ $id ] ) ) {
            // this user is already a member
            return false; 
        }
        $self->member_ids[$id]= $id;
        return true;
    }

    /**
     * Remove a user from this group
     * @param mixed a user ID or name
    **/
    public function remove( $id )
    {
        if ( ! is_int( $id ) ) {
            $user= User::get( $id );
            $id= $user->id;
        }
        if ( ! isset( $self->member_ids[ $id ] ) ) {
            // this user is not a member of this group
            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 )
    {
        // is this permisson currently assigned to this group?
        if ( isset( $this->permissions_granted[ $permission ] ) ) {
            // we can short-circuit and stop processing
            reutrn true;
        }
        
        // is this permission currently denied to ths group?
        if ( isset( $permission, $this->permissions_denied[ $permission ] ) ) {
            // we need to toggle the denied bit, which is a single
            // UPDATE operation, rather than a DELETE + INSERT
            $this->toggle_permissions['grant']= $permission;

            // we also need to update the temporary variable
            // so that the can() method works as expected
            // even before calls to update() occur
            unset( $this->permissions_denied[ $permission ] );
        }

        // finally, we grant this permission
        $this->permissions_granted[ $permission ]= $permission;
    }

    /**
     * Deny a permission to this group
     * @param int The permission ID to be denied
    **/
    public function deny( $permission )
    {
        // short-circuit: is this permission already denied?
        if ( isset( $this->permissions_denied[ $permission ] ) ) {
            return true;
        }

        // is this permission currently granted?
        if ( isset( $this->permissions_granted[ $permission] ) ) {
            // we need to toggle the denied bit, which is a single
            // UPDATE operation, rather than a DELETE + INSERT
            $this->toggle_permissions['deny']= $permission;

            // we also need to update the temporary variable
            // so that the can() method works as expected
            // even before calls to update() occur
            unset( $this->permissions_granted[ $permission ] );
        }

        // finally, we deny the permission
        $this->permissions_denied[ $permission ] = $permission;
    }

    /**
     * Remove a permission from a group
     * @param int a permission ID
    **/
    public function revoke( $permission )
    {
        if ( isset( $this->permissons_granted[ $permission ] ) ) {
            unset( $this->permissions_granted[ $permission ] );
        }
        if ( isset( $permission, $this->permissions_denied[ $permission ] ) ) {
            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 mixed If a permission is denied to this group, return boolean FALSE; if a permission is granted, return boolean TRUE; if a permission is neither granted nor denied, return an empty string.
    **/
    public function can( $permission )
    {
        if ( isset( $this->permissions_denied[ $permission ] ) ) {
            return false;
        }
        if ( isset( $this->permissions_granted[ $permission ] ) ) {
            return true;
        }
        return '';
    }

    /**
     * Fetch a group from the database by ID or name.
     * This is a wrapper for get_by_id() and get_by_name()
     * @param mixed $group A group ID or name
     * @return mixed UserGroup object, or boolean FALSE
    */
    public static function get( $group )
    {
        if ( is_int( $group ) ) {
            return self::get_by_id( $group );
        } else {
            return self::get_by_name( $group );
        }
    }

    /**
     * Select a group from the DB by its ID
     * @param int A group ID
     * @return mixed A UserGroup object, or boolean FALSE
    **/
    public static function get_by_id( $id )
    {
        if ( 0 == $id ) {
            return false;
        }
        return DB::get_row( 'SELECT * FROM {groups} WHERE id=?', array( $id ), 'UserGroup' );
    }

    /**
     * Select a group from the DB by its name
     * @param string A group name
     * @return mixed A UserGroup object, or boolean FALSE
    **/
    public static function get_by_name( $name )
    {
        if ( '' == $name ) {
            return false;
        }
        return DB::get_row( 'SELECT * FROM {groups} WHERE name=?', array( $name ), 'UserGroup' );
    }

    /**
     * Determine whether a group exists
     * @param mixed The name or ID of the group
     * @return bool Whether the group exists or not
    **/
    public static function exists( $group )
    {
        if ( is_int( $group ) ) {
            $query= 'id';
        } else {
            $query= 'name';
        }
        return DB::query("SELECT id FROM {groups} WHERE $query=?", array( $group ) );
    }

}
?>