Ticket #132: groups.patch

system/admin/groups.php

@@ -14 +14 @@
 </form>
 <ul>
 <?php
-foreach ( $groups as $id => $name )
-{
-        echo '<li>';
-        echo '<form method="post" action=""><input type="hidden" name="group" value="' . $id . '"><input type="submit" name="delete_group" value="Delete"> ';
+foreach ( $groups as $group ) {
+    echo '<li>';
+    echo '<form method="post" action=""><input type="hidden" name="group" value="' . $group->name . '"><input type="submit" name="delete_group" value="Delete"> ';
     echo '<input type="submit" name="edit_group" value="Edit"> ';
-    echo $name . '</form>';
-        echo '</li>';
+    echo $group->name . '</form>';
+    echo '</li>';
 }
 ?>
 </ul>
@@ -28 +27 @@
 <div class="column span-8">
 <p>Members</p>
 <?php
-if ( isset( $group ) ) {
+if ( isset( $group_edit ) ) {
     if ( isset( $users) && ( ! empty( $users ) ) ) {
+        echo '<p>Editing members of ' . $group_edit->name . '</p>';
         echo '<form method="post" action="">';
-        echo '<input type="hidden" name="group" value="' . $group . '">';
-        echo Utils::html_select( 'add_user', $users );
-        echo ' <input type="submit" value="Add"></form>';
+        echo '<input type="hidden" name="group" value="' . $group_edit->name . '">';
+        $user_data= array();
+        foreach ( $users as $user ) {
+            $user_data[$user->id]= $user->username;
+        }
+        echo Utils::html_select( 'add_user', $user_data );
+        echo '<input type="submit" value="Add"></form>';
     }
-    if ( ! empty($group_members) ) {
-            echo '<ul>';
-            foreach ( $group_members as $member ) {
-                    $user= User::get_by_id($member);
-                    echo '<li><form method="post" action=""><input type="hidden" name="remove_user" value="' . $user->id . '">';
-            echo '<input type="hidden" name="user_group" value="' . $group . '"><input type="submit" value="Remove"></form> ' . $user->username . '</li>';
-            }
-            echo '</ul>';
+    if ( ! empty($members) ) {
+        echo '<ul>';
+        foreach ( $members as $member ) {
+            echo '<li><form method="post" action=""><input type="hidden" name="remove_user" value="' . $member->id . '">';
+            echo '<input type="hidden" name="group" value="' . $group_edit->name . '"><input type="submit" value="Remove"> ' . $member->username . '</form></li>';
+        }
+        echo '</ul>';
     } else {
         echo '<p>No members.</p>';
     }
@@ -51 +54 @@
 </div>
 <div class="column span-8 last">
 <p>Permissions</p>
+<?php
+if ( isset( $group_edit ) ) {
+    if ( isset( $permissions) && ( ! empty( $permissions ) ) ) {
+        echo '<p>Editing Permissions of ' . $group_edit->name . '</p>';
+        echo '<form method="post" action="">';
+        echo '<input type="hidden" name="group" value="' . $group_edit->name . '">';
+        $permission_data= array();
+        foreach ( $permissions as $permission ) {
+            $permission_data[$permission->id]= $permission->name;
+        }
+        echo Utils::html_select( 'grant_permission', $permission_data );
+        echo '<input type="submit" value="Grant"></form>';
+        echo Utils::html_select( 'deny_permission', $permission_data );
+        echo '<input type="submit" value="Deny"></form>';
+    }
+    if ( ! empty($permissions_set) ) {
+        echo '<ul>';
+        foreach ( $permissions_set as $permission_set ) {
+            echo '<li><form method="post" action=""><input type="hidden" name="permission_set" value="' . $permission_set->id . '">';
+            echo '<input type="hidden" name="group" value="' . $group_edit->name . '">';
+            echo '<input type="submit" value="Revoke"> ' . $permission->name . '</form></li>';
+        }
+        echo '</ul>';
+    } else {
+        echo '<p>No permissions.</p>';
+    }
+}
+?>
 </div>
 </div>
 <?php include('footer.php');?>

system/classes/adminhandler.php

@@ -991 +991 @@
 
     public function post_groups()
     {
-        $this->theme->groups= UserGroup::all_groups();
+        $this->theme->groups= UserGroups::get();
         if ( isset( $this->handler_vars['add_group'] ) ) {
-            if ( UserGroup::add_group( $this->handler_vars['add_group'] ) ) {
-                Session::notice( sprintf(_t( 'Added group %s'), $this->handler_vars['add_group'] ) );
-                $this->theme->groups= UserGroup::all_groups();
+            $name= $this->handler_vars['add_group'];
+            if ( UserGroup::exists($name) ) {
+                Session::notice( sprintf(_t( 'The group %s already exists'), $name ) );
             }
+            else {
+                $groupdata= array(
+                    'name' => $name
+                );
+                $group= UserGroup::create($groupdata);
+                Session::notice( sprintf(_t( 'Added group %s'), $name ) );
+                // reload the groups
+                $this->theme->groups= UserGroups::get();
+            }
         }
 
         if ( isset( $this->handler_vars['delete_group'] ) ) {
-            // capture the group name before we delete it
-            $group_name=  $this->theme->groups[$this->handler_vars['group']];
-            if ( UserGroup::remove_group( intval( $this->handler_vars['group'] ) ) ) {
-                Session::notice( sprintf( _t( 'Removed group %s' ), $group_name ) );
+            $name= $this->handler_vars['group'];
+            if ( !UserGroup::exists($name) ) {
+                Session::notice( sprintf(_t( 'The group %s does not exist'), $name ) );
+            }
+            else {
+                $group= UserGroup::get($name);
+                $group->delete();
+                Session::notice( sprintf( _t( 'Removed group %s' ), $name ) );
                 // reload the groups
-                $this->theme->groups= UserGroup::all_groups();
+                $this->theme->groups= UserGroups::get();
             }
         }
 
         if ( isset( $this->handler_vars['add_user'] ) ) {
-            UserGroup::add_user( $this->handler_vars['group'], $this->handler_vars['add_user'] );
-            $this->theme->groups= UserGroup::all_groups();
+            $name= $this->handler_vars['group'];
+            $user_id= $this->handler_vars['add_user'];
+            if ( !UserGroup::exists($name) ) {
+                Session::notice( sprintf(_t( 'The group %s does not exist'), $name ) );
+            }
+            else {
+                $group= UserGroup::get($name);
+                $user= User::get((int)$user_id);
+                $group->add((int)$user_id);
+                $group->update();
+                Session::notice( sprintf(_t( 'Added user %s to group %s'), $user->username, $name ) );
+                // reload the groups
+                $this->theme->groups= UserGroups::get();
+            }
         }
 
         if ( isset( $this->handler_vars['remove_user'] ) ) {
-            UserGroup::remove_user( $this->handler_vars['user_group'], $this->handler_vars['remove_user'] );
-            $this->theme->groups= UserGroup::all_groups();
+            $name= $this->handler_vars['group'];
+            $user_id= $this->handler_vars['remove_user'];
+            if ( !UserGroup::exists($name) ) {
+                Session::notice( sprintf(_t( 'The group %s does not exist'), $name ) );
+            }
+            else {
+                $group= UserGroup::get($name);
+                $user= User::get((int)$user_id);
+                $group->remove((int)$user_id);
+                $group->update();
+                Session::notice( sprintf(_t( 'Removed user %s from group %s'), $user->username, $name ) );
+                // reload the groups
+                $this->theme->groups= UserGroups::get();
+            }
         }
 
         if ( isset( $this->handler_vars['edit_group'] ) ) {
-            $this->theme->group= $this->handler_vars['group'];
-            $this->theme->group_members= UserGroup::members( $this->theme->group );
-            $all_users= Users::get_all();
-            $users= array();
-            foreach ( $all_users as $user ) {
-                if ( ! in_array( $user->id,  $this->theme->group_members ) ) {
-                    $users[$user->id]= $user->username;
-                }
+            $name= $this->handler_vars['group'];
+            if ( !UserGroup::exists($name) ) {
+                Session::notice( sprintf(_t( 'The group %s does not exist'), $name ) );
             }
-            $this->theme->users= $users;
+            else {
+                $group= UserGroup::get($name);
+                $this->theme->group_edit= $group;
+                $this->theme->members= $group->members();
+                $this->theme->users= Users::get_all();
+            }
         }
         $this->display( 'groups' );
     }

system/classes/usergroup.php

@@ -1 +1 @@
 <?php
 /**
 * Habari UserGroup Class
+*
 * @package Habari
 **/
-class UserGroup
+class UserGroup extends QueryRecord
 {
-        /**
-         * An array of users assigned to a specific group id.
-         * Both the group and the user are id integers, not string values.
-         * The user arrays have both the key and the value set to the user_id.  
-         *
-         * For example:
-         * <code>
-         * self::$groups= array(
-         *      1 => array(1 => 1),
-         *      2 => array(1 => 1, 2 => 2),
-         * );
-         * </code>
-         **/     
-        private static $groups= array();
+    /**
+     * Static storage for this group's info
+    **/
+    // these hold the values as fetched from the DB
+    private $members= array();
+    private $permissions_granted= null;
+    private $permissons_denied= null;
 
-        /**
-         * An array of group IDs with group names.
-         * For example:
-         * <code>
-         * self::$group_names= array(
-         *      1 => 'administrators',
-         *      2 => 'guests',
-         * );
-         * </code>       
-         **/             
-        private static $group_names= array();
+    // these hold changes before they're committed to the DB
+    private $new_members= array();
+    private $removed_members= array();
+    private $new_permissions_granted= null;
+    private $new_permissons_denied= null;
 
-        /**
-         * An array of permssions assigned to a group.
-         * The group and permission are both id integers, not string values.
-         * The key of each permission array is the permission id.  
-         * The value of the permission id is boolean on whether to grant or deny
-                 * that permission.
-                 *
-         * For example:
-         * <code>
-         * self::$group_permissions= array(
-         *      1 => array( 1 => true, 2 => true),
-         *      2 => array( 2 => false),
-         * );
-         * </code>
-         **/
-    private static $group_permissions= array();
-
     /**
-     * __static() class members are called by __autoload()
+     * get default fields for this record
+     * @return array an array of the fields used in the UserGroup table
     **/
-    public static function __static()
+    public static function default_fields()
     {
-        self::load_groups();
+        return array(
+            'id' => '',
+            'name' => ''
+        );
     }
 
     /**
-     * Load all group data from the DB
+     * Constructor for the UserGroup class
+     * @param array $paramarray an associative array of UserGroup fields
     **/
-    public static function load_groups ()
+    public function __construct( $paramarray= array() )
     {
-        self::$group_names= array();
-        $results= DB::get_results( 'SELECT * FROM {groups}' );
-        natsort( $results );
-        foreach ($results as $group) {
-            self::$group_names[$group->id]= $group->name;
+        $this->fields= array_merge(
+            self::default_fields(),
+            $this->fields );
+        parent::__construct( $paramarray );
+        $this->exclude_fields('id');
+        
+        // if we have an ID, load this UserGroup's members and permissions
+        if ( $this->id ) {
+            // TODO can we do this through Users::get()?
+            $member_ids= DB::get_column( 'SELECT user_id FROM {users_groups} WHERE group_id= ?', array( $this->id ) );
+            foreach ($member_ids as $id) {
+                $this->members[]= User::get((int)$id);
+            }
+            $this->permissions_granted= DB::get_column( 'SELECT permission_id FROM {groups_permissions} WHERE group_id=? AND denied=0 ', array( $this->id ) );
+            $this->permissions_denied= DB::get_column( 'SELECT permission_id FROM {groups_permissions} WHERE group_id=? AND denied=1', array( $this->id ) );
         }
-        self::$groups= array();
-        $results= DB::get_results( 'SELECT * FROM {users_groups}' );
-        foreach ( $results as $group ) {
-            self::$groups[$group->group_id][$group->user_id]= $group->user_id;
-        }
     }
 
     /**
-     * function all_groups
-     * Returns an array of all the groups, in the form id => name
-     * @return array an array of group id => name
+     * 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 all_groups()
+    public static function create( $paramarray )
     {
-        return self::$group_names;
+        $usergroup= new UserGroup( $paramarray );
+        $usergroup->insert();
+        return $usergroup;
     }
 
     /**
-     * function add_group
-     * Adds a new group to the Groups table
-     * @param string The name of the group to add
-     * @return bool Whether the group was added or not
+     * Save a new UserGroup to the UserGroup table
     **/
-    public static function add_group( $group )
+    public function insert()
     {
-        if ( in_array( $group, self::$group_names ) ) {
-            Session::notice( _t( 'That group already exists.' ) );
-            return false;
+        // If all goes according plan, $result will stay true
+        $result= true;
+        // Allow plugins to disallow adding the group, by changing $result
+        $result= Plugins::filter('usergroup_insert_allow', $result, $this);
+        // If still allowed, add the group
+        if ( $result ) {
+            Plugins::act('usergroup_insert_before', $this);
+            $this->exclude_fields('id');
+            // $result will change to false if insertion fails
+            // Perhaps we should throw an exception here instead?
+            $result= parent::insertRecord( DB::table('groups') );
+            $this->fields['id']= DB::last_insert_id();
+            EventLog::log('New group created: ' . $this->name, 'info', 'default', 'habari');
+            Plugins::act('usergroup_insert_after', $this);
         }
-        $allow= true;
-        $allow= Plugins::filter('usergroup_insert_allow', $allow );
-        if ( ! $allow ) {
-            return false;
-        }
-        Plugins::act('usergroup_add_before');
-        $results= DB::query( 'INSERT INTO {groups} (name) VALUES (?)', array( $group ) );
-        Plugins::act('usergroup_add_after');
-        self::load_groups();
-        return true;
+        return $result;
     }
 
     /**
-     * function remove_group
-     * Remove a group from the Groups table.  Also removes all users_groups members of the group.
-     * @param mixed A Group name or integer ID
-     * @return bool Whether the group was removed or not
+     * Updates an existing UserGroup in the DB
     **/
-    public static function remove_group( $group )
+    public function update()
     {
-        if ( is_int( $group ) ) {
-            if ( ! array_key_exists( $group, self::$group_names ) ) {
-                Session::notice( _t('That group does not exist.' ) );
-                return false;
+        $allow= true;
+        // Allow plugins to disallow updating the group, by changing $allow
+        $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 ( !empty($this->new_members) ) {
+            // add this group's new members
+            foreach ($this->new_members as $new_member) {
+                $result= DB::query( 'INSERT INTO {users_groups} (user_id, group_id) VALUES (?, ?)', array( $new_member->id, $this->id ) );
+                EventLog::log('User ' . $new_member->username . ' added to group ' . $this->name, 'info', 'default', 'habari');
             }
-        } else {
-            if ( ! in_array( $group, self::$group_names ) ) {
-                Session::notice( _t('That group does not exist.' ) );
-                return false;
+        }
+        if ( !empty($this->removed_members) ) {
+            // remove this group's removed members
+            foreach ($this->removed_members as $removed_member) {
+                $result= DB::query( 'DELETE FROM {users_groups} WHERE user_id=? AND group_id=?', array( $removed_member->id, $this->id ) );
+                EventLog::log('User ' . $removed_member->username . ' removed from group ' . $this->name, 'info', 'default', 'habari');
             }
-            $groups= array_flip( self::$group_names );
-            $group= $groups[ $group ];
         }
-        $allow= true;
-        $allow= Plugins::filter('usergroup_insert_allow', $allow );
-        if ( ! $allow ) {
-            return false;
+        // add this group's new permissions
+        //$result= DB::query( 'DELETE FROM {groups_permissions} WHERE group_id=?', array( $this->id ) );
+        Plugins::act('usergroup_update_after', $this);
+    }
+
+    /**
+     * Delete a UserGroup
+    **/
+    public function delete()
+    {
+        // If all goes according plan, $result will stay true
+        $result= true;
+        // Allow plugins to disallow removing the group, by changing $result
+        $result= Plugins::filter('usergroup_delete_allow', $result, $this );
+        // If still allowed, remove the group
+        if ( $result ) {
+            Plugins::act('usergroup_delete_before', $this);
+            // If anything fails, this will return false. Perhaps this isn't the right thing to do.
+            // remove all this group's permissions
+            $result= DB::query( 'DELETE FROM {groups_permissions} WHERE group_id=?', array( $this->id ) ) && $result;
+            // remove all this group's members
+            $result= DB::query( 'DELETE FROM {users_groups} WHERE group_id=?', array( $this->id ) ) && $result;
+            // remove this group
+            $result= parent::deleteRecord( DB::table('groups'), array( 'id' => $this->id ) ) && $result;
+            Plugins::act('usergroup_delete_after', $this);
+            EventLog::log('Group created: ' . $this->name, 'info', 'default', 'habari');
         }
-        Plugins::act('usergroup_remove_before');
-        // delete the group
-        $results= DB::query( 'DELETE FROM {groups} WHERE id=?', array( $group) );
-        // and delete any members assigned to the group
-        $results= DB::query( 'DELETE FROM {users_groups} WHERE group_id=?', array( $group ) );
-        Plugins::act('usergroup_remove_after');
-        self::load_groups();
-        return true;
+        return $result;
     }
 
     /**
      * function members
-     * returns an array of user IDs belogning to the specified group
-     * @param int a group ID
-     * @return array an array of user IDs
+     * returns an array of users belonging to this UserGroup
+     * @return array an array of Users that belong to this group
     **/
-    public static function members( $group )
+    public function members()
     {
-        $members= array();
-        if ( isset( self::$groups[ intval($group) ] ) ) {
-            $members= self::$groups[ intval($group) ];
+        return $this->members;
+    }
+
+    /**
+     * Helper function to add a user to this group
+     * @param mixed a user ID or name
+    **/
+    private function add_user( $param )
+    {
+        $user= User::get($param);
+        // Add the user if not already in the group
+        if ( !in_array( $user, $this->members ) && !in_array( $user, $this->new_members ) ) {
+            $this->new_members[]= $user;
         }
-        return $members;
+        return true;
     }
-    
+
     /**
-     * Add a user to a group
-     * @param int a group ID
-     * @param int a user ID
+     * Add a user or users to this group
+     * @param mixed a user ID or name, or an array of them
     **/
-    public static function add_user( $group, $id )
+    public function add( $param )
     {
-        if ( empty( self::$groups[ intval( $group) ] ) || ! in_array( self::$groups[ intval($group) ], $id ) )
-        {
-            $results= DB::query( 'INSERT INTO ' . DB::table('users_groups') . ' (group_id, user_id) VALUES (?, ?)', array( intval($group), intval($id) ) );
-            $groups= self::load_groups();
+        if ( is_array( $param ) ) {
+            foreach ( $param as $user ) {
+                $this->add_user($user);
+            }
+        } 
+        else {
+            $this->add_user($param);
         }
-        $user= User::get_by_id( $id );
-        Session::notice( sprintf( _t('Added %1s to %2s'), $user->username, self::$group_names[$group] ) );
+        return true;
     }
 
     /**
-     * Remove a user from a group
-     * @param int a group ID
-     * @param int a user ID
+     * Helper function to remove a user from this group
+     * @param mixed a user ID or name
     **/
-    public static function remove_user( $group, $id )
+    private function remove_user( $param )
     {
-        if ( in_array( intval($id), self::$groups[ intval($group) ] ) ) {
-            $results= DB::query( 'DELETE FROM {users_groups} WHERE group_id=? and user_id= ?', array( intval($group), intval($id) ) );
-            $groups= self::load_groups();
+        $user= User::get($param);
+        // Remove the user if already in the group
+        if ( in_array( $user, $this->new_members ) ) {
+            unset($this->new_members[$user]);
         }
-        $user= User::get_by_id($id);
-        Session::notice( sprintf( _t('Removed %1s from %2s'), $user->username, self::$group_names[$group]) );
+        elseif ( in_array( $user, $this->members ) ) {
+            $this->removed_members[]= $user;
+        }
+        return true;
     }
 
     /**
-     * Assign a new permission to a group
-     * @param int A group ID
-     * @param int A permission ID
-     * @param int Whether this permission should be denied to this group
+     * Remove a user or users from this group
+     * @param mixed a user ID or name, or an array of them
     **/
-    public static function grant_permission( $group, $permission, $denied= 0 )
+    public function remove( $param )
     {
-        // first, see if this group has this permission
-        // either granted or denied
-        $check= DB::get_row('SELECT id,denied FROM ' . DB::table('groups_permissions') . ' WHERE group_id=? AND permission_id=?', array( intval($group), intval($permission) ) );
-        if ( ! empty( $check ) ) {
-            if ( $check->denied === intval($denied) ) {
-                // no change
-                return;
-            } else {
-                // the "denied" value is different, so update
-                // the existing record
-                DB::query('UPDATE ' . DB::table('groups_permissions') . ' SET denied=? WHERE id=?', array( intval($denied), $check->id) );
-                return;
+        if ( is_array( $param ) ) {
+            foreach ( $param as $user ) {
+                $this->remove_user($user);
             }
+        } 
+        else {
+            $this->remove_user($param);
         }
-        // We got here, which means that the permission does not yet
-        // exist.  Let's add it.
-        DB::query('INSERT INTO ' . DB::table('groups_permissions') . ' (group_id, permission_id, denied) VALUES ( ?, ?, ?)', array( intval($group), intval($permission), intval($denied) ) );
+        return true;
     }
 
     /**
+     * Assign a new permission to this group
+     * @param int A permission ID
+    **/
+    public function grant( $permission )
+    {
+    }
+
+    /**
+     * Deny a permission to this group
+     * @param int The permission ID to be denied
+    **/
+    public function deny( $permission )
+    {
+    }
+
+    /**
      * Remove a permission from a group
-     * @param int a group ID
      * @param int a permission ID
     **/
-    public static function revoke_permission( $group, $permission )
+    public function revoke( $permission )
     {
-        DB::query('DELETE FROM ' . DB::table('groups_permissions') . ' WHERE group_id=? and permission_id=?', array( intval($group), intval($permission) ) );
     }
 
     /**
      * Determine whether members of a group can do something
-     * @param int a group ID
      * @param string a text description of a permission
      * @return bool Whether the group can do the thing
     **/
-    public static function can( $group_id, $permission )
+    public function can( $permission )
     {
-        return ACL::group_can( intval($group_id), $permission );
+        return ACL::group_can( $this->id, $permission );
     }
+
+    /**
+     * Fetch a group from the database by name or ID.
+     * This is a wrapper function that will invoke the appropriate
+     * get_by_* method.
+     *
+     * @param mixed $group group ID or name
+     * @return object UserGroup object, or FALSE
+     */
+    public static function get( $group )
+    {
+        if ( is_int( $group ) ) {
+            // Got a UserGroup ID
+            $group= self::get_by_id( $group );
+        }
+        else {
+            // Got UserGroup name
+            $group= self::get_by_name( $group );
+        }
+        // $group will be a UserGroup object, or false depending
+        // on the results of the get_by_* method called above
+        return $group;
+    }
+
+    /**
+     * Select a group from the database by its id
+     *
+     * @param int $id
+     * @return Group
+     */
+    public static function get_by_id( $id ) {
+        if ( 0 == $id ) {
+            return false;
+        }
+
+        $params= array(
+            'id' => $id,
+        &